SimpleGraph.Adj.ne

theorem SimpleGraph.Adj.ne : ∀ {V : Type u} {G : SimpleGraph V} {a b : V}, G.Adj a b → a ≠ b := by sorry

This theorem states that for any type `V`, any Simple Graph `G` on `V`, and any two vertices `a` and `b` in `V`, if `a` and `b` are adjacent in `G` (denoted as `G.Adj a b`), then `a` and `b` must not be identical (i.e., `a ≠ b`). In other words, there are no self-loops in a Simple Graph.

In a simple graph, no vertex is adjacent to itself.


theorem Pi.lt_def :
    ∀ {ι : Type u} {α : ι → Type v} [inst : (i : ι) → Preorder (α i)] {x y : (i : ι) → α i},
      x < y ↔ x ≤ y ∧ ∃ i, x i < y i :=
  by sorry

The theorem `Pi.lt_def` states that for any type `ι` and any type map `α : ι → Type v`, given a Preorder on each type `α i`, for any two functions `x, y : (i : ι) → α i`, `x` is less than `y` if and only if `x` is less than or equal to `y` and there exists some `i` such that `x i` is strictly less than `y i`. This theorem essentially provides a definition for the "less than" relation in the context of these function spaces.

For any preordered type ι and type map α : ι → Type, the function space α → α has a "less than" relation defined as reflexive, transitive, and such that x < y if and only if x ≤ y and ∃ i, x i < y i.


FreeAbelianGroup.lift.of

theorem FreeAbelianGroup.lift.of :
    ∀ {α : Type u} {β : Type v} [inst : AddCommGroup β] (f : α → β) (x : α),
      (FreeAbelianGroup.lift f) (FreeAbelianGroup.of x) = f x :=
  by sorry

The theorem `FreeAbelianGroup.lift.of` states that for any type `α` and `β`, where `β` is an instance of an additive commutative group, and for any function `f` from `α` to `β`, and any element `x` of type `α`, the result of lifting `f` through the free abelian group of `α` and then applying it to the canonical map from `α` to its free abelian group applied to `x` is equal to directly applying `f` to `x`. This effectively asserts the compatibility of the lift operation with the canonical embedding into the free abelian group.

Given a type `α`, an additive commutative group `β`, and a function `f` from `α` to `β`, the lifted application of `f` to the free abelian group element represented by `x` in `α` equals the direct application of `f` to `x`.


theorem nhds_eq_comap_uniformity :
    ∀ {α : Type ua} [inst : UniformSpace α] {x : α}, nhds x = Filter.comap (Prod.mk x) (uniformity α) := by sorry

The theorem `nhds_eq_comap_uniformity` states that for any type `α` endowed with a `UniformSpace` structure, and for any element `x` of `α`, the neighborhood filter at `x` is equal to the comap of the function `Prod.mk x` and the uniformity of `α`. In simpler terms, this means that the set of all neighborhoods (sets containing an open set around `x`) is equivalent to taking the uniformity (a specific filter on the product of `α` with itself) and mapping it back along the function that sends an element to the pair consisting of `x` and that element. This theorem establishes an important correspondence between the concept of a neighborhood in topology and the concept of a uniformity in the context of uniform spaces.

The neighborhood filter of a point in a uniform space is equal to the composition of the point's evaluation function with the uniformity of the space.


theorem Int.add_lt_add_right : ∀ {a b : ℤ}, a < b → ∀ (c : ℤ), a + c < b + c := by sorry

This theorem states that for any two integers `a` and `b`, if `a` is less than `b`, then for any integer `c`, the sum of `a` and `c` is less than the sum of `b` and `c`. In other words, adding the same integer to both `a` and `b` maintains the original inequality between `a` and `b`. This is a property of the integers under addition and is a fundamental characteristic of the order structure on the integers.

For all integers a, b, and c, if a < b then a + c < b + c.


theorem smul_lt_smul_of_pos_right :
    ∀ {α : Type u_1} {β : Type u_2} {a₁ a₂ : α} {b : β} [inst : SMul α β] [inst_1 : Preorder α] [inst_2 : Preorder β]
      [inst_3 : Zero β] [inst_4 : SMulPosStrictMono α β], a₁ < a₂ → 0 < b → a₁ • b < a₂ • b :=
  by sorry

This theorem, named `smul_lt_smul_of_pos_right`, states that for any types `α` and `β`, given two elements `a₁` and `a₂` of type `α`, and an element `b` of type `β`, under the conditions that `α` is equipped with a scalar multiplication operation (`SMul α β`), `α` and `β` are both preordered (`Preorder α` and `Preorder β`), `β` has a zero (`Zero β`), and the scalar multiplication operation is strictly monotonically increasing when `b` is positive (`SMulPosStrictMono α β`), if `a₁` is less than `a₂` and `b` is greater than zero, then the result of scalar multiplication of `a₁` and `b` is less than the result of scalar multiplication of `a₂` and `b`. In mathematical notation, this can be written as: if $a_1 < a_2$ and $b > 0$, then $a_1 \cdot b < a_2 \cdot b$.

Given types `α` and `β` with scalar multiplication `SMul α β`, `Preorder α`, `Preorder β`, `Zero β`, and `SMulPosStrictMono α β`, if `a₁ < a₂` in `α` and `b > 0` in `β`, then `a₁ * b < a₂ * b`.


Function.Embedding.ext

theorem Function.Embedding.ext : ∀ {α : Sort u_1} {β : Sort u_2} {f g : α ↪ β}, (∀ (x : α), f x = g x) → f = g := by
  sorry

This theorem states that for any two function embeddings `f` and `g` from a sort `α` to another sort `β`, if for every element `x` in sort `α` the result of function `f` applied to `x` is equal to the result of function `g` applied to `x`, then the functions `f` and `g` are equal. In other words, two function embeddings between the same sorts are the same if they produce the same output for every input.

If two function embeddings from sort `α` to sort `β` agree on every element of `α`, then they are equal.


/-- Induction principle starting at a non-zero number. For maps to a `Sort*` see `leRecOn`.
To use in an induction proof, the syntax is `induction n, hn using Nat.le_induction` (or the same
for `induction'`).  -/
theorem Nat.le_induction :
    ∀ {m : ℕ} {P : (n : ℕ) → m ≤ n → Prop},
      P m ⋯ → (∀ (n : ℕ) (hmn : m ≤ n), P n hmn → P (n + 1) ⋯) → ∀ (n : ℕ) (hmn : m ≤ n), P n hmn :=
  by sorry

This is the induction principle starting at a non-zero number. For any natural number `m` and a property `P` that depends on a natural number `n` and the fact that `m` is less than or equal to `n`, if `P` holds for `m` and if, for any `n` where `P` holds, then `P` also holds for `n + 1`, then `P` holds for any `n` that is greater than or equal to `m`. This theorem is typically used in an induction proof with the syntax `induction n, hn using Nat.le_induction`.

The theorem states that if a property `P` holds for a natural number `m` less than or equal to `n`, and `P` holds for `n + 1` whenever it holds for `n`, then `P` holds for all natural numbers greater than or equal to `m`. (Natural number induction principle)


theorem uniformContinuous_const :
    ∀ {α : Type ua} {β : Type ub} [inst : UniformSpace α] [inst_1 : UniformSpace β] {b : β},
      UniformContinuous fun x => b :=
  by sorry

The theorem `uniformContinuous_const` asserts that for all types `α` and `β` equipped with uniform space structures, and for any constant `b` in `β`, the function that maps every element of `α` to this fixed constant `b` is uniformly continuous. This means that, no matter how close two points in `α` are (or where they are located in `α`), the corresponding points in `β` (which are both `b`) are always exactly the same. Therefore, the function preserves proximity: if two points are close in `α`, their images are just as close in `β`.

Given types `α` and `β` with uniform structures and a constant `b` in `β`, the function mapping all of `α` to `b` is a uniformly continuous function.


theorem MeasurableEmbedding.subtype_coe :
    ∀ {α : Type u_1} {mα : MeasurableSpace α} {s : Set α}, MeasurableSet s → MeasurableEmbedding Subtype.val := by sorry

This theorem states that for any type `α` with a `MeasurableSpace` structure (denoted as `mα`), and any set `s` of type `Set α`, if `s` is a measurable set (i.e., `MeasurableSet s` is true), then the function `Subtype.val` (which retrieves the underlying element from a subtype) is a measurable embedding. In other words, if we have a set of elements that form a measurable subset in a measurable space, the operation of retrieving the underlying elements from this set is a measurable process according to the measure space structure.

For any measurable space `(α, mα)` and measurable set `s ∈ Set α`, the function `Subtype.val : s → α` is a measurable function.


theorem Finset.prod_range_succ :
    ∀ {β : Type u_4} [inst : CommMonoid β] (f : ℕ → β) (n : ℕ),
      (Finset.prod (Finset.range (n + 1)) fun x => f x) = (Finset.prod (Finset.range n) fun x => f x) * f n :=
  by sorry

This theorem states that for any commutative monoid `β`, any function `f` from natural numbers to `β`, and any natural number `n`, the product of `f(x)` for each `x` in the set of natural numbers less than `n + 1` is equal to the product of `f(x)` for each `x` in the set of natural numbers less than `n` multiplied by `f(n)`. In other words, adding one more term to the range in the product changes the product by a factor of the function applied to the new term.

For any commutative monoid `β` and function `f` from natural numbers to `β`, the product of `f(x)` for `x` in the set of natural numbers less than `n + 1` equals the product of `f(x)` for `x` in the set of natural numbers less than `n` multiplied by `f(n)`.


theorem Set.sInter_image : ∀ {α : Type u_1} {β : Type u_2} (f : α → Set β) (s : Set α), ⋂₀ (f '' s) = ⋂ x ∈ s, f x := by
  sorry

This theorem, `Set.sInter_image`, states that for any types `α` and `β`, for any function `f` from `α` to a set of `β`, and for any set `s` of type `α`, the intersection over the image of `s` under `f` is equal to the intersection over all elements `x` in `s` of the sets `f(x)`. In mathematical notation, this says that if `f : α → P(β)` is a function and `s ⊆ α`, then `⋂₀ (f '' s) = ⋂_{x ∈ s} f(x)`, where `P(β)` denotes the power set of `β`, `f '' s` is the image of `s` under `f`, and `⋂₀` and `⋂_{x ∈ s}` denote intersection over a set and over elements in a set, respectively.

For any function `f : α → P(β)` and set `s ⊆ α`, the intersection of the image of `s` under `f` equals the intersection of `f(x)` over all `x ∈ s`. In mathematical notation, `⋂₀ (f '' s) = ⋂_{x ∈ s} f(x)`.


theorem Real.sqrt_sq : ∀ {x : ℝ}, 0 ≤ x → Real.sqrt (x ^ 2) = x := by sorry

The theorem `Real.sqrt_sq` states that for every real number `x`, given `x` is non-negative, the square root of the square of `x` is equal to `x` itself. In other words, if `x` is a non-negative real number, then applying the square root function to `x^2` returns `x`. In mathematical notation, this would be stated as: for all `x` in ℝ such that `x ≥ 0`, √(x^2) = x.

For all non-negative real numbers `x`, $\sqrt{x^2} = x$.


theorem Real.sq_sqrt : ∀ {x : ℝ}, 0 ≤ x → Real.sqrt x ^ 2 = x := by sorry

This theorem states that for all real numbers `x`, if `x` is greater than or equal to zero, then the square of the square root of `x` is equal to `x`. In mathematical terms, for any real number `x` such that `x ≥ 0`, we have `sqrt(x)² = x`.

For all real numbers `x` with `x ≥ 0`, `sqrt(x)² = x`.


theorem Rat.cast_neg : ∀ {α : Type u_3} [inst : DivisionRing α] (n : ℚ), ↑(-n) = -↑n := by sorry

The theorem `Rat.cast_neg` states that for all types `α` in the division ring `α`, for any rational number `n`, the negation of `n` cast to type `α` is equal to the negation of `n` cast to type `α`. In other words, negating a rational number and then casting it to another type has the same result as first casting the rational number to another type and then negating it.

For any type `α` in a division ring and rational number `n`, `-(Rat.cast _ α n) = Rat.cast _ α (-n)`.


theorem Mathlib.Data.Finset.Image._auxLemma.2 :
    ∀ {α : Type u_1} {β : Type u_2} {s : Finset α} {f : α ≃ β} {b : β},
      (b ∈ Finset.map (Equiv.toEmbedding f) s) = (f.symm b ∈ s) :=
  by sorry

This theorem states that for any types `α` and `β`, any finset `s` of type `α`, an equivalence relation `f` from `α` to `β`, and any element `b` of type `β`, the element `b` belongs to the image of the finset `s` under the mapping `f` if and only if the inverse image of `b` under `f` belongs to the finset `s`. In other words, it states that the image of a finset under an equivalence relation contains a particular element if and only if the original finset contains the preimage of that element.

For any equivalence relation f between types α and β, finset s ∈ α, and b ∈ β, the element b is in the image of s under f if and only if the inverse image of b under f is in s.


/-- See `zero_lt_two` for a version with the type implicit.  -/
theorem zero_lt_two' :
    ∀ (α : Type u_1) [inst : AddMonoidWithOne α] [inst_1 : PartialOrder α] [inst_2 : ZeroLEOneClass α]
      [inst_3 : NeZero 1] [inst_4 : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1], 0 < 2 :=
  by sorry

This theorem, `zero_lt_two'`, states that for any type `α` possessing certain properties (specifically, being an additive monoid with a distinguished element '1', having a partial order, satisfying the property that 0 is less than or equal to 1, that 1 is not zero, and that addition is a covariant operation), the value '0' is less than '2'. Here, '2' is likely understood as '1 + 1' in the context of the additive monoid. This theorem abstracts the common numerical fact that 0 is less than 2 into a more general setting.

For any additive monoid with unit '1' and partial order where 0 is less than 1 and 1 is non-zero, 0 is less than 1 + 1.


theorem Finset.univ_nonempty : ∀ {α : Type u_1} [inst : Fintype α] [inst_1 : Nonempty α], Finset.univ.Nonempty := by
  sorry

The theorem `Finset.univ_nonempty` states that for any type `α`, given that `α` is a finite type (`Fintype α`) and there exists at least one element of type `α` (`Nonempty α`), the universal set of `α` (`Finset.univ`) is not empty. In other words, if we have a nonempty finite type, its universal set must contain at least one element.

If `α` is a finite, nonempty type, then `Finset.univ α` is a nonempty set.


theorem MeasureTheory.MeasurePreserving.quasiMeasurePreserving :
    ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] [inst_1 : MeasurableSpace β]
      {μa : MeasureTheory.Measure α} {μb : MeasureTheory.Measure β} {f : α → β},
      MeasureTheory.MeasurePreserving f μa μb → MeasureTheory.Measure.QuasiMeasurePreserving f μa μb :=
  by sorry

This theorem states that for all types α and β, given that α and β are measurable spaces, and given measures μa on α and μb on β as well as a function f from α to β, if f is a measure-preserving function from μa to μb, then f is also quasi-measure-preserving. In other words, any function that preserves measures also preserves them in the weaker sense of being quasi-measure-preserving.

If $f:\alpha \to \beta$ is a measure-preserving function between measurable spaces $(\alpha, \mu_a)$ and $(\beta, \mu_b)$, then $f$ is quasi-measure-preserving.


theorem Complex.ofReal_ne_zero : ∀ {z : ℝ}, ↑z ≠ 0 ↔ z ≠ 0 := by sorry

This theorem states that for any real number `z`, the complex representation of `z` (denoted by `↑z`) is not equal to zero if and only if `z` is not equal to zero. In other words, a real number and its complex representation are simultaneously non-zero.

For any real number `z`, `↑z ≠ 0` if and only if `z ≠ 0`.


theorem Ideal.mem_map_of_mem :
    ∀ {R : Type u} {S : Type v} {F : Type u_1} [inst : Semiring R] [inst_1 : Semiring S] [inst_2 : FunLike F R S]
      (f : F) {I : Ideal R} {x : R}, x ∈ I → f x ∈ Ideal.map f I :=
  by sorry

The theorem `Ideal.mem_map_of_mem` states that for any given semirings `R` and `S`, a function `f` of type `F` which is `FunLike` from `R` to `S`, an ideal `I` in `R`, and an element `x` in `R`, if the element `x` belongs to the ideal `I`, then the image of `x` under the function `f` belongs to the ideal mapped by `f` from `I`. This is essentially stating a property of map operation on ideals in the context of semirings.

If `f` is a function from semiring `R` to semiring `S` that is `FunLike`, `I` is an ideal of `R`, and `x` is an element of `I`, then `f(x)` belongs to the ideal `f''I` in `S`.


theorem AddUnits.neg_add : ∀ {α : Type u} [inst : AddMonoid α] (a : AddUnits α), ↑(-a) + ↑a = 0 := by sorry

This theorem, `AddUnits.neg_add`, states that for any type `α` that is an additive monoid, and for any additive unit `a` of this type, the sum of the negative of `a` and `a` itself is always equal to zero. It mirrors the familiar property of numbers that the addition of a number and its negative yields zero.

For any additive monoid type `α` and additive unit `a`, `-a + a = 0`.


theorem Polynomial.map_sub :
    ∀ {R : Type u} [inst : Ring R] {p q : Polynomial R} {S : Type u_1} [inst_1 : Ring S] (f : R →+* S),
      Polynomial.map f (p - q) = Polynomial.map f p - Polynomial.map f q :=
  by sorry

The theorem `Polynomial.map_sub` states that for any types `R` and `S` that are Rings, and any polynomials `p` and `q` over the ring `R`, and a ring homomorphism `f` from `R` to `S`, mapping the difference of the polynomials `p` and `q` across the ring homomorphism `f` results in the difference of the mappings of the individual polynomials. In other words, the map operation preserves subtraction in the domain of polynomials.

For any ring homomorphism $f$ from ring $R$ to ring $S$ and polynomials $p, q$ over $R$, we have $f(p - q) = f(p) - f(q)$.


Con.eq

/-- Two elements are related by a congruence relation `c` iff they are represented by the same
element of the quotient by `c`.  -/
theorem Con.eq : ∀ {M : Type u_1} [inst : Mul M] (c : Con M) {a b : M}, ↑a = ↑b ↔ c a b := by sorry

This theorem, `Con.eq`, states that for any type `M` equipped with a multiplication operation and any congruence relation `c` on `M`, two elements `a` and `b` from `M` are related by the congruence relation `c` if and only if they are represented by the same element in the quotient of `M` by `c`. In other words, `a` and `b` are congruent under the relation `c` precisely when their equivalence classes under `c` are the same.

For any type equipped with a multiplication operation and a congruence relation, two elements are congruent if and only if their equivalence classes under the relation are equal.


theorem CategoryTheory.Idempotents.Karoubi.comp_p :
    ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] {P Q : CategoryTheory.Idempotents.Karoubi C}
      (f : CategoryTheory.Idempotents.Karoubi.Hom P Q), CategoryTheory.CategoryStruct.comp f.f Q.p = f.f :=
  by sorry

The theorem `CategoryTheory.Idempotents.Karoubi.comp_p` states that for any category `C`, and for any two objects `P` and `Q` in the Karoubi envelope of `C` (i.e., the category obtained by 'adding' idempotents to `C`), if there exists a morphism `f` from `P` to `Q`, then the composition of `f.f` and `Q.p` (where `f.f` is the morphism underlying `f`, and `Q.p` is the idempotent associated with `Q`) is just `f.f`. In other words, the idempotent `Q.p` acts like an identity with respect to the composition operation on the morphism `f.f`.

In the Karoubi envelope of a category `C`, for any objects `P` and `Q` and morphism `f` from `P` to `Q`, the composition of `f.f` and `Q.p` equals `f.f`.


AddCommute.eq

/-- Equality behind `AddCommute a b`; useful for rewriting. -/
theorem AddCommute.eq : ∀ {S : Type u_2} [inst : Add S] {a b : S}, AddCommute a b → a + b = b + a := by sorry

This theorem states that for any type `S` equipped with an addition operation, and for any two elements `a` and `b` of type `S`, if `a` and `b` commute with respect to addition (i.e., `a + b` equals `b + a`), then the result of adding `a` and `b` is indeed equal to the result of adding `b` and `a`. This theorem can be practical for rewriting expressions involving the addition operation in Lean 4 proof scripts.

For any commutative additive type `S` and elements `a, b` in `S`, `a + b` equals `b + a`.


theorem Polynomial.map_one :
    ∀ {R : Type u} {S : Type v} [inst : Semiring R] [inst_1 : Semiring S] (f : R →+* S), Polynomial.map f 1 = 1 := by
  sorry

The theorem `Polynomial.map_one` states that for any given types `R` and `S` that are semirings (i.e. they obey the properties of addition and multiplication in a ring), and any ring homomorphism `f` from `R` to `S`, the mapping of the polynomial 1 (which is a constant polynomial) under `f` is also 1. In other words, this means that applying any ring homomorphism to the constant polynomial 1 always yields the constant polynomial 1.

For any semirings R and S and ring homomorphism f from R to S, f(1\_R) = 1\_S, where 1\_R is the multiplicative identity of R and 1\_S is the multiplicative identity of S.


theorem le_of_not_ge : ∀ {α : Type u} [inst : LinearOrder α] {a b : α}, ¬a ≥ b → a ≤ b := by sorry

This theorem, `le_of_not_ge`, states that for any type `α` having a linear order and for any two elements `a` and `b` of this type, if `a` is not greater than or equal to `b`, then `a` must be less than or equal to `b`. This is a fundamental property in ordered sets.

If `α` is a type with a linear order and `a` is not greater than or equal to `b` in `α`, then `a` is less than or equal to `b`.


theorem HomologicalComplex.congr_hom :
    ∀ {ι : Type u_1} {V : Type u} [inst : CategoryTheory.Category.{v, u} V]
      [inst_1 : CategoryTheory.Limits.HasZeroMorphisms V] {c : ComplexShape ι} {C D : HomologicalComplex V c}
      {f g : C ⟶ D}, f = g → ∀ (i : ι), f.f i = g.f i :=
  by sorry

This theorem, `HomologicalComplex.congr_hom`, states that for any two homomorphisms `f` and `g` from a homological complex `C` to another homological complex `D` in a category `V` with zero morphisms, if `f` and `g` are the same homomorphism, then for any object `i` in the indexing type `ι`, the component of `f` at `i` is the same as the component of `g` at `i`. This theorem essentially asserts that homomorphisms between homological complexes are determined by their components.

Given homological complexes `C` and `D` in a category `V` with zero morphisms, any equal homomorphisms `f` and `g` : `C` --> `D` have equal components `f i` and `g i` for all objects `i` in the indexing type `ι`.


theorem ENNReal.inv_mul_cancel : ∀ {a : ENNReal}, a ≠ 0 → a ≠ ⊤ → a⁻¹ * a = 1 := by sorry

The theorem `ENNReal.inv_mul_cancel` states that for all extended nonnegative real numbers `a`, where `a` is neither zero nor `∞`, the product of the multiplicative inverse of `a` and `a` itself is equal to 1. This is a property of division in standard real numbers being extended to the extended nonnegative real numbers. In mathematical terms, for any `a` in [0, ∞) excluding 0 and ∞, `a⁻¹ * a = 1`.

For all extended nonnegative real numbers $a$ different from zero and infinity, $a^{-1} \cdot a = 1$.


theorem Int.ofNat_zero : ↑0 = 0 := by sorry

This theorem, `Int.ofNat_zero`, states that the integer value of the natural number 0 is also 0. In other words, when a natural number 0 is converted to an integer in Lean 4, it remains 0.

The theorem asserts that the natural number 0 converts to the integer 0 in Lean 4.


theorem add_left_inj :
    ∀ {G : Type u_3} [inst : Add G] [inst_1 : IsRightCancelAdd G] (a : G) {b c : G}, b + a = c + a ↔ b = c := by sorry

This theorem states that, for any type `G` which is equipped with addition and has the right-cancellation property, if the addition of any element `a` with another element `b` equals to the addition of `a` with a third element `c`, then `b` is equal to `c`. In other words, if `b + a = c + a` then `b = c`. The right-cancellation property ensures that if you add the same quantity to two equal quantities, the results are still equal, which allows us to "cancel" `a` from both sides of the equation.

For type `G` with addition and right cancellation property, if `a + b = a + c`, then `b = c`.


theorem Int.cast_injective :
    ∀ {α : Type u_1} [inst : AddGroupWithOne α] [inst_1 : CharZero α], Function.Injective Int.cast := by sorry

The theorem `Int.cast_injective` states that for any type `α` that is an additive group with one (meaning it has a structure of an additive group with a distinct element identified as one), and that has the property of `CharZero` (meaning that any distinct integers map to distinct elements in `α`), the canonical function that casts an integer to an element of `α` is injective. In other words, distinct integers will always map to distinct elements of `α` under this casting function. This injection property guarantees that no information is lost when integers are cast to `α`, as the original integer can be uniquely recovered.

The canonical function from integers to an additive group with one and CharZero structure maps distinct integers to distinct group elements.


theorem MeasureTheory.Measure.measure_univ_eq_zero :
    ∀ {α : Type u_1} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α}, ↑↑μ Set.univ = 0 ↔ μ = 0 := by sorry

This theorem states that for any type `α`, any measurable space `m0` over `α`, and any measure `μ` from the measure theory, the measure of the universal set `Set.univ` is equal to zero if and only if the measure `μ` itself is zero. In other words, a measure is zero if it assigns zero measure to the entire space it is defined on, and conversely, if a measure is zero, then the measure it assigns to the entire space is zero. This is an important property in measure theory, allowing us to identify trivial or empty measures.

For any measure `μ` on a measurable space `(α, m0)`, `μ` assigns measure zero to the universal set `Set.univ` if and only if `μ` is the zero measure.


theorem Mathlib.Order.BoundedOrder._auxLemma.15 :
    ∀ {α : Type u} [inst : PartialOrder α] [inst_1 : OrderBot α] {a : α}, (a ≤ ⊥) = (a = ⊥) := by sorry

This theorem, named `Mathlib.Order.BoundedOrder._auxLemma.15`, states that for any type `α` that has a partial order and a bottom element (`⊥`), any element `a` of this type is less than or equal to the bottom element if and only if `a` is equal to the bottom element. This is a fundamental property of partially ordered sets with a smallest element, where anything less than or equal to the smallest element must necessarily be the smallest element itself.

For any partially ordered type with a bottom element, an element is less than or equal to the bottom element if and only if it is equal to the bottom element.


/-- For ideals in a Dedekind domain, to divide is to contain.  -/
theorem Ideal.dvd_iff_le :
    ∀ {A : Type u_2} [inst : CommRing A] [inst_1 : IsDedekindDomain A] {I J : Ideal A}, I ∣ J ↔ J ≤ I := by sorry

This theorem states that for ideals in a Dedekind domain, the concept of divisibility is equivalent to containment. More specifically, given a Dedekind domain `A` that is a commutative ring and two ideals `I` and `J` in `A`, the ideal `I` divides the ideal `J` if and only if `J` is contained within `I`. This means that if every element of `J` is also in `I`, then `I` divides `J`, and vice versa. This theorem is a critical property of ideals in Dedekind domains, which are an important class of rings in number theory and algebraic geometry.

In a commutative Dedekind domain, ideal containment is equivalent to divisibility.


theorem Complex.conj_ofReal : ∀ (r : ℝ), (starRingEnd ℂ) ↑r = ↑r := by sorry

This theorem states that for any real number `r`, the conjugate of `r` when it is considered as a complex number (that is, converted from real to complex using `↑r`) is equal to `r` itself. In mathematical terms, if we denote complex conjugation by `starRingEnd ℂ`, this theorem says for every real number `r`, `(starRingEnd ℂ) ↑r = ↑r`. This is expected as the complex conjugate of a real number is the number itself, since it has no imaginary part to be negated.

The real part of a complex number is equal to its complex conjugate for any real number. In Lean notation, `(starRingEnd ℂ) ↑r = ↑r` for all real numbers `r`.


theorem MeasureTheory.Measure.measurePreserving_swap :
    ∀ {α : Type u_1} {β : Type u_3} [inst : MeasurableSpace α] [inst_1 : MeasurableSpace β]
      {μ : MeasureTheory.Measure α} {ν : MeasureTheory.Measure β} [inst_2 : MeasureTheory.SFinite ν]
      [inst_3 : MeasureTheory.SFinite μ],
      MeasureTheory.MeasurePreserving Prod.swap (MeasureTheory.Measure.prod μ ν) (MeasureTheory.Measure.prod ν μ) :=
  by sorry

The theorem `MeasureTheory.Measure.measurePreserving_swap` states that for any pair of types `α` and `β` equipped with structures of measurable spaces and measures `μ` and `ν` respectively, where both measures are sigma-finite, the function `Prod.swap` is measure-preserving with respect to the product measures on `α × β` and `β × α`. In other words, swapping the factors in the product of two measures does not change the product measure. This corresponds to the mathematical statement that the product of two measures is invariant under the swap of the factors, assuming both measures are sigma-finite.

For any sigma-finite measurable spaces `(α, Σα, μ)` and `(β, Σβ, ν)`, the product measures `μ ⨝ ν` and `ν ⨝ μ` on `α × β` are equal.


theorem Set.union_subset_union : ∀ {α : Type u} {s₁ s₂ t₁ t₂ : Set α}, s₁ ⊆ s₂ → t₁ ⊆ t₂ → s₁ ∪ t₁ ⊆ s₂ ∪ t₂ := by sorry

This theorem states that for all types `α` and any sets `s₁`, `s₂`, `t₁`, and `t₂` of type `α`, if `s₁` is a subset of `s₂` and `t₁` is a subset of `t₂`, then the union of `s₁` and `t₁` is also a subset of the union of `s₂` and `t₂`. In mathematical terms, if $s_1 \subseteq s_2$ and $t_1 \subseteq t_2$, then $s_1 \cup t_1 \subseteq s_2 \cup t_2$.

Given sets `s₁`, `s₂`, `t₁`, and `t₂` of type `α`, if `s₁ ⊆ s₂` and `t₁ ⊆ t₂`, then `s₁ ∪ t₁ ⊆ s₂ ∪ t₂`.


This theorem, `not_false`, asserts that "not false" is true. In other words, it states that the negation of falsehood is a valid statement or true. This is a basic principle of logic, expressed here in the formal language of the Lean 4 theorem prover.

The theorem `not_false` asserts that the negation of false is true. In mathematical terms, this is equivalent to saying that ⊥ (the logical false) and ⊥⊥ (the negation of logical false) are equivalent.


theorem WithBot.coe_eq_coe : ∀ {α : Type u_1} {a b : α}, ↑a = ↑b ↔ a = b := by sorry

This theorem, `WithBot.coe_eq_coe`, states that for any type `α` and for any two elements `a` and `b` of type `α`, the condition that the coercion of `a` to the `WithBot` type equals the coercion of `b` to the `WithBot` type is equivalent to `a` being equal to `b`. In other words, the coercions of two elements to the `WithBot` type are equal if and only if the elements themselves are equal.

For any type `α` and elements `a` and `b` of type `α`, `WithBot.coe a = WithBot.coe b` if and only if `a = b`.


CategoryTheory.Over.OverMorphism.ext

theorem CategoryTheory.Over.OverMorphism.ext :
    ∀ {T : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} T] {X : T} {U V : CategoryTheory.Over X} {f g : U ⟶ V},
      f.left = g.left → f = g :=
  by sorry

The theorem `CategoryTheory.Over.OverMorphism.ext` states that for any category `T` and any object `X` in `T`, given two objects `U` and `V` in the over category over `X`, and two morphisms `f` and `g` from `U` to `V` in this over category, if the underlying morphisms of `f` and `g` in the original category `T` are equal, then `f` and `g` themselves are equal. This essentially tells us that in the over category, the morphisms are determined by their underlying morphisms in the base category.

In the over category of an object X in a category T, two morphisms from U to V have the same underlying morphism in T imply they are equal as morphisms.


MeasureTheory.Lp.memℒp

theorem MeasureTheory.Lp.memℒp :
    ∀ {α : Type u_1} {E : Type u_2} {m0 : MeasurableSpace α} {p : ENNReal} {μ : MeasureTheory.Measure α}
      [inst : NormedAddCommGroup E] (f : ↥(MeasureTheory.Lp E p μ)), MeasureTheory.Memℒp (↑↑f) p μ :=
  by sorry

This theorem states that for any measure space `α`, normed additive commutative group `E`, extended nonnegative real numbers `p`, measure `μ` on `α`, and function `f` in the Lp space of measurable functions from `α` to `E`, the function `f` satisfies the property of being almost everywhere strongly measurable and having finite Lp norm (`∫ ‖f a‖^p ∂μ)^(1/p)` is finite if `p < ∞`, or `essSup f < ∞` if `p = ∞`). In other words, any function in the Lp space is in the set of functions for which the Lp norm is finite almost everywhere.

Any function in the Lp space of measurable functions from a measure space to a normed additive commutative group has finite Lp norm almost everywhere when the real number p is finite, or essential supremum is finite when p is infinite.


theorem Matrix.one_mul :
    ∀ {m : Type u_2} {n : Type u_3} {α : Type v} [inst : NonAssocSemiring α] [inst_1 : Fintype m]
      [inst_2 : DecidableEq m] (M : Matrix m n α), 1 * M = M :=
  by sorry

This theorem, `Matrix.one_mul`, states that for any types `m`, `n`, and `α` where `α` forms a nonassociative semiring, `m` has a finite number of distinct values and equality between elements of `m` is decidable, if `M` is a matrix with rows indexed by `m` and columns indexed by `n` and entries in `α`, then multiplying `M` by the multiplicative identity `1` results in `M` itself. In other words, for any such matrix `M`, `1 * M = M`.

For any nonassociative semiring `α` with decidable equality and finite number of distinct values, and given a matrix `M` over `α` with finite index sets, the multiplicative identity `1` multiplied by `M` equals `M`.


/-- If `a ≤ b`, then `(b, +∞) ⊆ (a, +∞)`. In preorders, this is just an implication. If you need
the equivalence in linear orders, use `Ioi_subset_Ioi_iff`.  -/
theorem Set.Ioi_subset_Ioi : ∀ {α : Type u_1} [inst : Preorder α] {a b : α}, a ≤ b → Set.Ioi b ⊆ Set.Ioi a := by sorry

This theorem states that, for any type `α` with a preorder structure (a structure in which elements can be compared as less than, equal, or greater than), if we have two elements `a` and `b` such that `a` is less than or equal to `b`, then the open, right-infinite interval starting from `b` is a subset of the open, right-infinite interval starting from `a`. In simpler terms, if `a` is not strictly greater than `b`, then all the elements strictly greater than `b` are also strictly greater than `a`. This is a simple implication in preorders. If you want the equivalent statement in linear orders, use the theorem `Ioi_subset_Ioi_iff`.

For any preorder `α`, if `a ≤ b` then the open right-interval `(b : α) ^+ := {x : α | ∃ (h : ℕ), x = a + h} ` is a subset of the open right-interval `(b : α) ^+ := {x : α | ∃ (h : ℕ), x = b + h} `.


theorem Set.image_iUnion :
    ∀ {α : Type u_1} {β : Type u_2} {ι : Sort u_4} {f : α → β} {s : ι → Set α}, f '' ⋃ i, s i = ⋃ i, f '' s i := by
  sorry

This theorem states that for any types `α` and `β`, for an arbitrary type `ι`, for any function `f` from `α` to `β`, and for any function `s` that assigns a set of `α` to each value of `ι`, the image under `f` of the union (over `ι`) of the sets `s i` is equal to the union (over `ι`) of the images of the sets `s i` under `f`. In other words, this is a formal statement of the property of the image of a union under a function, namely that the image of the union is the union of the images, written in terms of sets. This can be written in mathematical notation as: \(f\left(\bigcup\limits_{i} s_i\right) = \bigcup\limits_{i} f\left(s_i\right)\).

For any functions `f: α -> β` and `s: ι -> set α`, the image of the union of `s i` under `f` is equal to the union of the images of `s i` under `f`. In mathematical notation, `f(⋃i in ι s i) = ⋃i in ι (fs i)`.


theorem nhds_pi :
    ∀ {ι : Type u_5} {π : ι → Type u_6} [T : (i : ι) → TopologicalSpace (π i)] {a : (i : ι) → π i},
      nhds a = Filter.pi fun i => nhds (a i) :=
  by sorry

This theorem, `nhds_pi`, states that for any type `ι`, any function `π` from `ι` to another type, a topology `T` on the type space `π i` for each `i` in `ι`, and any function `a` from `ι` to `π i`, the neighborhood filter at `a` is equal to the product of the neighborhood filters at each `a i`. In other words, the neighborhood of a point in a product space is the product of the neighborhoods of the components of that point. Here, a product space is a space obtained by taking the Cartesian product of a family of spaces, and the Cartesian product of a family of sets is the set of all possible sequences that can be formed by selecting one member from each of the sets in the family.

For any function `π:` `ι` → Type, given topologies `T_i` on `π i` for each `i` in `ι`, and a function `a:` `ι` → `π i`, the neighborhood filter at `a` in the product space `∏ i, (π i, T_i)` is equal to the product of the neighborhood filters at `a i` in `(π i, T_i)`.


theorem Ordinal.opow_succ : ∀ (a b : Ordinal.{u_1}), a ^ Order.succ b = a ^ b * a := by sorry

The theorem `Ordinal.opow_succ` states that for any two ordinals `a` and `b`, the ordinal exponentiation of `a` to the successor of `b` (i.e., `a ^ Order.succ b`) equals the result of multiplying `a` to the power of `b` by `a` (i.e., `a ^ b * a`). This is similar to the basic property of exponentiation in elementary mathematics where `a` to the power of `n+1` is equal to `a` to the power of `n` times `a`.

For any ordinals `a` and `b`, `a^(Order.succ b)` equals `a^b * a`.


theorem le_zero_iff : ∀ {α : Type u_1} [inst : LinearOrderedCommMonoidWithZero α] {a : α}, a ≤ 0 ↔ a = 0 := by sorry

This theorem, `le_zero_iff`, is a statement about objects of a certain type, specifically a type `α` that forms a linearly ordered commutative monoid with zero. For any element `a` of this type, the theorem asserts that `a` is less than or equal to zero if and only if `a` is equal to zero. This captures the fact that in these algebraic structures, zero is the smallest element, and anything less than or equal to zero must in fact be zero itself.

For any element `a` in a commutative monoid with a zero, `a ≤ 0` if and only if `a = 0`.


theorem Nat.zero_lt_one : 0 < 1 := by sorry

This theorem states that zero is less than one in the set of natural numbers. In the language of mathematics, it is expressed as "0 < 1". This is a fundamental truth in number theory and is foundational to many other theorems and properties.

The theorem asserts that 0 is less than 1 in the natural numbers.


theorem Polynomial.degree_zero : ∀ {R : Type u} [inst : Semiring R], Polynomial.degree 0 = ⊥ := by sorry

The theorem `Polynomial.degree_zero` states that for any semiring `R` (a mathematical structure which behaves like the set of natural numbers under addition and multiplication), the degree of the zero polynomial (i.e., the polynomial where all coefficients are zero) is `⊥` (often read as 'bottom'). In other words, the highest power of `X` that appears in the zero polynomial is undefined, since the zero polynomial has no terms.

The degree of the zero polynomial in a semiring is undefined.


theorem MeasureTheory.Measure.map_id :
    ∀ {α : Type u_1} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α}, MeasureTheory.Measure.map id μ = μ := by
  sorry

The theorem `MeasureTheory.Measure.map_id` states that for any type `α`, any measurable space `m0` on `α`, and any measure `μ` on this measurable space, the pushforward of the measure `μ` under the identity function (`id`) is the same as the original measure `μ`. This is essentially saying that applying the identity function doesn't change the measure, which aligns with our intuitive understanding of the identity function.

For any measurable space `(α, Σ, m)` and measure `μ:` `Σ → ℝ`, the pushforward `id.pushforward μ` of `μ` under the identity function is equal to `μ`.


Multiset.induction

theorem Multiset.induction :
    ∀ {α : Type u_1} {p : Multiset α → Prop},
      p 0 → (∀ ⦃a : α⦄ {s : Multiset α}, p s → p (a ::ₘ s)) → ∀ (s : Multiset α), p s :=
  by sorry

The theorem `Multiset.induction` describes a method of induction on multisets. Given any type `α`, a property `p` that applies to multisets of `α`, we can prove that this property holds for all multisets of `α` if we can demonstrate two things. First, that the property `p` holds for the empty multiset (denoted by `0`). Second, if we can show that for any given element `a` of type `α` and any multiset `s` of `α`, if the property `p` holds for `s`, then it also holds for the multiset formed by prepending `a` to `s` (denoted by `a ::ₘ s`).

If a property holds for the empty multiset and is closed under prepending an element to a multiset, then it holds for all multisets.


theorem CategoryTheory.Adjunction.right_triangle_components :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂}
      [inst_1 : CategoryTheory.Category.{v₂, u₂} D] {F : CategoryTheory.Functor C D} {G : CategoryTheory.Functor D C}
      (adj : F ⊣ G) (Y : D),
      CategoryTheory.CategoryStruct.comp (adj.unit.app (G.obj Y)) (G.map (adj.counit.app Y)) =
        CategoryTheory.CategoryStruct.id (G.obj Y) :=
  by sorry

This theorem is about the right triangle identity in the context of an adjunction in category theory. For any two categories `C` and `D`, and a pair of functors `F` (from `C` to `D`) and `G` (from `D` to `C`) that form an adjunction, the theorem asserts the following: for any object `Y` in `D`, the composition of the unit of the adjunction (applied to `G(Y)`) and the morphism `G` applied to the counit of the adjunction (applied to `Y`) is equal to the identity morphism on `G(Y)`. This is one of the defining properties of adjunctions in category theory, expressed in the language of Lean 4. This theorem is a formalization of the following diagrammatic identity for an adjunction, commonly referred to as the "right triangle identity":

```
G(F(G(Y))) ---> G(Y)
 |                 |
 |                 | id_{G(Y)}
 V                 V
G(Y) ---> G(Y)
```

For any adjunction between categories `C` and `D` given by functors `F: C -> D` and `G: D -> C`, and for any object `Y` in `D`, the composition of the unit `G(η_Y)` and the counit `η_G(Y)` is equal to the identity morphism `id_{G Y}`, i.e., `G(η_Y) ∘ η_G(Y) = id_ {G Y}`.


theorem Filter.mem_atTop_sets :
    ∀ {α : Type u_3} [inst : Nonempty α] [inst : SemilatticeSup α] {s : Set α},
      s ∈ Filter.atTop ↔ ∃ a, ∀ b ≥ a, b ∈ s :=
  by sorry

This theorem states that for any type `α` which is both nonempty and a semi-lattice with a supremum operation, and for any set `s` of elements of this type, `s` lies in the filter `atTop` (which represents the limit as we approach infinity on an ordered set) if and only if there exists an element `a` such that for all elements `b` that are greater than or equal to `a`, `b` is an element of `s`. In other words, a set `s` is in the filter `atTop` iff there is a point from which onwards all elements belong to `s`.

For any nonempty type `α` with a supremum operation and any set `s` of elements from `α`, `s` lies in the filter `atTop` if and only if there exists an element `a` such that all elements greater than or equal to `a` are in `s`.


Part.ext

/-- `Part` extensionality  -/
theorem Part.ext : ∀ {α : Type u_1} {o p : Part α}, (∀ (a : α), a ∈ o ↔ a ∈ p) → o = p := by sorry

This theorem, `Part.ext`, states that for any type `α` and any two partial functions `o` and `p` of type `Part α`, if for every `α`, `α` belongs to `o` if and only if it belongs to `p`, then `o` and `p` are equivalent. In other words, two partial functions are the same if they have the same elements.

If two partial functions have the same domains and map each element in their domains to the same value, then they are equal.


theorem Int.neg_add : ∀ {a b : ℤ}, -(a + b) = -a + -b := by sorry

This theorem, `Int.neg_add`, states that for all integers `a` and `b`, the negation of the sum of `a` and `b` is equal to the sum of the negations of `a` and `b`. In other words, given any two integers, the negative of their sum is the same as the sum of their negatives. This is essentially a formal way of stating the distributive property of negation over addition for integers.

For all integers `a` and `b`, `-(a + b) = a + (-b)`.


theorem CategoryTheory.Adjunction.counit_naturality :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂}
      [inst_1 : CategoryTheory.Category.{v₂, u₂} D] {F : CategoryTheory.Functor C D} {G : CategoryTheory.Functor D C}
      (adj : F ⊣ G) {X Y : D} (f : X ⟶ Y),
      CategoryTheory.CategoryStruct.comp (F.map (G.map f)) (adj.counit.app Y) =
        CategoryTheory.CategoryStruct.comp (adj.counit.app X) f :=
  by sorry

This theorem, `CategoryTheory.Adjunction.counit_naturality`, is about the properties of adjunctions in category theory. Specifically, for any categories `C` and `D`, a pair of functors `F : C -> D` and `G : D -> C` forming an adjunction `adj : F ⊣ G`, and any morphism `f : X ⟶ Y` in `D`, the theorem states that the composition of the `F`-mapped version of `G.map f` and the counit of the adjunction at `Y` is the same as the composition of the counit of the adjunction at `X` and `f`.

In mathematical terms, this corresponds to the naturality condition for the counit of an adjunction, which can be written as `F(G(f)) ⋅ counit_Y = counit_X ⋅ f` in the notation of category theory. This property is central to the definition of an adjunction in category theory.

For any adjunction `F ⊣ G` between categories `C` and `D` and morphism `f : X ⟶ Y` in `D`, the composition of `F(G(f))` and the counit of `F` at `Y` equals the composition of the counit of `G` at `X` and `f`.


AffineMap.ext

/-- Two affine maps are equal if they coerce to the same function.  -/
theorem AffineMap.ext :
    ∀ {k : Type u_1} {V1 : Type u_2} {P1 : Type u_3} {V2 : Type u_4} {P2 : Type u_5} [inst : Ring k]
      [inst_1 : AddCommGroup V1] [inst_2 : Module k V1] [inst_3 : AddTorsor V1 P1] [inst_4 : AddCommGroup V2]
      [inst_5 : Module k V2] [inst_6 : AddTorsor V2 P2] {f g : P1 →ᵃ[k] P2}, (∀ (p : P1), f p = g p) → f = g :=
  by sorry

This theorem states that two affine maps are equal if they map every point in their domain to the same point in their codomain. More formally, for any type `k` forming a ring, types `V1` and `V2` forming additive commutative groups and being modules over `k`, types `P1` and `P2` being affine spaces over `V1` and `V2` respectively, and any two affine maps `f` and `g` from `P1` to `P2`, if for every point `p` in `P1`, `f` of `p` equals `g` of `p`, then `f` and `g` are equal.

If two affine maps between modules over a commutative ring and their corresponding affine spaces map every point to the same image, then they are equal.


theorem Polynomial.natDegree_eq_of_degree_eq :
    ∀ {R : Type u} {S : Type v} [inst : Semiring R] {p : Polynomial R} [inst_1 : Semiring S] {q : Polynomial S},
      Polynomial.degree p = Polynomial.degree q → Polynomial.natDegree p = Polynomial.natDegree q :=
  by sorry

The theorem states that for any two polynomials `p` and `q` over two potentially different semirings `R` and `S`, if the degree of `p` (the highest power of `X` that appears in `p`) is equal to the degree of `q` (the highest power of `X` that appears in `q`), then the natural degree of `p` (the degree forced to natural numbers, where the degree of the zero polynomial is defined as 0) is equal to the natural degree of `q`.

If two polynomials `p` and `q` over semirings `R` and `S` have equal degrees, then their natural degrees are equal.


theorem neg_le :
    ∀ {α : Type u} [inst : AddGroup α] [inst_1 : LE α]
      [inst_2 : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1]
      [inst_3 : CovariantClass α α (Function.swap fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] {a b : α},
      -a ≤ b ↔ -b ≤ a :=
  by sorry

The theorem `neg_le` establishes a relationship between the negations of two elements of a type `α`. This type `α` is a member of the `AddGroup` class, which means it has addition and subtraction operations, and it's also a member of the `LE` class, meaning that it has a less-or-equal-to operation. The theorem also requires two covariant classes: one for the regular addition operation and one for the swapped addition operation. Both of these classes also have a less-or-equal-to operation.

The theorem states that for any two elements `a` and `b` of type `α`, `-a` is less than or equal to `b` if and only if `-b` is less than or equal to `a`. In other words, the negation of `a` is less or equal to `b` if the negation of `b` is less or equal to `a`, and vice versa.

For all `α` in `AddGroup` and `LE` classes, and for all `a` and `b` in `α`, `-a ≤ b` if and only if `-b ≤ a`.


theorem Polynomial.natDegree_zero : ∀ {R : Type u} [inst : Semiring R], Polynomial.natDegree 0 = 0 := by sorry

This theorem states that, for any type `R` that is a semiring, the natural degree of the zero polynomial is zero. In other words, when the polynomial is `0`, its degree is also `0`. This adheres to the general mathematical principle that the degree of the zero polynomial is defined to be zero.

For any semiring type R, the degree of the zero polynomial is 0.


theorem Polynomial.coeff_C :
    ∀ {R : Type u} {a : R} {n : ℕ} [inst : Semiring R], Polynomial.coeff (Polynomial.C a) n = if n = 0 then a else 0 :=
  by sorry

The theorem `Polynomial.coeff_C` states that for any type `R` which is a semiring, any element `a` of `R`, and any natural number `n`, the coefficient of `X^n` in the constant polynomial `a` is `a` if `n` is 0 and 0 otherwise. In other words, the only nonzero coefficient of a constant polynomial is the constant itself, which is the coefficient of `X^0`.

For any semiring `R` and element `a` in `R`, the coefficient of `X^0` in the polynomial `a` is `a`, while the coefficients of all other powers of `X` are `0`.


theorem inner_add_left :
    ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
      (x y z : E), ⟪x + y, z⟫_𝕜 = ⟪x, z⟫_𝕜 + ⟪y, z⟫_𝕜 :=
  by sorry

This theorem, named 'inner_add_left', states that for any type 𝕜 and any normed add commutative group E, which also forms an inner product space over 𝕜, the inner product of the sum of two elements (x and y) and a third element z is equal to the sum of the inner products of x and z, and y and z. In mathematical notation, this could be written as: ⟪x + y, z⟫_𝕜 = ⟪x, z⟫_𝕜 + ⟪y, z⟫_𝕜. This property is fundamental to the theory of inner product spaces.

For any normed add commutative group E that is also an inner product space over field 𝕜, the inner product of the sum of two elements x and y, and a third element z, equals the sum of the inner products of x and z, and y and z: ⟪x + y, z⟫_𝕜 = ⟪x, z⟫_𝕜 + ⟪y, z⟫_𝕜.


theorem Associates.mk_eq_mk_iff_associated :
    ∀ {α : Type u_1} [inst : Monoid α] {a b : α}, Associates.mk a = Associates.mk b ↔ Associated a b := by sorry

This theorem states that for any type `α` that forms a `Monoid`, two elements `a` and `b` of `α` have the same `Associates` via the `Associates.mk` function if and only if `a` and `b` are `Associated`. In mathematical terms, `a` and `b` are `Associated` if there exists a unit `u` such that `a` multiplied by `u` equals `b`.

For any monoid type `α` and elements `a` and `b` of `α`, `a` and `b` have the same associates if and only if they are associated through a unit.


CategoryTheory.IsSplitEpi.mk'

/-- A constructor for `IsSplitEpi f` taking a `SplitEpi f` as an argument  -/
theorem CategoryTheory.IsSplitEpi.mk' :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X Y : C} {f : X ⟶ Y},
      CategoryTheory.SplitEpi f → CategoryTheory.IsSplitEpi f :=
  by sorry

This theorem is a constructor for the `IsSplitEpi` property of a morphism `f` in category theory, given that `f` is a `SplitEpi` (split epimorphism). Specifically, for any category `C`, and objects `X` and `Y` in `C`, if there is a morphism `f` from `X` to `Y` that is a split epimorphism, then `f` is an `IsSplitEpi`, i.e., has the "is split epimorphism" property.

In any category, a split epimorphism is an object with the "is split epimorphism" property.


theorem Multiset.sum_replicate :
    ∀ {α : Type u_2} [inst : AddCommMonoid α] (n : ℕ) (a : α), Multiset.sum (Multiset.replicate n a) = n • a := by sorry

The theorem `Multiset.sum_replicate` states that for any type `α` that has a commutative additive monoid structure, and for any natural number `n` and any element `a` of type `α`, the sum of a multiset created by replicating `a` `n` times is equal to `n` times `a`. This means that if you create a multiset with `n` copies of `a` and then sum them all up, you get the same result as if you just multiplied `a` by `n`. The symbol `•` denotes scalar multiplication in this context.

For any commutative additive monoid type `α` and natural number `n`, the sum of `n` copies of an element `a` in a multiset equals `n • a`.


theorem AlgHom.map_add :
    ∀ {R : Type u} {A : Type v} {B : Type w} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Semiring B]
      [inst_3 : Algebra R A] [inst_4 : Algebra R B] (φ : A →ₐ[R] B) (r s : A), φ (r + s) = φ r + φ s :=
  by sorry

This theorem states that for any commutative semiring `R`, semiring `A`, and semiring `B`, given that `A` and `B` are `R`-algebras, an algebra homomorphism `φ` from `A` to `B` preserves addition. In other words, for any elements `r` and `s` in `A`, the image of the sum (`r + s`) under `φ` is the sum of the images (`φ r + φ s`). This is a property of algebra homomorphisms, which must preserve both the algebraic structure (operation-preserving) and the scalar multiplication.

Given commutative semirings `R`, semirings `A` and `B`, and an `R`-algebra homomorphism `φ` from `A` to `B`, for all elements `r` and `s` in `A`, we have `φ(r + s) = φ(r) + φ(s)`.


theorem Cardinal.mk_eq_zero : ∀ (α : Type u) [inst : IsEmpty α], Cardinal.mk α = 0 := by sorry

The theorem `Cardinal.mk_eq_zero` states that for any type `α`, if `α` is an empty type (i.e., it has no elements), then the cardinality of `α` is zero. In other words, the number of elements in an empty type is zero.

If a type has no elements, then its cardinality is zero.


theorem Function.id_comp : ∀ {α : Sort u₁} {β : Sort u₂} (f : α → β), id ∘ f = f := by sorry

This theorem, named `Function.id_comp`, states that for all functions `f` from some sort `α` to another sort `β`, the composition of the identity function `id` and `f` is equal to `f` itself. In other words, if you first apply `f` and then apply the identity function, it's the same as just applying `f`. This is a formalization of one of the basic properties of the identity function in function composition, as usually expressed in mathematics by \(id \circ f = f\).

The identity function's composition with any function `f` is equal to `f`. In mathematical notation: `id ∘ f = f`.


theorem Filter.monotone_principal : ∀ {α : Type u}, Monotone Filter.principal := by sorry

The theorem `Filter.monotone_principal` states that for any given type `α`, the function `Filter.principal` is monotone. This means that if we have two sets `a` and `b` of type `α` such that `a` is a subset of `b`, then the principal filter of `a` is a subset of the principal filter of `b`. In other words, the creation of principal filters by the function `Filter.principal` respects the order of the input sets, making it monotone.

For any type `α` and sets `a` and `b` of type `α`, if `a` is a subset of `b`, then `Filter.principal a` is a subset of `Filter.principal b`.


SetCoe.ext

theorem SetCoe.ext : ∀ {α : Type u} {s : Set α} {a b : ↑s}, ↑a = ↑b → a = b := by sorry

The theorem `SetCoe.ext` states that for any type `α` and any set `s` of type `α`, given any two elements `a` and `b` of the subtype corresponding to `s`, if the elements `a` and `b`, when considered as elements of the original type `α` (by applying the coercion function `↑`), are equal, then `a` and `b` themselves (considered as elements of the subtype) are also equal. This essentially says that equality within the original type implies equality within the subtype.

If `α` is a type and `s : Set α` is a subset, then for all `a, b ∈ s`, `a = b` in `α` implies `a = b` in `s`.


theorem Int.floor_le : ∀ {α : Type u_2} [inst : LinearOrderedRing α] [inst_1 : FloorRing α] (a : α), ↑⌊a⌋ ≤ a := by
  sorry

This theorem, `Int.floor_le`, asserts that for any type `α` that is a linearly ordered ring and also a floor ring, the floor of any element `a` of type `α` is less than or equal to `a`. In mathematical terms, for every `a` in `α`, `⌊a⌋ ≤ a`. Here, `⌊a⌋` represents the greatest integer less than or equal to `a`, known as the floor of `a`.

For any element `a` in a linearly ordered ring and floor ring `α`, the floor of `a`, `⌊a⌋`, is less than or equal to `a`.


theorem measurableSet_le :
    ∀ {α : Type u_1} {δ : Type u_5} [inst : TopologicalSpace α] [inst_1 : MeasurableSpace α]
      [inst_2 : OpensMeasurableSpace α] [inst_3 : MeasurableSpace δ] [inst_4 : PartialOrder α]
      [inst_5 : OrderClosedTopology α] [inst : SecondCountableTopology α] {f g : δ → α},
      Measurable f → Measurable g → MeasurableSet {a | f a ≤ g a} :=
  by sorry

The theorem `measurableSet_le` states that for any two functions `f` and `g` from a measurable space `δ` to a topological space `α` that is also a measurable space, if `f` and `g` are both measurable functions and `α` has a partial order and a second countable topology that is closed under the order, then the set of all elements `a` from the domain for which the value of `f` at `a` is less than or equal to the value of `g` at `a` is a measurable set.

A function from a measurable space to a second countable, order-closed topological space that preserves the order and is measurable, maps measurable sets to measurable sets. (The theorem `measurableSet_le` states that the set of elements where the function value of one function is less than or equal to that of another is such a measurable set.)


theorem CategoryTheory.IsIso.inv_eq_of_hom_inv_id :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} {f : X ⟶ Y} [inst_1 : CategoryTheory.IsIso f]
      {g : Y ⟶ X},
      CategoryTheory.CategoryStruct.comp f g = CategoryTheory.CategoryStruct.id X → CategoryTheory.inv f = g :=
  by sorry

The theorem `CategoryTheory.IsIso.inv_eq_of_hom_inv_id` states that for any category `C` and objects `X` and `Y` within `C`, if there is an isomorphism `f` from `X` to `Y` and another morphism `g` from `Y` to `X`, such that the composition of `f` and `g` equals the identity on `X`, then `g` is the inverse of `f`. In other words, if composing `f` with `g` results in the identity morphism (doing nothing), then `g` undoes exactly what `f` does and so `g` is the inverse of `f`.

If in a category, the composition of an isomorphism with its right inverse equals the identity morphism, then they are inverses of each other.


/-- The rank of a finite module is finite.  -/
theorem rank_lt_aleph0 :
    ∀ (R : Type u) (M : Type v) [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M]
      [inst_3 : StrongRankCondition R] [inst_4 : Module.Finite R M], Module.rank R M < Cardinal.aleph0 :=
  by sorry

The theorem `rank_lt_aleph0` states that for any type `R` and `M`, given `R` is a ring, `M` is an additive commutative group, `M` is a module over `R`, `R` satisfies the strong rank condition and `M` is a finite module over `R`, the rank of the module `M` is less than `ℵ₀`, the smallest infinite cardinal. In other words, the rank of a finite module is always finite.

The rank of a finite module over a ring satisfying the strong rank condition is a finite number.


theorem Finset.weightedVSubOfPoint_apply :
    ∀ {k : Type u_1} {V : Type u_2} {P : Type u_3} [inst : Ring k] [inst_1 : AddCommGroup V] [inst_2 : Module k V]
      [S : AddTorsor V P] {ι : Type u_4} (s : Finset ι) (w : ι → k) (p : ι → P) (b : P),
      (Finset.weightedVSubOfPoint s p b) w = Finset.sum s fun i => w i • (p i -ᵥ b) :=
  by sorry

The theorem `Finset.weightedVSubOfPoint_apply` states that for any types `k`, `V`, `P`, `ι`, given a ring structure on `k`, an additive commutative group structure on `V`, a module structure of `k` over `V`, an additive torsor structure of `V` over `P`, a finite set `s` of elements of type `ι`, a weight function `w` mapping elements of `ι` to `k`, a point function `p` mapping elements of `ι` to `P`, and a reference point `b` of type `P`, the weighted difference of vectors from `b` to points `p i` in `s` according to the weight function `w` is equal to the sum over `s` of the scaled vectors `w i • (p i -ᵥ b)`.

In mathematical terms, $\sum_{i\in s} w(i)\cdot (p(i)-b)$ gives the weighted difference of vectors from `b` to `p i` for each `i` in the finite set `s`, where the scaling of each vector is determined by the function `w`.

For any finite set `s`, weight function `w`, additive torsor `P`, point function `p`, module structure `V`, ring `k`, and reference point `b`, the weighted difference of vectors from `b` to `p i` for each `i` in `s`, where the scaling of each vector is determined by `w`, equals the sum over `s` of the scaled vectors `w i • (p i - b)`.


theorem Int.natAbs_pos : ∀ {a : ℤ}, 0 < Int.natAbs a ↔ a ≠ 0 := by sorry

This theorem states that for any integer `a`, the absolute value of `a` (denoted `Int.natAbs a`) is greater than zero if and only if `a` is not equal to zero. In other words, the absolute value of an integer is positive precisely when that integer is non-zero.

For any integer `a`, `Int.natAbs a > 0` if and only if `a` is non-zero.


theorem Set.iUnion_mono :
    ∀ {α : Type u_1} {ι : Sort u_4} {s t : ι → Set α}, (∀ (i : ι), s i ⊆ t i) → ⋃ i, s i ⊆ ⋃ i, t i := by sorry

The theorem `Set.iUnion_mono` states that for any type `α` and any index type `ι`, if `s` and `t` are two indexed families of sets of `α` such that every set `s i` is a subset of `t i` for each index `i` in `ι`, then the union over all `s i` (denoted as `⋃ i, s i`) is a subset of the union over all `t i` (denoted as `⋃ i, t i`). This theorem is asserting a kind of monotonicity property of indexed union operation over sets: if each individual set in one family is contained in the corresponding set in another family, then the whole union of the first family is contained in the union of the second one.

If for each index `i`, set `s i` is a subset of `t i`, then the indexed union of `s` is a subset of the indexed union of `t`. In symbols, `⋃ i, s i ⊆ ⋃ i, t i`.


theorem Finset.sum_comm :
    ∀ {α : Type u_3} {β : Type u_4} {γ : Type u_5} [inst : AddCommMonoid β] {s : Finset γ} {t : Finset α}
      {f : γ → α → β},
      (Finset.sum s fun x => Finset.sum t fun y => f x y) = Finset.sum t fun y => Finset.sum s fun x => f x y :=
  by sorry

The theorem `Finset.sum_comm` states that for all types `α`, `β`, and `γ`, given an additive commutative monoid over `β`, a finite set `s` of type `γ`, a finite set `t` of type `α`, and a function `f` from `γ` to `α` to `β`, the sum over `s` of the sums over `t` of `f x y` is equal to the sum over `t` of the sums over `s` of `f x y`. In mathematical terms, this theorem is stating the commutativity of the sum, i.e., $\sum_{x \in s} \sum_{y \in t} f(x, y) = \sum_{y \in t} \sum_{x \in s} f(x, y)$.

For all additive commutative monoids over type `β`, finite sets `s` of type `γ` and `t` of type `α`, and functions `f` from `γ` to `α` to `β`, the sum over `s` of the sums over `t` of `f x y` equals the sum over `t` of the sums over `s` of `f x y`. (Mathematically: $\sum\_{x \in s} \sum\_{y \in t} f(x, y) = \sum\_{y \in t} \sum\_{x \in s} f(x, y)$)


theorem CategoryTheory.Idempotents.Karoubi.p_comp :
    ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] {P Q : CategoryTheory.Idempotents.Karoubi C}
      (f : CategoryTheory.Idempotents.Karoubi.Hom P Q), CategoryTheory.CategoryStruct.comp P.p f.f = f.f :=
  by sorry

This theorem, `CategoryTheory.Idempotents.Karoubi.p_comp`, states that for any category `C`, and for any two objects `P` and `Q` in the Karoubi envelope of `C` (a construction that adds new objects to the category such that every idempotent morphism becomes an isomorphism), given a morphism `f` from `P` to `Q`, the composition of the projection of `P` and the morphism `f` is equal to `f` itself. This is a property in the context of idempotent completion, highlighting the nature of the Karoubi envelope in dealing with idempotent morphisms.

In the Karoubi envelope of a category `C`, for any object `P`, any object `Q`, and any morphism `f` from `P` to `Q` of idempotent source and target, the projection of `P` followed by `f` equals `f`.


theorem le_of_add_le_add_right :
    ∀ {α : Type u_1} [inst : Add α] [inst_1 : LE α]
      [i : ContravariantClass α α (Function.swap fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] {a b c : α},
      b + a ≤ c + a → b ≤ c :=
  by sorry

The theorem `le_of_add_le_add_right` states that for all types `α` equipped with an addition operator and a less-than-or-equal-to relation, and for which the less-than-or-equal-to relation is contravariant with respect to swapping the arguments of the addition operation, if `b + a` is less than or equal to `c + a` for any elements `a`, `b`, and `c` of type `α`, then `b` must be less than or equal to `c`. This essentially captures the intuitive property of "cancelling" the same quantity from both sides of an inequality.

If for all `α` with addition and `≤` such that `≤` is contravariant, `a ≤ b` implies `a + c ≤ b + c` for all `a, b, c` in `α`, then `b ≤ c`.


theorem Finite.exists_equiv_fin : ∀ (α : Sort u_3) [h : Finite α], ∃ n, Nonempty (α ≃ Fin n) := by sorry

For any type or sort `α` that is finite (as indicated by `h : Finite α`), there exists a natural number `n` such that there is a nonempty equivalence between type `α` and the finite sequence of natural numbers less than `n` (denoted by `Fin n`). Essentially, this theorem states that we can map any finite type to a finite sequence of natural numbers.

For any finite type `α`, there exists a natural number `n` such that there exists a bijective function from `α` to `Fin n`.


theorem neg_nonpos :
    ∀ {α : Type u} [inst : AddGroup α] [inst_1 : LE α]
      [inst_2 : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] {a : α}, -a ≤ 0 ↔ 0 ≤ a :=
  by sorry

This theorem, `neg_nonpos`, states that for all types `α` that have an additive group structure and an order `≤` that is compatible with the group operation (in the sense of the `CovariantClass` condition), the negation of a number `a` is non-positive if and only if `a` is non-negative. In mathematical notation, this can be expressed as `-a ≤ 0 ↔ 0 ≤ a`.

For all types `α` with an additive group structure and a compatible order, `-a ≤ 0 if and only if 0 ≤ a`.


theorem List.map_id' : ∀ {α : Type u_1} (l : List α), List.map (fun a => a) l = l := by sorry

The theorem `List.map_id'` states that for any list `l` of a certain type `α`, mapping the identity function `(fun a => a)` over `l` returns `l` itself. This means applying the identity function to each element of the list leaves the list unchanged. In mathematical terms, it's saying for each element `a` in list `l`, the list resulting from applying the identity function is equal to the original list `l`.

For any list `l` of type `α`, the application of the identity function to each element of `l` results in the same list `l`. In mathematical notation: `List.map (fun a => a) l = l` for all `l` of type `α list`.


/-- An induction principle for span membership. If `p` holds for 0 and all elements of `s`, and is
preserved under addition and scalar multiplication, then `p` holds for all elements of the span of
`s`.  -/
theorem Submodule.span_induction :
    ∀ {R : Type u_1} {M : Type u_4} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {x : M}
      {s : Set M} {p : M → Prop},
      x ∈ Submodule.span R s →
        (∀ x ∈ s, p x) → p 0 → (∀ (x y : M), p x → p y → p (x + y)) → (∀ (a : R) (x : M), p x → p (a • x)) → p x :=
  by sorry

This theorem, `Submodule.span_induction`, provides an induction principle for elements belonging to the span of a set in a module. More specifically, it states that if a property `p` holds for the zero element and all elements of a set `s` in a module `M` over a semiring `R`, and `p` is preserved under both addition and scalar multiplication, then `p` holds for all elements in the span of `s`. This induction principle is a crucial tool for making arguments about all elements of a spanned set in a module, typically in a linear algebraic context.

If a property holds for the zero element and is closed under addition and scalar multiplication for every element in a set in a module, then it holds for all elements in the span of that set.


LinearIsometry.isometry

theorem LinearIsometry.isometry :
    ∀ {R : Type u_1} {R₂ : Type u_2} {E : Type u_5} {E₂ : Type u_6} [inst : Semiring R] [inst_1 : Semiring R₂]
      {σ₁₂ : R →+* R₂} [inst_2 : SeminormedAddCommGroup E] [inst_3 : SeminormedAddCommGroup E₂] [inst_4 : Module R E]
      [inst_5 : Module R₂ E₂] (f : E →ₛₗᵢ[σ₁₂] E₂), Isometry ⇑f :=
  by sorry

The theorem asserts that a linear isometry between two seminormed add commutative groups, which are also modules over semirings, preserves the extended distance between points. In other words, for any semirings `R` and `R₂`, any seminormed add commutative groups `E` and `E₂`, any module structures on `E` over `R` and on `E₂` over `R₂`, and any ring homomorphism `σ₁₂` from `R` to `R₂`, if `f` is a linear isometry from `E` to `E₂` then the function `f` is an isometry. Here, an isometry is defined as a map which preserves the extended distance between points in the pseudoemetric space sense.

A linear isometry between two seminormed add commutative groups, equipped with module structures over compatible semirings, preserves the extended distances between points.


theorem isUnit_iff_ne_zero : ∀ {G₀ : Type u_3} [inst : GroupWithZero G₀] {a : G₀}, IsUnit a ↔ a ≠ 0 := by sorry

This theorem, `isUnit_iff_ne_zero`, states that for any type `G₀` which forms a group with a zero element (captured by the `GroupWithZero G₀` typeclass), and any element `a` of this type, `a` is a unit if and only if `a` is not equal to zero. Here, a unit is defined as an element that has a two-sided inverse.

In a group with a zero element, an element is a unit if and only if it is not equal to the zero element.


SimpleGraph.Subgraph.ext

theorem SimpleGraph.Subgraph.ext :
    ∀ {V : Type u} {G : SimpleGraph V} (x y : SimpleGraph.Subgraph G), x.verts = y.verts → x.Adj = y.Adj → x = y := by
  sorry

This theorem states that for any type `V` and any simple graph `G` of type `SimpleGraph V`, if we have two subgraphs `x` and `y` of `G`, and if the vertices `x.verts` of `x` are equal to the vertices `y.verts` of `y`, and also the adjacency relation `x.Adj` of `x` is equal to the adjacency relation `y.Adj` of `y`, then the two subgraphs `x` and `y` are in fact the same subgraph. In other words, two subgraphs are considered equal if they have the same vertices and the same adjacency relation.

given types `V` and a simple graph `G` of type `SimpleGraph V`, if `x` and `y` are subgraphs of `G` with equal vertices and identical adjacency relations, then `x = y`.


theorem Int.lt_add_one_iff : ∀ {a b : ℤ}, a < b + 1 ↔ a ≤ b := by sorry

This theorem, `Int.lt_add_one_iff`, is a statement about integer inequality. For all integers `a` and `b`, the theorem states that `a` is less than `b + 1` if and only if `a` is less than or equal to `b`. This theorem bridges the relational gap between less than and less than or equal, and demonstrates an interesting property of integer arithmetic.

For all integers `a` and `b`, `a` < `b` if and only if `a` <= `b` + 1.


theorem one_ne_zero' : ∀ (α : Type u_2) [inst : Zero α] [inst_1 : One α] [inst_2 : NeZero 1], 1 ≠ 0 := by sorry

This theorem states that for every data type `α`, given that this type has a zero element (as provided by the `Zero α` instance), a one element (given by `One α` instance), and that it's not possible for one to be equal to zero in type `α` (given by the `NeZero 1` instance), then one is not equal to zero in this type. In mathematical terms, this theorem asserts that ∀α, 1 ≠ 0 in the context where α has a zero, a one, and one is not equal to zero.

If type `α` has a zero element, a one element, and one is not equal to zero, then one is not equal to zero in `α`. In symbols, `∀α (Zero α : α) (One α : α) (NeZero 1 α : One α ≠ Zero α) : One α ≠ Zero α`.


theorem ENNReal.coe_inj : ∀ {p q : NNReal}, ↑p = ↑q ↔ p = q := by sorry

This theorem, named `ENNReal.coe_inj`, states that for any two nonnegative real numbers `p` and `q`, the equality of their coercions (i.e., their representations as extended nonnegative real numbers) implies the equality of `p` and `q` themselves. In other words, the process of coercion preserves equality in the set of nonnegative real numbers.

For all non-negative real numbers p and q, if p = q as extended real numbers then p = q.


theorem ENNReal.coe_inv : ∀ {r : NNReal}, r ≠ 0 → ↑r⁻¹ = (↑r)⁻¹ := by sorry

This theorem states that for any nonnegative real number `r` (represented as `NNReal`), if `r` is not equal to zero, then the inverse of the coerced `r` (i.e., `r` treated as an extended nonnegative real number, denoted by `↑r⁻¹`) is equal to the inverse of the coercion of `r` (denoted by `(↑r)⁻¹`). In simpler terms, when we inverse a nonnegative real number, it doesn't matter if we convert it to an extended nonnegative real number before or after taking the inverse; both processes yield the same result.

For any nonzero `r` in `NNReal`, `↑r⁻¹ = (↑r)⁻¹`.


DifferentiableAt.comp

theorem DifferentiableAt.comp :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F]
      {G : Type u_4} [inst_5 : NormedAddCommGroup G] [inst_6 : NormedSpace 𝕜 G] {f : E → F} (x : E) {g : F → G},
      DifferentiableAt 𝕜 g (f x) → DifferentiableAt 𝕜 f x → DifferentiableAt 𝕜 (g ∘ f) x :=
  by sorry

The theorem `DifferentiableAt.comp` states that for any non-trivial normed field `𝕜`, if `f` is a function from a normed space `E` over `𝕜` to another normed space `F` over `𝕜`, and `g` is a function from `F` to yet another normed space `G` over `𝕜`, then if `g` is differentiable at the point `f(x)`, and if `f` is also differentiable at the point `x`, then the function obtained by composing `g` and `f` (i.e., `g ∘ f`) is also differentiable at the point `x`. This theorem encapsulates the chain rule from calculus.

If `f:` X → Y is differentiable at `x ∈ X` and `g:` Y → Z is differentiable at `y = f(x)`, then the composition `g ∘ f:` X → Z is differentiable at `x`.


theorem not_isEmpty_iff : ∀ {α : Sort u_1}, ¬IsEmpty α ↔ Nonempty α := by sorry

This theorem states that for any type `α`, it is not the case that `α` is empty if and only if `α` is nonempty. In other words, a type `α` is not empty if there exists at least one element of type `α`. Conversely, if `α` is nonempty, then it cannot be the case that `α` is empty.

A type `α` is nonempty if and only if it is not empty.


theorem MeasureTheory.AEStronglyMeasurable.ennnorm :
    ∀ {α : Type u_1} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} {β : Type u_5}
      [inst : SeminormedAddCommGroup β] {f : α → β},
      MeasureTheory.AEStronglyMeasurable f μ → AEMeasurable (fun a => ↑‖f a‖₊) μ :=
  by sorry

This theorem states that for all types `α` and `β`, where `α` has a `MeasurableSpace` structure, `β` has a `SeminormedAddCommGroup` structure, and `μ` is a `MeasureTheory.Measure` on `α`, if a function `f` from `α` to `β` is "almost everywhere strongly measurable" with respect to measure `μ`, then the function that maps each element `a` of `α` to the nonnegative extended real norm of `f(a)` is "almost everywhere measurable" with respect to the same measure `μ`. In mathematical terms, it states that if a function is almost everywhere strongly measurable, then its norm is also almost everywhere measurable.

If a function from a measurable space to a seminormed additive commutative group is almost everywhere strongly measurable with respect to a measure, then the function mapping each element to the nonnegative extended real norm of its image is almost everywhere measurable with respect to the same measure.


theorem Real.pi_div_two_pos : 0 < Real.pi / 2 := by sorry

The theorem `Real.pi_div_two_pos` asserts that the number Pi divided by 2 is greater than zero. In other words, it establishes the positivity of half of Pi, a basic and important property of this mathematical constant in the field of real numbers.

The theorem `Real.pi_div_two_pos` asserts that 0 < Pi / 2 in the real numbers.


theorem Basis.span_eq :
    ∀ {ι : Type u_1} {R : Type u_3} {M : Type u_6} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
      (b : Basis ι R M), Submodule.span R (Set.range ⇑b) = ⊤ :=
  by sorry

This theorem, `Basis.span_eq`, states that for any given basis `b` of a module `M` over a semiring `R`, the span of the range of the basis (i.e., the set of all elements obtained by applying the basis function to all elements in its domain) is the entire module `M`. In other words, any element of the module `M` can be expressed as a linear combination of elements from the basis `b`. This is a key property of a basis in the context of module theory.

For any module M over a semiring R and basis b of M, the span of the basis equals M, i.e., every element in M can be expressed as a linear combination of basis elements.


theorem Commute.one_right : ∀ {M : Type u_2} [inst : MulOneClass M] (a : M), Commute a 1 := by sorry

The theorem `Commute.one_right` states that for any type `M` equipped with multiplication and identity element (`MulOneClass`) and any element `a` of type `M`, the element `a` commutes with the identity element `1`. In other words, the multiplication of `a` with 1 is the same as the multiplication of 1 with `a` - their order in the multiplication does not matter, or in mathematical terms, `a * 1 = 1 * a`.

For any `MulOneClass` type `M` and element `a` in `M`, `a * 1 = 1 * a`.


theorem Set.inter_empty : ∀ {α : Type u} (a : Set α), a ∩ ∅ = ∅ := by sorry

The theorem `Set.inter_empty` states that for all types `α` and for any set `a` of type `α`, the intersection of `a` with the empty set is the empty set. In mathematical terms, for any set `A`, we have `A ∩ ∅ = ∅`. This means that there are no elements which belong to both `A` and the empty set, which is consistent with the definition of set intersection.

For any set `A`, the intersection of `A` with the empty set is the empty set. In mathematical notation, `A ∩ ∅ = ∅`.


theorem or_iff_left : ∀ {b a : Prop}, ¬b → (a ∨ b ↔ a) := by sorry

This theorem, `or_iff_left`, states that for any two propositions `a` and `b`, if `b` is not true (denoted by `¬b`), then the logical OR of `a` and `b` (`a ∨ b`) is equivalent to `a` itself. In other words, if `b` is false, then the truth value of the expression `a ∨ b` is determined solely by `a`, because the OR operation with a false value doesn't change the overall value of the expression.

For all propositions `a` and `b`, `a ∨ ¬b` is equivalent to `a`.


theorem not_top_lt : ∀ {α : Type u} [inst : Preorder α] [inst_1 : OrderTop α] {a : α}, ¬⊤ < a := by sorry

This theorem states that for any type `α` that has a pre-order structure and a maximum element (`OrderTop α`), there is no element `a` in `α` such that the maximum element is less than `a`. In other words, it's impossible for the top element (`⊤`) of the pre-order to be less than any element in the set, which makes sense as `⊤` is defined to be the greatest element in the set.

For any pre-order type `α` with a maximum element `⊤`, there is no element `a` in `α` such that `⊤` is strictly less than `a`.


theorem Mathlib.Logic.Basic._auxLemma.32 :
    ∀ {α : Sort u_3} {β : Sort u_2} {f : α → β} {p : α → Prop} {q : β → Prop},
      (∃ b, (∃ a, p a ∧ f a = b) ∧ q b) = ∃ a, p a ∧ q (f a) :=
  by sorry

This theorem states that for any two types `α` and `β`, and functions `f : α → β`, `p : α → Prop`, and `q : β → Prop`, there is an equivalence between two existential statements: (1) there exists an element `b` of type `β` such that there exists an element `a` of type `α` where `p a` and `f a = b` hold, and `q b` also holds; and (2) there exists an element `a` of type `α` such that `p a` and `q (f a)` hold. Essentially, it demonstrates how quantifiers and conditions can be rearranged without changing the underlying logical proposition.

For any functions `f : α → β`, `p : α → Prop`, and `q : β → Prop`, the statements "exists `a : α` such that `p a` and `f a = b` for some `b : β` with `q b`" and "exists `a : α` such that `p a` and `q (f a)`" are logically equivalent.


theorem CategoryTheory.Subobject.underlyingIso_arrow :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X Y : C} (f : X ⟶ Y) [inst_1 : CategoryTheory.Mono f],
      CategoryTheory.CategoryStruct.comp (CategoryTheory.Subobject.underlyingIso f).inv
          (CategoryTheory.Subobject.arrow (CategoryTheory.Subobject.mk f)) =
        f :=
  by sorry

This theorem, `CategoryTheory.Subobject.underlyingIso_arrow`, in the field of Category Theory, states that for any category `C`, and any two objects `X` and `Y` in `C`, given a monomorphism `f` from `X` to `Y`, the composition of the inverse of the underlying isomorphism of `f` and the arrow from the subobject created by `f` to `Y` is equal to `f` itself. In other words, the arrow from the subobject gives us back our original morphism when composed with the inverse of the isomorphism.

For any category C, if f : X → Y is a monomorphism in C, then the composition of the inverse of the underlying isomorphism of f and the arrow from the subobject of X in Y to Y is equal to f.


theorem Int.fract_nonneg :
    ∀ {α : Type u_2} [inst : LinearOrderedRing α] [inst_1 : FloorRing α] (a : α), 0 ≤ Int.fract a := by sorry

The theorem `Int.fract_nonneg` asserts that for any type `α` which is an instance of a `LinearOrderedRing` and a `FloorRing`, the fractional part of any element `a` of this type, as defined by `Int.fract a`, is always non-negative. In other words, the fractional part of a number, obtained by subtracting its floor from it, is always greater than or equal to zero.

For any element `a` of a type `α` that is both a LinearOrderedRing and a FloorRing, the fractional part `Int.fract a` of `a` is non-negative.


theorem Set.image_inter :
    ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {s t : Set α}, Function.Injective f → f '' (s ∩ t) = f '' s ∩ f '' t :=
  by sorry

The theorem `Set.image_inter` asserts that for any two sets `s` and `t` of some type `α` and any injective function `f` from `α` to another type `β`, the image of the intersection of `s` and `t` under `f` is equal to the intersection of the images of `s` and `t` under `f`. In other words, if we apply an injective function `f` to each element in the intersection of `s` and `t`, we get the same result as if we first applied `f` to each element in `s` and `t` individually and then took the intersection. This theorem exemplifies one of the properties of injective functions in the context of set theory.

For injective functions `f` from set `α` to type `β`, `f''(s ∩ t) = f''(s) ∩ f''(t)`, where `s` and `t` are subsets of `α` and `f''` denotes the image of `α` under `f`.


theorem MeasureTheory.Measure.withDensity_rnDeriv_eq :
    ∀ {α : Type u_1} {m : MeasurableSpace α} (μ ν : MeasureTheory.Measure α)
      [inst : MeasureTheory.Measure.HaveLebesgueDecomposition μ ν],
      MeasureTheory.Measure.AbsolutelyContinuous μ ν → ν.withDensity (μ.rnDeriv ν) = μ :=
  by sorry

This theorem states that for any two measures `μ` and `ν` on a measurable space `α`, if `μ` has a Lebesgue decomposition with respect to `ν`, and `μ` is absolutely continuous with respect to `ν`, then `ν` with density equal to the Radon-Nikodym derivative of `μ` with respect to `ν` is equal to `μ`. In simpler terms, given two measures, if one is absolutely continuous with respect to the other and a certain decomposition condition is met, then we can represent one measure as the other measure "scaled" by a specific function, which is the Radon-Nikodym derivative.

If measure `μ` has a Lebesgue decomposition with respect to `ν` and is absolutely continuous with respect to `ν`, then `μ = ν ∣𝒫(dμ∕dν)∣`.


theorem IntermediateField.subset_adjoin :
    ∀ (F : Type u_1) [inst : Field F] {E : Type u_2} [inst_1 : Field E] [inst_2 : Algebra F E] (S : Set E),
      S ⊆ ↑(IntermediateField.adjoin F S) :=
  by sorry

This theorem states that for any set `S` of elements from a type `E` (which is a field and also an `F`-algebra), when we extend a field `F` by adjoining the set `S` using the function `IntermediateField.adjoin`, the set `S` is a subset of the resulting intermediate field. In other words, all elements in the set `S` are elements of the intermediate field created by adjoining `S` to `F`.

For any set `S` of elements from a field `F` that is also an `F-algebra,` the set `S` is contained in the intermediate field obtained by adjoining `S` to `F` using `IntermediateField.adjoin.`


theorem ENNReal.ofReal_coe_nnreal : ∀ {p : NNReal}, ENNReal.ofReal ↑p = ↑p := by sorry

This theorem states that for any nonnegative real number `p` (denoted as `NNReal`), the function `ENNReal.ofReal` applied to the coercion of `p` to a real number will yield the same result as simply coercing `p` to an extended nonnegative real number (denoted as `ENNReal`). In other words, the `ENNReal.ofReal` function behaves as expected on nonnegative real numbers when they are interpreted as extended nonnegative real numbers.

For any non-negative real number `p`, `ENNReal.ofReal (realCoerce p) = ENNReal p`.


theorem CategoryTheory.GradedObject.hom_ext :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {β : Type u_1} {X Y : CategoryTheory.GradedObject β C}
      (f g : X ⟶ Y), (∀ (x : β), f x = g x) → f = g :=
  by sorry

The theorem `CategoryTheory.GradedObject.hom_ext` states that for any category `C`, for any type `β`, and for any two `β`-graded objects `X` and `Y` in `C`, if for any element `x` of type `β`, the morphisms `f` and `g` from `X` to `Y` behave in such a way that `f(x) = g(x)`, then we can conclude that `f` is equal to `g`. In other words, if two morphisms between the same pair of `β`-graded objects in a category coincide on each grading, they are equal.

Given any category `C`, if for every `β`-graded object `X` and `Y` in `C` and every element `x` of type `β`, the morphisms `f` and `g` from `X` to `Y` satisfy `f(x) = g(x)`, then `f = g` as morphisms from `X` to `Y`.


theorem smul_one_mul :
    ∀ {M : Type u_10} {N : Type u_11} [inst : MulOneClass N] [inst_1 : SMul M N] [inst_2 : IsScalarTower M N N] (x : M)
      (y : N), x • 1 * y = x • y :=
  by sorry

This theorem, `smul_one_mul`, states that for any types `M` and `N`, given a multiplication identity element (with `N` acting as a `MulOneClass`), a scalar multiplication operation (`SMul`) between `M` and `N`, and a scalar tower (`IsScalarTower`) that is a structure expressing the associativity between the scalar multiplication and the multiplication, then for any element `x` of type `M` and `y` of type `N`, the scalar multiple of `1` and `y` by `x` is equal to the scalar multiple of `y` by `x`. This essentially shows the neutral aspect of `1` in scalar multiplication context.

For any types `M`, `N` with `N` being a `MulOneClass`, given a scalar multiplication `SMul` and a scalar tower `IsScalarTower` between `M` and `N`, the scalar multiplication of `1` by any `y` in `N` by an element `x` in `M` equals the scalar multiplication of `y` by `x`.


theorem subset_antisymm :
    ∀ {α : Type u} [inst : HasSubset α] {a b : α} [inst_1 : IsAntisymm α fun x x_1 => x ⊆ x_1], a ⊆ b → b ⊆ a → a = b :=
  by sorry

This theorem, `subset_antisymm`, states that for any type `α` with a subset operation and an antisymmetry property, if `a` and `b` are elements of `α` such that `a` is a subset of `b` and `b` is a subset of `a`, then `a` is equal to `b`. In other words, within a given type that has an antisymmetric subset relation, two elements are equal if and only if they are subsets of each other. This is a formalization of the antisymmetry property of set inclusion in the context of general types in Lean 4.

If `α` is a type with an antisymmetric subset relation, then for all `a` and `b` in `α`, `a ⊆ b` and `b ⊆ a` imply `a = b`.


theorem Set.Finite.induction_on :
    ∀ {α : Type u} {C : Set α → Prop} {s : Set α},
      Set.Finite s → C ∅ → (∀ {a : α} {s : Set α}, a ∉ s → Set.Finite s → C s → C (insert a s)) → C s :=
  by sorry

The theorem `Set.Finite.induction_on` is a principle of mathematical induction for finite sets. Given a type `α` and a property `C` that we wish to prove for all finite sets of type `α`, it says the following. If `s` is a finite set, `C` holds for the empty set, and whenever `C` holds for any finite set `s`, it also holds for the set obtained by inserting an element `a` not present in `s` into `s`, then `C` holds for `s`. This is a typical structure of induction: prove something for a base case (here, the empty set), then prove that if it holds for a certain case, it also holds for the next case (here, inserting a new element into the set).

The theorem `Set.Finite.induction_on` asserts that if `C` is a property that holds for the empty set of type `α` and is closed under adding an element not in the set, then `C` holds for all finite sets of type `α`.


theorem Metric.isClosed_ball :
    ∀ {α : Type u} [inst : PseudoMetricSpace α] {x : α} {ε : ℝ}, IsClosed (Metric.closedBall x ε) := by sorry

The theorem `Metric.isClosed_ball` states that for any pseudometric space `α`, any point `x` in `α`, and any real number `ε`, the closed ball centered at `x` with radius `ε` (which is the set of all points `y` such that the distance between `y` and `x` is less than or equal to `ε`) is a closed set. In the context of topology, a set is called closed if it contains all its limit points.

In a pseudometric space, the closed ball is a closed set.


theorem Nat.prod_factors : ∀ {n : ℕ}, n ≠ 0 → List.prod (Nat.factors n) = n := by sorry

The theorem `Nat.prod_factors` in Lean 4 asserts that for every natural number `n` such that `n` is not equal to zero, the product of the list of its prime factors (as given by the function `Nat.factors n`) equals the number `n` itself. In other words, if you take a non-zero natural number, find all its prime factors, and multiply them together, you get the original number back. This is a formalization of the fundamental theorem of arithmetic, which states that every integer greater than 1 either is a prime number itself or can be factored as a product of primes in an essentially unique way.

For every natural number `n` greater than zero, `n` is the product of its prime factors.


theorem List.cons_append : ∀ {α : Type u} (a : α) (as bs : List α), a :: as ++ bs = a :: (as ++ bs) := by sorry

This theorem, `List.cons_append`, states that for any type `α`, and for any element `a` of this type and any two lists `as` and `bs` of the same type, prepending `a` to the concatenation of `as` and `bs` is the same as prepending `a` to `as` and then concatenating the result with `bs`. In other words, in the context of list operations, the operation of prepending an element to a list is 'left distributive' over list concatenation.

For any type `α` and lists `as : list α` and `bs : list α`, `a :: (as ++ bs) = a :: as ++ bs`, where `::` denotes list prepending and `++` list concatenation.


theorem add_sub_add_comm :
    ∀ {α : Type u_1} [inst : SubtractionCommMonoid α] (a b c d : α), a + b - (c + d) = a - c + (b - d) := by sorry

This theorem, `add_sub_add_comm`, states that for any type `α` that is a commutative subtraction monoid, for any four elements `a`, `b`, `c` and `d` of type `α`, adding `b` to `a`, then subtracting the sum of `c` and `d` is equal to subtracting `c` from `a`, then adding the result to the difference of `b` and `d`. In mathematical notation, this is represented as \(a + b - (c + d) = a - c + (b - d)\). This theorem is a statement about the commutativity and associativity of addition and subtraction in such a type.

For any commutative subtraction monoid type `α`, the commutative and associative properties of addition and subtraction imply that `a + b - (c + d) = a - c + (b - d)` for all `a, b, c, d ∈ α`.


theorem map_eq_zero_iff :
    ∀ {M : Type u_4} {N : Type u_5} {F : Type u_9} [inst : Zero M] [inst_1 : Zero N] [inst_2 : FunLike F M N]
      [inst_3 : ZeroHomClass F M N] (f : F), Function.Injective ⇑f → ∀ {x : M}, f x = 0 ↔ x = 0 :=
  by sorry

The theorem `map_eq_zero_iff` states that for any types `M`, `N` and `F`, given that `M` and `N` are equipped with zero elements, `F` is a function-like type from `M` to `N`, and `F` forms a zero homomorphism from `M` to `N`, then for any function `f` of type `F`, if `f` is injective, for any element `x` of type `M`, `f(x)` is equal to the zero element of `N` if and only if `x` is the zero element of `M`. In other words, an injective zero homomorphism only maps the zero element to the zero element.

An injective zero homomorphism maps the zero element to the zero element.


/-- Comparison test of convergence of series of non-negative real numbers.  -/
theorem Summable.of_nonneg_of_le :
    ∀ {β : Type u_2} {f g : β → ℝ}, (∀ (b : β), 0 ≤ g b) → (∀ (b : β), g b ≤ f b) → Summable f → Summable g := by sorry

This is the comparison test for the convergence of series of non-negative real numbers. Given two functions `f` and `g` from an arbitrary type `β` to the real numbers, if for all `b` in `β`, the value of `g b` is non-negative and less than or equal to `f b`, and if the sum of the series formed by `f` exists (i.e., `f` is summable), then the sum of the series formed by `g` also exists (`g` is also summable).

If `f(x)` is a summable series of non-negative real numbers and `g(x) ≤ f(x)` for all `x`, then `g(x)` is also summable.


theorem Summable.of_norm :
    ∀ {ι : Type u_1} {E : Type u_3} [inst : SeminormedAddCommGroup E] [inst_1 : CompleteSpace E] {f : ι → E},
      (Summable fun a => ‖f a‖) → Summable f :=
  by sorry

The theorem `Summable.of_norm` asserts that for any type `ι`, any seminormed additively commutative group `E` that is also a complete space, and any function `f` mapping elements of `ι` to `E`, if the norm of `f` for each element in its domain is summable, then the function `f` itself is summable. In other words, if the series of norms of `f` converges, then the series created by `f` also converges.

If `ι` is a type, `E` is a complete, additively commutative seminormed group, and `f : ι → E` is a function such that the series of its norms is summable, then the series represented by `f` is also summable.


theorem Finset.card_fin : ∀ (n : ℕ), Finset.univ.card = n := by sorry

This theorem states that for any natural number `n`, the cardinality (or size) of the universal finite set (`Finset.univ`) is equal to `n`. Here, `Finset.univ` is a set that consists of all elements of a given type `α`, under the assumption that `α` is a finite type (`Fintype α`). Essentially, this theorem is stating that the number of elements in this universal finite set is `n`, for any `n` in the natural numbers.

For any finite type `α`, the cardinality of `Finset.univ` (the universal finite set of `α`) equals the natural number representing its size.


theorem continuousAt_id : ∀ {X : Type u_1} [inst : TopologicalSpace X] {x : X}, ContinuousAt id x := by sorry

This theorem states that the identity function is continuous at every point in any topological space. In mathematical terms, for any topological space `X` and any point `x` in `X`, the identity function `id` satisfies the property that `id(x)` tends to `id(x₀)` when `x` tends to `x₀`. Here, `id(x)` is simply `x`, so the property simplifies to `x` tends to `x₀` when `x` tends to `x₀`, which is always true.

The identity function is continuous on every topological space.


MeasurableSet.iInter

theorem MeasurableSet.iInter :
    ∀ {α : Type u_1} {ι : Sort u_6} {m : MeasurableSpace α} [inst : Countable ι] {f : ι → Set α},
      (∀ (b : ι), MeasurableSet (f b)) → MeasurableSet (⋂ b, f b) :=
  by sorry

The theorem `MeasurableSet.iInter` states that for any type `α`, any type `ι` which is countable, a measurable space `m` on `α`, and a function `f` from `ι` to the sets of `α`, if every set `f b` for each `b` in `ι` is a measurable set, then the intersection of all these sets (represented as `⋂ b, f b`) is also a measurable set. This theorem captures an important property of measurable sets: the countable intersection of measurable sets is also measurable.

The countable intersection of measurable sets in a measurable space is measurable.


theorem Mathlib.Data.Finset.Sigma._auxLemma.1 :
    ∀ {ι : Type u_1} {α : ι → Type u_2} {s : Finset ι} {t : (i : ι) → Finset (α i)} {a : (i : ι) × α i},
      (a ∈ Finset.sigma s t) = (a.fst ∈ s ∧ a.snd ∈ t a.fst) :=
  by sorry

The theorem `Mathlib.Data.Finset.Sigma._auxLemma.1` states that for any types `ι` and `α` (which is a function from `ι` to some type), any finite set `s` of type `ι`, any function `t` from `ι` to a finite set of `α i`, and any dependent pair `a` of type `ι` and `α i`, the pair `a` belongs to the set `s.sigma t` if and only if the first element of `a` belongs to `s` and the second element of `a` belongs to the set `t` at the index of the first element of `a`.
In mathematical terms, if `a` is the pair `(i, a_i)` where `i` belongs to `s` and `a_i` belongs to the `t(i)`, then `a` belongs to the finite set `σ` of all such pairs generated by `s` and `t`.

For any type `ι`, function `t` from `ι` to finite sets of type `α i`, finite set `s` of type `ι`, and pairs `(i, a\_i)` of type `ι × α i`, `(i, a\_i)` is in the set `s.sigma t` if and only if `i` is in `s` and `a\_i` is in `t i`.


theorem Set.Ici_inter_Iic : ∀ {α : Type u_1} [inst : Preorder α] {a b : α}, Set.Ici a ∩ Set.Iic b = Set.Icc a b := by
  sorry

This theorem states that for any type `α` that has a preorder, and any two elements `a` and `b` of that type, the intersection of the set of all elements greater than or equal to `a` (`Set.Ici a`) and the set of all elements less than or equal to `b` (`Set.Iic b`) is exactly the set of all elements `x` such that `a ≤ x` and `x ≤ b` (`Set.Icc a b`). In other words, when we take the intersection of the left-closed right-infinite interval starting at `a` and the left-infinite right-closed interval ending at `b`, we get the left-closed right-closed interval from `a` to `b`.

For any type `α` with a preorder and any `a, b ∈ α`, `Set.Icc a b = Set.Ici a ∩ Set.Iic b`.