theorem inner_add_right :
    ∀ {𝕜 : 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, y⟫_𝕜 + ⟪x, z⟫_𝕜 :=
  by sorry

This theorem, named `inner_add_right`, states that for any type `𝕜` and `E`, where `𝕜` has a structure of a ring-like ordered field (`RCLike 𝕜`) and `E` is a normed additive commutative group with an inner product space over `𝕜` (`InnerProductSpace 𝕜 E`), the inner product of `x` with the sum of `y` and `z` (denoted by `⟪x, y + z⟫_𝕜`) equals to the sum of the inner product of `x` with `y` and the inner product of `x` with `z` (denoted by `⟪x, y⟫_𝕜 + ⟪x, z⟫_𝕜`). This theorem is a property of inner product spaces reflecting the distributivity of the inner product with respect to vector addition on the right.

For any ring-like ordered field `𝕜` and inner product space `𝕜[E]`, the inner product of `x` with the sum of `y` and `z` equals the sum of the inner products of `x` with `y` and `z`.


theorem Mathlib.Data.Fintype.Pi._auxLemma.9 :
    ∀ {α : Type u_1} [inst : DecidableEq α] [inst_1 : Fintype α] {δ : α → Type u_3} {t : (a : α) → Finset (δ a)}
      {f : (a : α) → δ a}, (f ∈ Fintype.piFinset t) = ∀ (a : α), f a ∈ t a :=
  by sorry

This theorem, `Mathlib.Data.Fintype.Pi._auxLemma.9`, states that for any type `α` that has decidable equality and is finite, for any function `δ` from `α` to another type `u_3`, for any function `t` from `α` to a `Finset` (a finite set) of `u_3` type, and for any function `f` from `α` to `u_3`, the condition that `f` is an element of the pi-Finset of `t` (i.e., the set of functions from `α` to `u_3` that send each element of `α` to an element in the corresponding `Finset` in `u_3`) is equivalent to the condition that for all elements `a` of `α`, `f(a)` is an element of `t(a)`.

In simpler terms, a function is in the pi-Finset of `t` if and only if it maps every element to a member of the corresponding set specified by `t`.

For a finite type `α` with decidable equality, a function `δ : α → u_3`, a function `t : α → Finset u_3`, and a function `f : α → u_3`, `f` is in the pi-Finset of `t` if and only if `f(a) ∈ t(a)` for all `a : α`.


IntervalIntegrable.symm

theorem IntervalIntegrable.symm :
    ∀ {E : Type u_3} [inst : NormedAddCommGroup E] {f : ℝ → E} {a b : ℝ} {μ : MeasureTheory.Measure ℝ},
      IntervalIntegrable f μ a b → IntervalIntegrable f μ b a :=
  by sorry

This theorem states that if a function `f` from the real numbers to a normed additive commutative group `E` is 'interval integrable' with respect to a measure `μ` on an interval from `a` to `b`, then the function `f` is also 'interval integrable' with respect to the measure `μ` on the interval from `b` to `a`. In other words, the 'interval integrability' of the function `f` is symmetric with respect to the endpoints `a` and `b` of the interval.

If a function `f` is interval integrable with respect to measure `μ` on the interval [`a`, `b`] of a normed additive commutative group `E`, then it is also interval integrable with respect to `μ` on the interval [`b`, `a`].


theorem BoxIntegral.Prepartition.mem_biUnion :
    ∀ {ι : Type u_1} {I J : BoxIntegral.Box ι} (π : BoxIntegral.Prepartition I)
      {πi : (J : BoxIntegral.Box ι) → BoxIntegral.Prepartition J},
      J ∈ BoxIntegral.Prepartition.biUnion π πi ↔ ∃ J' ∈ π, J ∈ πi J' :=
  by sorry

This theorem states that, for any type `ι`, any boxes `I` and `J`, a partition `π` of `I`, and a function `πi` that associates each box `J` to a partition of `J`, the box `J` belongs to the biUnion of `π` and `πi` if and only if there exists a box `J'` in `π` such that `J` belongs to the partition `πi J'`.

In more detail, the `BoxIntegral.Prepartition.biUnion` operation takes a partition of a box and a function that gives a partition for every box, and combines them into a single partition. The theorem then characterizes membership in this combined partition.

For any type `ι`, given a partition `π` of a box `I` and a function `πi` that maps each box `J` to a partition of `J`, a box `J` belongs to the biUnion of `π` and `πi` if and only if there exists a box `J'` in `π` such that `J` is in the partition `πi(J')`.


theorem Finsupp.support_eq_empty :
    ∀ {α : Type u_1} {M : Type u_5} [inst : Zero M] {f : α →₀ M}, f.support = ∅ ↔ f = 0 := by sorry

This theorem, `Finsupp.support_eq_empty`, declares a property for a function `f` of type `Finsupp` (which stands for "finite support"). Here, `Finsupp` is a type representing a function from `α` to `M` with finite support, i.e., there are only a finite number of elements of `α` for which `f` is non-zero. The theorem states that the support of `f` is empty if and only if `f` is the zero function. In other words, `f` maps all elements to zero if and only if there are no elements where `f` is non-zero. The `Zero M` instance indicates that `M` is a type with a specified zero element, and `∅` denotes an empty set.

A function `f` of type `Finsupp α M` has an empty support if and only if it is the zero function.


theorem add_eq_zero_iff :
    ∀ {α : Type u} [inst : CanonicallyOrderedAddCommMonoid α] {a b : α}, a + b = 0 ↔ a = 0 ∧ b = 0 := by sorry

This theorem states that for any given type `α` which is a canonically ordered additive commutative monoid, the sum of two elements `a` and `b` is equal to zero if and only if both `a` and `b` are equal to zero. In other words, in this type of monoid, the only way for the sum of two elements to be zero is if both elements are zero themselves. This theorem is a key property of all canonically ordered additive commutative monoids.

In a canonically ordered additive commutative monoid, the sum of two elements is zero if and only if both elements are zero.


theorem CategoryTheory.Adjunction.homEquiv_naturality_right_symm :
    ∀ {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 : C} {Y Y' : D} (f : X ⟶ G.obj Y) (g : Y ⟶ Y'),
      (adj.homEquiv X Y').symm (CategoryTheory.CategoryStruct.comp f (G.map g)) =
        CategoryTheory.CategoryStruct.comp ((adj.homEquiv X Y).symm f) g :=
  by sorry

The theorem `CategoryTheory.Adjunction.homEquiv_naturality_right_symm` expresses a fundamental property of adjunctions in category theory. Specifically, it states that for any two categories `C` and `D`, and functors `F` from `C` to `D` and `G` from `D` to `C` forming an adjunction, the mapping of morphisms (homEquiv) between objects is natural in the right argument. This naturality condition ensures that for any objects `X` in `C`, `Y` and `Y'` in `D`, and morphisms `f` from `X` to `G(Y)` and `g` from `Y` to `Y'`, the composition of `f` with the functor image of `g` under `G` and then applying the inverse of homEquiv at `X` and `Y'`, is the same as first applying the inverse of homEquiv at `X` and `Y` to `f`, and then composing the result with `g`. This theorem is a cornerstone of the theory of adjoint functors, which are a key concept in category theory.

Given categories `C` and `D`, functors `F: C → D` and `G: D → C` forming an adjunction, the homomorphism equivalence `map_comp` between `F(f)` and `G(g)` for morphisms `f: X → G(Y)` in `C` and `g: Y → Y'` in `D`, is natural in `Y` and `Y'`.


theorem CategoryTheory.IsIso.comp_inv_eq :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z : C} (α : X ⟶ Y) [inst_1 : CategoryTheory.IsIso α]
      {f : Z ⟶ Y} {g : Z ⟶ X},
      CategoryTheory.CategoryStruct.comp f (CategoryTheory.inv α) = g ↔ f = CategoryTheory.CategoryStruct.comp g α :=
  by sorry

This theorem is a statement about the composition of morphisms in a category theory framework. Given a category `C` and objects `X`, `Y`, and `Z` in `C`, if `α` is an isomorphism from `X` to `Y`, the theorem states that for any morphisms `f : Z ⟶ Y` and `g : Z ⟶ X`, the composition of `f` and the inverse of `α` is equal to `g` if and only if `f` is equal to the composition of `g` and `α`. In less formal terms, this theorem is a condition for the exchange of a morphism and its inverse in a composition of morphisms.

In a category `C`, given objects `X`, `Y`, `Z`, an isomorphism `α : X ≈ Y`, morphisms `f : Z ⟶ Y`, and `g : Z ⟶ X`, `f ∘ α⁻¹ = g` if and only if `f = g ∘ α`.


theorem Ordinal.opow_one : ∀ (a : Ordinal.{u_1}), a ^ 1 = a := by sorry

This theorem states that for any ordinal number `a`, raising `a` to the power of 1 is equivalent to `a` itself. In the context of the theory of ordinal numbers in set theory, this means that the single exponentiation of any ordinal number does not modify its value, analogy to the property from basic arithmetic that any number raised to the power of 1 stays the same.


/-- An induction principle for closure membership. If `p` holds for `1` and all elements of `s`, and
is preserved under multiplication, then `p` holds for all elements of the closure of `s`.  -/
theorem Submonoid.closure_induction :
    ∀ {M : Type u_1} [inst : MulOneClass M] {s : Set M} {p : M → Prop} {x : M},
      x ∈ Submonoid.closure s → (∀ x ∈ s, p x) → p 1 → (∀ (x y : M), p x → p y → p (x * y)) → p x :=
  by sorry

This theorem, called "Submonoid.closure_induction", is an induction principle for checking if an element is a member of a submonoid's closure. Given a type `M` with multiplication and identity (`MulOneClass M`), a set `s` of type `M`, a predicate `p` from `M` to `Prop`, and an element `x` of type `M`, it states that if `x` is in the closure of `s`, `p` holds for the multiplicative identity `1` and all elements of `s`, and `p` is preserved under multiplication (i.e., if `p` holds for elements `x` and `y`, then it also holds for their product `x * y`), then `p` holds for `x`. In other words, we can use this theorem to prove properties of elements in the generated submonoid by showing they hold for `1`, the generating set `s`, and are preserved under multiplication.

If `s` is a submonoid of a type `M` with predicate `p`, and `x` is in the closure of `s` with `p(1)` holding for the multiplicative identity and `p` being multiplicatively preserving on `s`, then `p(x)` holds.


theorem iInf_pos : ∀ {α : Type u_1} [inst : CompleteLattice α] {p : Prop} {f : p → α} (hp : p), ⨅ (h : p), f h = f hp :=
  by sorry

This theorem, `iInf_pos`, states that for any type `α` that forms a complete lattice, given a proposition `p` and a function `f` from `p` to `α`, for any instance `hp` where `p` holds true, the infimum (greatest lower bound) over all elements `h` for which `p` holds, of `f(h)`, is equal to `f(hp)`. In other words, it asserts that the infimum of the function values for all instances of the proposition is the function value at the particular instance `hp`.

For any complete lattice `α`, function `f` from a proposition `p` to `α`, and instance `hp` of `p`, the infimum of `f(h)` over all `h` with `p(h)` is equal to `f(hp)`.


theorem exists₂_congr :
    ∀ {α : Sort u_1} {β : α → Sort u_2} {p q : (a : α) → β a → Prop},
      (∀ (a : α) (b : β a), p a b ↔ q a b) → ((∃ a b, p a b) ↔ ∃ a b, q a b) :=
  by sorry

This theorem, `exists₂_congr`, states that for all types `α` and `β` (where `β` is dependent on `α`), and for all predicates `p` and `q` that take two arguments (an element of `α` and an element of `β`), if for all `a` in `α` and `b` in `β a`, `p a b` is equivalent to `q a b`, then the existential quantification of `p` over both `a` and `b` is equivalent to the existential quantification of `q` over both `a` and `b`. In other words, if `p` and `q` are equivalent for all possible inputs, then there exists some `a` and `b` for which `p a b` is true if and only if there exists some `a` and `b` for which `q a b` is true.

If for all `a` in `α` and `b` in `β(a)`, `p(a, b) ↔ q(a, b)` implies `∃(a, b). p(a, b) ↔ ∃(a, b). q(a, b)`.


theorem Polynomial.natDegree_mul_le :
    ∀ {R : Type u} [inst : Semiring R] {p q : Polynomial R},
      Polynomial.natDegree (p * q) ≤ Polynomial.natDegree p + Polynomial.natDegree q :=
  by sorry

This theorem states that for any semiring `R` and any two polynomials `p` and `q` over `R`, the natural degree of the product of `p` and `q` is less than or equal to the sum of the natural degrees of `p` and `q`. In mathematical terms, if $p$ and $q$ are polynomials over a semiring, then the degree of $p \times q$ is less than or equal to the degree of $p$ plus the degree of $q$.

The natural degree of the product of two polynomials over a semiring does not exceed the sum of their degrees.


theorem Finset.mem_map_of_mem :
    ∀ {α : Type u_1} {β : Type u_2} (f : α ↪ β) {a : α} {s : Finset α}, a ∈ s → f a ∈ Finset.map f s := by sorry

This theorem states that for any types `α` and `β`, if `f` is an embedding from `α` to `β`, `a` is an element of the finset `s` in `α`, then the image of `a` under the embedding `f` is an element of the image finset `Finset.map f s` in `β`. In other words, if an element is in a finset, then its image under a given embedding function is in the mapped finset. This is a fundamental property about the interaction of embeddings and finsets in Lean 4.

For any embeddings between types `f : α → β` and finsets `s : Finset α`, if `a ∈ s`, then `f a ∈ Finset.map f s`.


theorem Rat.smul_def : ∀ {K : Type u_3} [inst : DivisionRing K] (a : ℚ) (x : K), a • x = ↑a * x := by sorry

This theorem, `Rat.smul_def`, states that for any division ring `K` and any rational number `a` and element `x` of `K`, the scalar multiplication of `a` and `x` (notated as `a • x`) is equal to the multiplication of the real number representation of `a` (notated as `↑a`) and `x`. This essentially says that scalar multiplication in the division ring works as you'd intuitively expect from real number multiplication.

For any division ring K and rational number a, the operation a • x of scalar multiplication equals the multiplication of the real number ↑a and element x, i.e., a • x = ↑a * x.


theorem LinearMap.BilinForm.proof_1 : ∀ (R : Type u_1) [inst : CommSemiring R], SMulCommClass R R R := by sorry

This theorem states that for any type `R` with a commutative semiring structure, the scalar multiplication of `R` is commutative. In other words, for any scalars `a`, `b` and any vector `v` in `R`, the operation `a * (b * v)` equals to `(a * b) * v`. This is one of the properties that define a commutative semiring in mathematical terms.

For any commutative semiring `R`, the scalar multiplication is commutative, i.e., `a * (b * v) = (a * b) * v` for all scalars `a`, `b` and vectors `v` in `R`.


theorem quotientMap_quotient_mk' :
    ∀ {X : Type u} [inst : TopologicalSpace X] {s : Setoid X}, QuotientMap Quotient.mk' := by sorry

This theorem states that for any type `X` equipped with a topological space structure and any setoid `s` over `X`, the canonical quotient map `Quotient.mk'` (which maps each element of `X` to its equivalence class in the quotient set `Quotient s`) is a quotient map. In other words, the function `Quotient.mk'` is surjective and for any set `s` in the resulting quotient structure, `s` is open if and only if its pre-image under `Quotient.mk'` is an open set in `X`.

Given a topological space `(X, top)` and a setoid `s` over `X`, the canonical quotient map `Quotient.mk' : X → Quotient s` is a quotient map, that is, it is surjective and preserves open sets.


theorem ProbabilityTheory.kernel.measure_le_bound :
    ∀ {α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β}
      (κ : ↥(ProbabilityTheory.kernel α β)) [h : ProbabilityTheory.IsFiniteKernel κ] (a : α) (s : Set β),
      ↑↑(κ a) s ≤ ProbabilityTheory.IsFiniteKernel.bound κ :=
  by sorry

This theorem from the field of probability theory, named "kernel.measure_le_bound", states that for any types `α` and `β`, given measurable spaces `mα` and `mβ` respectively, for any kernel `κ` from `α` to `β`, and assuming that `κ` is a finite kernel (as indicated by `h`), for any element `a` of type `α` and any set `s` of type `β`, the measure of `s` under `κ a` is always less than or equal to the bound of the finite kernel `κ`. In essence, it ensures that measures produced by a finite kernel never exceed its upper bound.

Given measurable spaces `mα` and `mβ`, a finite kernel `κ` from `α` to `β`, and for any `a ∈ α` and `s ∈ β`, the measure of `s` under `κ a` is less than or equal to the bound of `κ`.


/-- An additive subgroup is closed under subtraction. -/
theorem sub_mem :
    ∀ {M : Type u_5} {S : Type u_6} [inst : SubNegMonoid M] [inst_1 : SetLike S M] [hSM : AddSubgroupClass S M] {H : S}
      {x y : M}, x ∈ H → y ∈ H → x - y ∈ H :=
  by sorry

This theorem states that an additive subgroup is closed under subtraction. Specifically, for any type `M` with a `SubNegMonoid` structure (a type of monoid with negation and subtraction), a set-like structure `S` of `M`, and an `AddSubgroupClass` of `S` and `M`, if you have an element `H` of `S`, and elements `x` and `y` of `M` that belong to `H`, then the difference of `x` and `y` (`x - y`) also belongs to `H`. In simpler terms, if `x` and `y` are elements of an additive subgroup `H`, then their difference is also an element of `H`.

If `H` is an additive subgroup of a `SubNegMonoid` `M`, then for all `x, y` in `H`, `x - y` is also in `H`.


theorem add_right_iterate :
    ∀ {G : Type u_3} [inst : AddMonoid G] (a : G) (n : ℕ), (fun x => x + a)^[n] = fun x => x + n • a := by sorry

This theorem, named `add_right_iterate`, states that for any type `G` that forms an additive monoid and any element `a` of type `G` and natural number `n`, iterating the function of adding `a` to another element `x` `n` times is equivalent to the function of adding `n` times `a` to `x`. Essentially, it's expressing the distributive property of addition over scalar multiplication in terms of function iteration.

For any additive monoid `G` and `a` in `G` and natural number `n`, the function `iterate (λ x, x + a) n` equals the function `λ x, (n • a) + x`.


theorem le_mul_of_one_le_right' :
    ∀ {α : Type u_1} [inst : MulOneClass α] [inst_1 : LE α]
      [inst_2 : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1] {a b : α}, 1 ≤ b → a ≤ a * b :=
  by sorry

This theorem, named `le_mul_of_one_le_right'`, asserts that in a type `α` that is a multiplication one-class and has a less than or equal to (`LE`) relation, if the multiplication operation is covariant and if `1` is less than or equal to some value `b`, then any value `a` of the type is less than or equal to the product of `a` and `b`. Thus, when `b` is greater than or equal to `1`, multiplying `a` by `b` will not make the product smaller than `a`.

If `α` is a multiplication one-class with `LE` relation, `1 ≤ b`, and multiplication is covariant in the first argument, then for all `a ∈ α`, we have `a ≤ a * b`.


theorem Finsupp.mem_supported :
    ∀ {α : Type u_1} {M : Type u_2} (R : Type u_5) [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
      {s : Set α} (p : α →₀ M), p ∈ Finsupp.supported M R s ↔ ↑p.support ⊆ s :=
  by sorry

The theorem `Finsupp.mem_supported` states that for any types `α`, `M`, and `R`, given a semiring `R`, an additive commutative monoid `M`, and a module structure on `M` over `R`, a function `p` from `α` to `M` is in the submodule `Finsupp.supported M R s` for a set `s` of `α` if and only if the support of `p` (the set of points where `p` is non-zero) is a subset of `s`. In other words, it describes the condition under which a function `p` belongs to the submodule of all functions whose non-zero values lie within a specified set `s`.

A function from a type `α` to an additive commutative `R`-module `M` belongs to the submodule `Finsupp.supported M R s` if and only if the support of the function is contained in the set `s`.


theorem Cardinal.mk_le_of_injective :
    ∀ {α β : Type u} {f : α → β}, Function.Injective f → Cardinal.mk α ≤ Cardinal.mk β := by sorry

This theorem states that for any types `α` and `β`, and any function `f` from `α` to `β`, if the function `f` is injective (i.e., no two different elements in `α` map to the same element in `β`), then the cardinality of `α` (denoted as `Cardinal.mk α`) is less than or equal to the cardinality of `β` (denoted as `Cardinal.mk β`). In other words, the size of `α` is no larger than the size of `β` when there is an injective function from `α` to `β`.

If `f` is an injective function from type `α` to type `β`, then `Cardinal.mk α ≤ Cardinal.mk β`.


theorem continuous_dist : ∀ {α : Type u} [inst : PseudoMetricSpace α], Continuous fun p => dist p.1 p.2 := by sorry

This theorem states that for any type `α` equipped with a `PseudoMetricSpace` structure (a type of mathematical space where distances can be measured), the distance function that takes a pair of points and returns the distance between them is a continuous function. In mathematical terms, it states that for any points in this specific type of space, small changes in the input points result in small changes in the output value (distance).

The distance function of a `PseudoMetricSpace` is continuous.


theorem isNoetherianRing_iff : ∀ {R : Type u_1} [inst : Semiring R], IsNoetherianRing R ↔ IsNoetherian R R := by sorry

This theorem establishes the equivalence between a ring being a Noetherian ring and the ring being Noetherian over itself. In other words, for any type `R` with the structure of a semiring, `R` is a Noetherian ring if and only if `R` is Noetherian as a module over itself. A ring is Noetherian if all its ideals are finitely generated, which means there are only finitely many elements required to generate any ideal in the ring.

A ring is Noetherian if and only if it is Noetherian as a module over itself. (That is, a ring is Noetherian if and only if all its ideals are finitely generated ideals.)


theorem ENNReal.ofReal_le_ofReal_iff : ∀ {p q : ℝ}, 0 ≤ q → (ENNReal.ofReal p ≤ ENNReal.ofReal q ↔ p ≤ q) := by sorry

The theorem `ENNReal.ofReal_le_ofReal_iff` states that for every two real numbers `p` and `q`, if `q` is nonnegative, then the nonnegative extended real number representation of `p` is less than or equal to the nonnegative extended real number representation of `q` if and only if `p` is less than or equal to `q`. In other words, the function `ENNReal.ofReal`, which maps real numbers to nonnegative extended real numbers, preserves the order of nonnegative real numbers.

For every real numbers `p` and `q` with `q` nonnegative, `ENNReal.ofReal p <= ENNReal.ofReal q` if and only if `p <= q`.


theorem MeasureTheory.VectorMeasure.restrict_le_restrict_iff :
    ∀ {α : Type u_1} {m : MeasurableSpace α} {M : Type u_3} [inst : TopologicalSpace M] [inst_1 : AddCommMonoid M]
      [inst_2 : PartialOrder M] (v w : MeasureTheory.VectorMeasure α M) {i : Set α},
      MeasurableSet i →
        (MeasureTheory.VectorMeasure.restrict v i ≤ MeasureTheory.VectorMeasure.restrict w i ↔
          ∀ ⦃j : Set α⦄, MeasurableSet j → j ⊆ i → ↑v j ≤ ↑w j) :=
  by sorry

This theorem states that for any types `α` and `M`, a measurable space over `α` denoted by `m`, a topological space over `M`, and an additive commutative monoid over `M` with a partial order, given vector measures `v` and `w` over `α` and `M`, and a set `i` of type `α` that is measurable, the restriction of the vector measure `v` to the set `i` is less than or equal to the restriction of the vector measure `w` to the same set if and only if for all subsets `j` of `i` that are measurable, the measure of `j` under `v` is less than or equal to the measure of `j` under `w`. In terms of measure theory, it provides a condition to compare the restrictions of two vector measures on a given measurable set.

For measurable sets i in a measurable space over type α, and vector measures v and w over i and a topological space M with an additive commutative monoid and partial order, if the measure of every measurable subset j of i satisfies v(j) ≤ w(j), then the restriction of v to i is less than or equal to the restriction of w to i.


theorem IsIntegralClosure.algebraMap_injective :
    ∀ (A : Type u_1) (R : Type u_2) (B : Type u_3) [inst : CommRing R] [inst_1 : CommSemiring A] [inst_2 : CommRing B]
      [inst_3 : Algebra R B] [inst_4 : Algebra A B] [inst : IsIntegralClosure A R B],
      Function.Injective ⇑(algebraMap A B) :=
  by sorry

The theorem `IsIntegralClosure.algebraMap_injective` states that for any types `A`, `R`, and `B`, with `R` being a commutative ring, `A` being a commutative semiring, and `B` being a ring. Additionally, `B` has two algebra structures over `R` and `A`, and `A` is an integral closure of `R` in `B`. Under these conditions, the algebra map from `A` to `B` is injective. In mathematical terms, this means if `f` is the algebra map from `A` to `B`, for any elements `x` and `y` in `A`, if `f(x) = f(y)`, then `x = y`. This property is crucial in certain areas of algebra and number theory.

If `A` is an integral closure of a commutative ring `R` in a commutative ring `B`, then the algebra map from `A` to `B` is injective.


/-- The `NonUnitalSubring` generated by a set includes the set.  -/
theorem NonUnitalSubring.subset_closure :
    ∀ {R : Type u} [inst : NonUnitalNonAssocRing R] {s : Set R}, s ⊆ ↑(NonUnitalSubring.closure s) := by sorry

This theorem states that for any type `R` that forms a Non-Unitary Non-Associative Ring, and any set `s` of elements of this type `R`, the set `s` is a subset of the Non-Unitary Subring generated by `s`. In other words, all elements in `s` are included in the Non-Unitary Subring that is created by taking `s` as a generating set.

For any non-unitary, non-associative ring `R` and set `s` of its elements, `s` is a subset of the non-unitary subring generated by `s`.


theorem Fin.le_castSucc_iff : ∀ {n : ℕ} {i : Fin (n + 1)} {j : Fin n}, i ≤ Fin.castSucc j ↔ i < Fin.succ j := by sorry

The theorem `Fin.le_castSucc_iff` states that for any natural number `n` and any two finite ordinals `i` and `j` such that `i` belongs to `Fin (n + 1)` and `j` belongs to `Fin n`, `i` is less than or equal to the embedding of `j` into `Fin (n + 1)` using `castSucc` if and only if `i` is less than the successor of `j` in `Fin (n + 1)`. This theorem provides a way to compare elements in different finite ordinal types, linking the relation of being less than or equal to under embedding and being less than under successorship.

For any natural number `n`, `Fin.le_castSucc_iff` asserts that `i ≤ castSucc i'` in `Fin (n + 1)` if and only if `i < succ i'` holds in `Fin n`, where `i` is an element of `Fin (n + 1)` and `i'` is an element of `Fin n`.


theorem MeasureTheory.Content.measure_apply :
    ∀ {G : Type w} [inst : TopologicalSpace G] (μ : MeasureTheory.Content G) [inst_1 : R1Space G]
      [S : MeasurableSpace G] [inst_2 : BorelSpace G] {s : Set G},
      MeasurableSet s → ↑↑(MeasureTheory.Content.measure μ) s = ↑(MeasureTheory.Content.outerMeasure μ) s :=
  by sorry

This theorem states that for any topological space `G`, given a measure content `μ` and a set `s` in `G` that is measurable, the measure of `s` induced by the outer measure derived from `μ`, is equal to the outer measure of `s` obtained directly from `μ`. This holds true regardless of the specific type of the topological space, provided the space is both a measurable space and a Borel space.

For any measurable and Borel topological space `(G, τ)` and measurable set `s ∈ G` with respect to the σ-algebra generated by the open sets, the measure `μ(s)` equals the outer measure `μ∗(s)`.


theorem MeasureTheory.dominatedFinMeasAdditive_condexpInd :
    ∀ {α : Type u_1} (G : Type u_5) [inst : NormedAddCommGroup G] {m m0 : MeasurableSpace α} [inst_1 : NormedSpace ℝ G]
      (hm : m ≤ m0) (μ : MeasureTheory.Measure α) [inst_2 : MeasureTheory.SigmaFinite (μ.trim hm)],
      MeasureTheory.DominatedFinMeasAdditive μ (MeasureTheory.condexpInd G hm μ) 1 :=
  by sorry

This theorem states that for any types `α` and `G`, with `G` being a normed additive commutative group, any two measurable spaces `m` and `m0` on `α` with `m` being a sub-measure of `m0`, a measure `μ` on `α` that is sigma-finite when trimmed by `m`, the function `MeasureTheory.condexpInd G hm μ` is a dominated finite measure additive function. In other words, the function is finite measure additive and its norm on any measurable set is less than or equal to the measure of the set. The domination constant in this case is `1`.

For any sigma-finite measure `μ` on a measurable space `(α, G)` that is a sub-measure of a finite measure `m0`, the function `MeasureTheory.condexpInd G m μ` is a dominated finite measure additive function with domination constant 1.


theorem iSup_and :
    ∀ {α : Type u_1} [inst : CompleteLattice α] {p q : Prop} {s : p ∧ q → α}, iSup s = ⨆ (h₁ : p), ⨆ (h₂ : q), s ⋯ := by
  sorry

This theorem is about the indexed supremum of a function in the context of a complete lattice. Specifically, it states that for any type `α` forming a complete lattice, and any propositions `p` and `q`, the indexed supremum of a function `s` (which maps from the conjunction of `p` and `q` to `α`) is equal to the supremum taken over all proofs `h₁` of `p` and all proofs `h₂` of `q` of the values `s` can take. In mathematical terms, this can be written as $\sup_{(p \land q)} s = \sup_p \sup_q s$.

Given a complete lattice `α` and a function `s` from the conjunction of propositions `p` and `q` to `α`, the indexed supremum of `s` equals the supremum over all proofs `h₁` of `p` and all proofs `h₂` of `q` of the values `s h₁ h₂`. In mathematical notation, $\sup_{(p \land q)} s = \sup_p \sup_q s(h₁, h₂)$.


theorem div_ne_zero : ∀ {G₀ : Type u_3} [inst : GroupWithZero G₀] {a b : G₀}, a ≠ 0 → b ≠ 0 → a / b ≠ 0 := by sorry

This theorem states that for any type `G₀` which forms a group with a zero element, if we have two elements `a` and `b` from this group, where neither `a` nor `b` are zero, then the division of `a` by `b` (represented as `a / b`) will also be a non-zero element. This is a property of division in groups with a zero element.

In a group with a zero element, the quotient of two non-zero elements is a non-zero element.


theorem iInf_iInf_eq_left :
    ∀ {α : Type u_1} {β : Type u_2} [inst : CompleteLattice α] {b : β} {f : (x : β) → x = b → α},
      ⨅ x, ⨅ (h : x = b), f x h = f b ⋯ :=
  by sorry

This theorem, named `iInf_iInf_eq_left`, states that for any types `α` and `β`, where `α` is a Complete Lattice, and for any value `b` of type `β` and any function `f` from type `β` which equates to `b` to type `α`, the infimum (denoted by `⨅`) over all `x` of the infimum over all `h` where `h` is the equality `x = b` of `f(x, h)` is equal to `f(b, ...)`. In simpler terms, it's saying that in a Complete Lattice, the infimum of the infimum of a certain function `f` over all `x` equal to `b` is equal to the function evaluated at `b`.

In a complete lattice, for any function from the lattice to itself, the infimum of the infima over all elements equal to a given one is equal to the image of that element under the function.


theorem ProbabilityTheory.kernel.deterministic_apply :
    ∀ {α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {f : α → β} (hf : Measurable f)
      (a : α), (ProbabilityTheory.kernel.deterministic f hf) a = MeasureTheory.Measure.dirac (f a) :=
  by sorry

This theorem states that for any measurable spaces `α` and `β`, and any measurable function `f` from `α` to `β`, the application of the deterministic kernel to a point `a` in `α` results in the Dirac measure at `f(a)`. In other words, the deterministic kernel associates each point in `α` with the Dirac measure at the corresponding point `f(a)` in `β`, acting as a Markov kernel in probability theory.

For any measurable spaces `α` and `β` and measurable function `f:` `α` → `β`, the deterministic kernel `K_f` satisfies `K_f(a) = δ(f(a))`, where `δ` denotes the Dirac measure.


LipschitzWith.id

/-- The identity is 1-Lipschitz.  -/
theorem LipschitzWith.id : ∀ {α : Type u} [inst : PseudoEMetricSpace α], LipschitzWith 1 id := by sorry

This theorem states that the identity function is 1-Lipschitz. In other words, in any pseudoemetric space, the distance between the images of any two points under the identity function is less than or equal to one times the distance between the points themselves. This is generally expressed as `dist(f(x), f(y)) ≤ K * dist(x, y)`, where `f` is the function in question (in this case, the identity function), `x` and `y` are any two points in the space, and `K` is the Lipschitz constant (in this case, 1).

In any pseudometric space, the distance between the identity function's images of any two points is no greater than the distance between the points themselves.


theorem Stream'.corec_eq :
    ∀ {α : Type u} {β : Type v} (f : α → β) (g : α → α) (a : α),
      Stream'.corec f g a = Stream'.cons (f a) (Stream'.corec f g (g a)) :=
  by sorry

The `Stream'.corec_eq` theorem states that for any types `α` and `β`, and for any functions `f` of type `α → β` and `g` of type `α → α`, and any element `a` of type `α`, the co-recursion of `f`, `g`, and `a` on a stream is equivalent to prepending the application of `f` to `a` (`f a`) onto the co-recursion of `f`, `g`, and the application of `g` to `a` (`g a`) on the stream. In simpler terms, this theorem establishes the behavior of the `Stream'.corec` function in terms of the `Stream'.cons` function and verifies its correctness in constructing streams using a co-recursive process.

For any types `α` and `β`, functions `f : α → β` and `g : α → α`, and element `a : α`, the co-recursive definition of a stream using `Stream'.corec f g a` is equivalent to prepending `f a` to the stream obtained by co-recursively applying `f` and `g` starting from `g a`.


theorem Int.ediv_mul_cancel : ∀ {a b : ℤ}, b ∣ a → a / b * b = a := by sorry

This theorem states that for any two integers `a` and `b`, if `b` divides `a` (i.e., `a` is divisible by `b` without remainder), then the result of `a` divided by `b` and subsequent multiplication by `b` equals to `a`. In other words, the division and subsequent multiplication effectively cancel out provided `b` divides `a` without leaving a remainder.

If `a` is divisible by `b`, then `a = (a / b) * b`.


theorem Nat.sub_lt_sub_left : ∀ {k m n : ℕ}, k < m → k < n → m - n < m - k := by sorry

This theorem states that for any three natural numbers `k`, `m`, and `n`, if `k` is less than `m` and `k` is less than `n`, then the difference of `m` and `n` is less than the difference of `m` and `k`. In other words, it expresses that subtracting a larger number from `m` results in a smaller result than subtracting a smaller number from `m`, given the ordering constraint on `k`, `m`, and `n`. This is a property of subtraction in the set of natural numbers.

For natural numbers `k`, `m`, and `n`, if `k` < `m` and `k` < `n`, then `m - k` < `m - n`.


theorem Matrix.mul_smul :
    ∀ {l : Type u_1} {m : Type u_2} {n : Type u_3} {R : Type u_7} {α : Type v} [inst : AddCommMonoid α] [inst_1 : Mul α]
      [inst_2 : Fintype n] [inst_3 : Monoid R] [inst_4 : DistribMulAction R α] [inst_5 : SMulCommClass R α α]
      (M : Matrix m n α) (a : R) (N : Matrix n l α), M * a • N = a • (M * N) :=
  by sorry

The theorem `Matrix.mul_smul` states that for any type `l`, `m`, `n`, `R`, and `α`, given the conditions that `α` forms an additive commutative monoid and can be multiplied, `n` is a finite type, `R` forms a monoid, `α` is a distributive multiplication action of `R`, and `R` and `α` form a scalar multiplication commutative class, then for any matrix `M` with indices from `m` to `n` and entries in `α`, any element `a` from `R`, and any matrix `N` with indices from `n` to `l` and entries in `α`, the multiplication of `M` and the scalar multiplication of `a` and `N` equals the scalar multiplication of `a` and the multiplication of `M` and `N`. In mathematical notation, this says $M \cdot (a \cdot N) = a \cdot (M \cdot N)$.

For matrices $M$ of size $(m \times n)$ and $(N$ of size $(n \times l)$ over an additive commutative monoid $\alpha$ with distributive multiplication action by a monoid $R$, where $\alpha$ and $R$ form a scalar multiplication commutative class, the multiplication of $M$ with the scalar multiplication of $a \in R$ and $N$ equals the scalar multiplication of $a$ and the product of $M$ and $N$: $M \cdot (a \cdot N) = a \cdot (M \cdot N)$.


theorem LinearIndependent.cardinal_lift_le_rank :
    ∀ {R : Type u} {M : Type v} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] [inst_3 : Nontrivial R]
      {ι : Type w} {v : ι → M},
      LinearIndependent R v → Cardinal.lift.{v, w} (Cardinal.mk ι) ≤ Cardinal.lift.{w, v} (Module.rank R M) :=
  by sorry

The theorem `LinearIndependent.cardinal_lift_le_rank` states that for any ring `R` and `AddCommGroup` `M` (with `M` being a module over `R`), given a family of vectors `v` indexed by type `ι` that is linearly independent over `R`, the cardinality of `ι` (after applying the universe lift operation) is less than or equal to the rank of the module `M` over `R` (again, after applying the universe lift operation). In other words, the lifted cardinality of the set of indices of a linearly independent family of vectors is less than or equal to the lifted rank of the module.

For any ring `R` and `AddCommGroup` `M` (a module over `R`), if `ι` is the index type of a linearly independent family of vectors in `M` over `R`, then the lifted cardinality of `ι` is less than or equal to the lifted rank of `M` over `R`.


theorem Finset.mem_map' :
    ∀ {α : Type u_1} {β : Type u_2} (f : α ↪ β) {a : α} {s : Finset α}, f a ∈ Finset.map f s ↔ a ∈ s := by sorry

The theorem `Finset.mem_map'` states that for all types `α` and `β`, and for all embedding function `f` from `α` to `β`, an element `a` of type `α`, and a finset `s` of type `α`, the element `f a` is in the image of the finset `s` under the function `f` if and only if the element `a` is in the finset `s`. In other words, this theorem provides a condition to check if an element is in the image of a finset under an embedding function.

For all types `α` and `β`, and for all embedding functions `f` from `α` to `β`, if `a` is an element of finset `s` of type `α`, then `f a` is an element of the image of `s` under `f`. Conversely, if `f a` is an element of the image of `s`, then `a` is an element of `s`.


theorem zpow_strictMono :
    ∀ {α : Type u_1} [inst : LinearOrderedSemifield α] {a : α}, 1 < a → StrictMono fun x => a ^ x := by sorry

The theorem `zpow_strictMono` states that for any type `α` that has a structure of a linearly ordered semifield, and for any element `a` of `α` which is greater than 1, the function `f(x) = a^x` is strictly monotonic. That is, for any two elements `b` and `c` of `α` such that `b < c`, we will have `a^b < a^c`.

For any linearly ordered semifield type `α` and element `a` greater than 1 in `α`, the function `x ↔ a^x` is strictly increasing.


theorem OrthonormalBasis.coe_toBasis :
    ∀ {ι : Type u_1} {𝕜 : Type u_3} [inst : RCLike 𝕜] {E : Type u_4} [inst_1 : NormedAddCommGroup E]
      [inst_2 : InnerProductSpace 𝕜 E] [inst_3 : Fintype ι] (b : OrthonormalBasis ι 𝕜 E),
      ⇑(OrthonormalBasis.toBasis b) = ⇑b :=
  by sorry

This theorem states that for any type `ι`, any ring `𝕜` where `𝕜` is an instance of `RCLike`, and any type `E` which forms a normed additive commutative group and an inner product space over `𝕜`, if `b` is an orthonormal basis of `E` indexed by `ι` over `𝕜`, then the function obtained by applying the coercion of `b` via the `toBasis` function of `OrthonormalBasis` is the same as the function obtained by directly coercing `b`. In other words, converting an orthonormal basis to a basis doesn't change the basis elements when you map over the index set `ι`.

For any type `ι`, ring `𝕜`, type `E` forming a normed additive commutative group and inner product space over `𝕜`, and orthonormal basis `b: E ⊓ ι → E` of `E` over `𝕜`, the coercions of `b` via `toBasis` of `OrthonormalBasis` and directly coercing `b` are equal.


theorem Mathlib.LinearAlgebra.Prod._auxLemma.1 :
    ∀ {R : Type u_1} {R₂ : Type u_3} {M : Type u_6} {M₂ : Type u_8} [inst : Semiring R] [inst_1 : Semiring R₂]
      [inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid M₂] [inst_4 : Module R M] [inst_5 : Module R₂ M₂]
      {τ₁₂ : R →+* R₂} {F : Type u_12} [inst_6 : FunLike F M M₂] [inst_7 : SemilinearMapClass F τ₁₂ M M₂] {f : F}
      {y : M}, (y ∈ LinearMap.ker f) = (f y = 0) :=
  by sorry

The theorem `Mathlib.LinearAlgebra.Prod._auxLemma.1` states that for any semirings `R` and `R₂`, additively commutative monoids `M` and `M₂`, `R`-module `M`, `R₂`-module `M₂`, a ring homomorphism `τ₁₂` from `R` to `R₂`, a type `F` which is "function-like" from `M` to `M₂`, and which is a semilinear map from `M` to `M₂` over the ring homomorphism `τ₁₂`, and for any element `f` of type `F` and `y` of type `M`, the statement `y` is in the kernel of `f` is equivalent to the statement that applying `f` to `y` yields the zero element of `M₂`. In other words, an element `y` lies in the kernel of the semilinear map `f` if and only if `f(y)` equals zero.

For any semirings R and R₂, additively commutative monoids M and M₂, R-module M, R₂-module M₂, a ring homomorphism τ₁₂ from R to R₂, a semilinear map F from M to M₂ over τ₁₂, and any y in M, the element y lies in the kernel of F if and only if F(y) = 0 in M₂.


theorem AbsoluteValue.ne_zero :
    ∀ {R : Type u_5} {S : Type u_6} [inst : Semiring R] [inst_1 : OrderedSemiring S] (abv : AbsoluteValue R S) {x : R},
      x ≠ 0 → abv x ≠ 0 :=
  by sorry

This theorem states that for any given types `R` and `S`, where `R` is a semiring and `S` is an ordered semiring, and for any absolute value function `abv` from `R` to `S`, if a value `x` from `R` is not equal to zero, then the absolute value of `x` (i.e., `abv x`) is also not equal to zero. This is a generalization of the familiar property of absolute values from real numbers, where the absolute value of a non-zero number is always non-zero.

If `abv` is an absolute value function from the semiring `R` to the ordered semiring `S`, then `abv (xs : R) ≠ 0` whenever `xs ≠ 0`.


theorem StrictMonoOn.lt_iff_lt :
    ∀ {α : Type u} {β : Type v} [inst : LinearOrder α] [inst_1 : Preorder β] {f : α → β} {s : Set α},
      StrictMonoOn f s → ∀ {a b : α}, a ∈ s → b ∈ s → (f a < f b ↔ a < b) :=
  by sorry

This theorem states that for any two types `α` and `β`, where `α` is a linear order and `β` is a preorder, and for any function `f` from `α` to `β` and any set `s` of type `α`, if `f` is strictly monotonic on `s`, then for all `a` and `b` in `s`, `f(a)` is less than `f(b)` if and only if `a` is less than `b`. In other words, a strictly monotonic function preserves the order of its inputs in the set.

If `f` is a strictly monotonic function from a linear order `α` to a preorder `β`, then `a < b` in `α` implies `f(a) < f(b)` in `β`.


Function.Commute.symm

theorem Function.Commute.symm : ∀ {α : Type u_1} {f g : α → α}, Function.Commute f g → Function.Commute g f := by sorry

The theorem `Function.Commute.symm` states that for any type `α` and any two functions `f` and `g` from `α` to `α`, if `f` and `g` commute, then `g` and `f` also commute. In other words, if the function composition `f(g(x))` equals `g(f(x))` for all `x` in `α`, then the function composition `g(f(x))` also equals `f(g(x))` for all `x` in `α`. This is the commutativity property of function composition.

If functions `f` and `g` from type `α` to `α` commute, that is, `f(g(x)) = g(f(x))` for all `x` in `α`, then they are interchangeable in function composition, i.e., `g(f(x)) = f(g(x))` for all `x` in `α`.


OrderIso.surjective

theorem OrderIso.surjective :
    ∀ {α : Type u_2} {β : Type u_3} [inst : LE α] [inst_1 : LE β] (e : α ≃o β), Function.Surjective ⇑e := by sorry

The theorem `OrderIso.surjective` states that for any two types `α` and `β` that have an order relation (represented by `LE α` and `LE β` respectively), if there is an order isomorphism `e` between `α` and `β` (denoted by `α ≃o β`), then the function represented by `e` (obtained by applying the coercion to function, `⇑e`) is surjective. In terms of mathematics, this means that for every element `b` from `β`, there exists an element `a` from `α` such that `b` is the image of `a` under the function represented by `e`. This theorem essentially asserts that every order isomorphism is a surjective function.

For any order isomorphic types `α` and `β`, the order isomorphism between them induces a surjective function from `α` to `β`.


/-- An element of a ring multiplied by the additive inverse of one is the element's additive
inverse.  -/
theorem mul_neg_one : ∀ {α : Type u} [inst : MulOneClass α] [inst_1 : HasDistribNeg α] (a : α), a * -1 = -a := by sorry

This theorem states that, for any element `a` of a ring-type `α`, the product of `a` and the additive inverse of one equals the additive inverse of `a`. In mathematical terms, for all `a` in a ring `α`, `a * -1 = -a`. This theorem holds for all types `α` that have a multiplication operation (`MulOneClass α`) and an additive inverse operation (`HasDistribNeg α`).

For any element `a` in a ring `α` with additive inverse, `a * (-1) = -(a)`.


theorem Set.Subsingleton.induction_on :
    ∀ {α : Type u} {s : Set α} {p : Set α → Prop}, Set.Subsingleton s → p ∅ → (∀ (x : α), p {x}) → p s := by sorry

This theorem, `Set.Subsingleton.induction_on`, is a principle of induction for subsets of a type `α` that have at most one element (also known as subsingleton sets). It states that for any property `p` of subsets of `α`, if `p` is true for the empty set and for any singleton set `{x}` where `x` is an element of `α`, then `p` is true for any subsingleton set `s`. In other words, given a property `p`, if `p` holds for the empty set and all singleton sets, it must also hold for all subsingleton sets.

If a property holds for the empty set and singletons, it holds for all subsingletons (subsets with at most one element) in a type `α`.


theorem Nat.gt_of_not_le : ∀ {n m : ℕ}, ¬n ≤ m → n > m := by sorry

This theorem states that for any two natural numbers `n` and `m`, if it is not the case that `n` is less than or equal to `m`, then `n` must be strictly greater than `m`. In other words, if `n` is not less than or equal to `m` in the natural numbers, the only other possibility is that `n` is greater than `m`.

If `n` is not less than or equal to `m` in the natural numbers, then `n` is strictly greater than `m`.


theorem add_sub_add_left_eq_sub : ∀ {G : Type u_3} [inst : AddCommGroup G] (a b c : G), c + a - (c + b) = a - b := by
  sorry

This theorem states that for any type `G` which is an instance of an additive commutative group, for any three elements `a`, `b`, and `c` of `G`, the equation `c + a - (c + b) = a - b` holds true. In other words, if you add `c` to `a` and subtract the sum of `c` and `b`, the result is the same as just subtracting `b` from `a`.

For any additive commutative group `G` and elements `a`, `b`, `c` in `G`, `c + a - (c + b) = a - b`.


theorem decide_eq_true : ∀ {p : Prop} [inst : Decidable p], p → decide p = true := by sorry

This theorem, named `decide_eq_true`, establishes that for any proposition `p` of type `Prop` and given that `p` is decidable (i.e., there exists a proof or disproof for `p`), if `p` is true, then the function `decide` applied to `p` is equal to `true`. Essentially, it states that if a proposition is true and decidable, applying the decision function to that proposition will return `true`.

If `p` is a decidable proposition of type `Prop` in Lean 4 and `p` is true, then `decide p = true`.


theorem closure_compl : ∀ {X : Type u} {s : Set X} [inst : TopologicalSpace X], closure sᶜ = (interior s)ᶜ := by sorry

This theorem states that, for any set `s` in a topological space `X`, the closure of the complement of `s` is equal to the complement of the interior of `s`. In other words, it provides a relationship between the complementary operations and the closure and interior operations in a topological space. The closure of a set `s` represents the smallest closed set that includes `s`, while the interior of `s` represents the largest open set that is a subset of `s`. The complement of a set is the set of all elements not in the set, so this theorem shows how these concepts interact.

The closure of a set's complement is equal to the complement of its interior in a topological space.


theorem Order.le_pred_of_lt :
    ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : PredOrder α] {a b : α}, a < b → a ≤ Order.pred b := by sorry

This theorem states that for any type `α` that has a preorder and predecessor order structure, given any two elements `a` and `b` of type `α`, if `a` is less than `b`, then `a` is less than or equal to the predecessor of `b`. In other words, if `a` is strictly less than `b`, it is also less than or equal to the greatest element that is less than `b`. If `b` is a minimal element, then its predecessor is `b` itself, so `a` is less than or equal to `b`.

For any preorder `α` with a predecessor order structure, if `a` is less than `b`, then `a` is less than or equal to the predecessor of `b`.


theorem iSup_bot : ∀ {α : Type u_1} {ι : Sort u_5} [inst : CompleteLattice α], ⨆ x, ⊥ = ⊥ := by sorry

This theorem states that for any type `α` that forms a complete lattice, and for any index type `ι`, the supremum (or least upper bound) of the bottom element `⊥` over all `x` drawn from type `ι` is equivalent to the bottom element `⊥` itself. In essence, it's asserting the property that the least upper bound of the smallest element in a complete lattice, irrespective of how we index or enumerate it, remains the smallest element.

For any complete lattice `α` and index type `ι`, the supremum of the bottom element `⊥` over all `x : ι` is equal to `⊥`.


theorem Fin.succ_lt_succ_iff : ∀ {n : ℕ} {a b : Fin n}, Fin.succ a < Fin.succ b ↔ a < b := by sorry

This theorem, named `Fin.succ_lt_succ_iff`, states that for all natural numbers `n` and for all elements `a` and `b` of the type `Fin n` (which represents the set of natural numbers less than `n`), the condition "the successor of `a` is less than the successor of `b`" is equivalent to the condition " `a` is less than `b`". In other words, the comparison of the order of `a` and `b` is the same whether we consider `a` and `b` themselves or their successors. This theorem is a formalization of the intuitive fact about the order of natural numbers.

For all natural numbers `n` and `a`, `b` in `Fin n`, `a < b` if and only if `a.succ` is less than `b.succ`.


theorem Convex.combo_self :
    ∀ {R : Type u_2} {M : Type u_5} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {a b : R},
      a + b = 1 → ∀ (x : M), a • x + b • x = x :=
  by sorry

The theorem `Convex.combo_self` states that for any semiring `R`, any additive commutative monoid `M`, and any module `M` over `R`, if `a` and `b` are elements of `R` such that `a + b` is equal to `1`, then for any `x` in `M`, the sum of `a` scaled by `x` and `b` scaled by `x` equals `x`. In other words, this theorem describes a property of convex combinations in the context of linear algebra, stating that if a point `x` is expressed as a convex combination of itself, then the coefficients add up to 1.

For any semiring R, additive commutative monoid M, and R-module M, if a and b are elements of R with a + b = 1, then for any x in M, ax + bx = x.


theorem MeasureTheory.AEStronglyMeasurable.mono_measure :
    ∀ {α : Type u_1} {β : Type u_2} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} [inst : TopologicalSpace β]
      {f : α → β} {ν : MeasureTheory.Measure α},
      MeasureTheory.AEStronglyMeasurable f μ → ν ≤ μ → MeasureTheory.AEStronglyMeasurable f ν :=
  by sorry

This theorem states that for any types `α` and `β`, a measurable space `m` on `α`, a measure `μ` on `α`, a topological space structure on `β`, a function `f` from `α` to `β`, and another measure `ν` on `α`, if the function `f` is almost everywhere strongly measurable with respect to the measure `μ`, and the measure `ν` is less than or equal to the measure `μ`, then the function `f` is also almost everywhere strongly measurable with respect to the measure `ν`. In other words, the property of a function being almost everywhere strongly measurable under a measure is preserved when we replace the measure with another that is smaller or equal.

If `α`, `β`, `m` a measurable space on `α`, `μ` a measure on `α`, `ν` another measure on `α` with `ν ≤ μ`, `f` a strongly measurable function from `α` to `β` with respect to `μ`, then `f` is also strongly measurable with respect to `ν`.


theorem Set.union_inter_distrib_right : ∀ {α : Type u} (s t u : Set α), (s ∪ t) ∩ u = s ∩ u ∪ t ∩ u := by sorry

This theorem states that for any type `α` and any three sets `s`, `t`, and `u` of this type, the union of `s` and `t` intersected with `u` is equal to the union of the intersection of `s` with `u` and the intersection of `t` with `u`. In mathematical notation, this is represented as $(s \cup t) \cap u = (s \cap u) \cup (t \cap u)$. This theorem essentially demonstrates the distributive property of intersection over union in the context of sets.

The theorem asserts that for any sets `s`, `t`, and `u`, the intersection of their union and `u` equals the union of their intersections with `u`. In mathematical notation, $(s \cup t) \cap u = (s \cap u) \cup (t \cap u)$.


theorem Specializes.mem_open :
    ∀ {X : Type u_1} [inst : TopologicalSpace X] {x y : X} {s : Set X}, x ⤳ y → IsOpen s → y ∈ s → x ∈ s := by sorry

This theorem, named `Specializes.mem_open`, is about topological spaces and the concept of specialization. It states that, for any type `X` that has a topological space structure, and for any two elements `x` and `y` of type `X`, if `x` specializes to `y` (denoted as `x ⤳ y`), and if a set `s` of elements of type `X` is open in this topological space and contains `y`, then `s` must also contain `x`. In other words, if `x` specializes to `y` and `y` belongs to an open set, then `x` will also belong to that open set.

If `x ⤳ y` and `y ∈ s`, then `x ∈ s` for any open set `s` in a topological space `X`.


theorem inf_le_sup : ∀ {α : Type u} [inst : Lattice α] {a b : α}, a ⊓ b ≤ a ⊔ b := by sorry

This theorem, `inf_le_sup`, states that for all types `α` that form a lattice (a mathematical structure with two binary operations called 'meet' and 'join'), the infimum (or 'meet', denoted by `⊓`) of any two elements `a` and `b` of the lattice is less than or equal to the supremum (or 'join', denoted by `⊔`) of those two elements. In mathematical terms, for any two elements `a` and `b` in a lattice `α`, it's always true that `a ⊓ b ≤ a ⊔ b`.

For all lattices α and elements a, b in α, the infimum (meet) of a and b is less than or equal to the supremum (join) of a and b: a ⊓ b ≤ a ⊔ b.


theorem FirstOrder.Language.Theory.realize_sentence_of_mem :
    ∀ {L : FirstOrder.Language} {M : Type w} [inst : FirstOrder.Language.Structure L M]
      (T : FirstOrder.Language.Theory L) [inst_1 : M ⊨ T] {φ : FirstOrder.Language.Sentence L}, φ ∈ T → M ⊨ φ :=
  by sorry

This theorem states that for any first-order language `L`, any type `M` that has a `FirstOrder.Language.Structure` over `L`, and any theory `T` in the language `L` that `M` realizes, if a sentence `φ` belongs to the theory `T`, then `M` realizes the sentence `φ`. In other words, an interpretation `M` of a theory `T` in a first-order language `L` makes every sentence in `T` true.

For any first-order language L, type M with a FirstOrder.Language.Structure over L, and theory T in L realized by M, if φ ∈ T then M |- φ (M satisfies sentence φ from theory T).


LieHom.ext

theorem LieHom.ext :
    ∀ {R : Type u} {L₁ : Type v} {L₂ : Type w} [inst : CommRing R] [inst_1 : LieRing L₁] [inst_2 : LieAlgebra R L₁]
      [inst_3 : LieRing L₂] [inst_4 : LieAlgebra R L₂] {f g : L₁ →ₗ⁅R⁆ L₂}, (∀ (x : L₁), f x = g x) → f = g :=
  by sorry

This theorem, `LieHom.ext`, states that for any commutative ring `R` and two Lie algebras `L₁` and `L₂` over `R`, if two Lie algebra homomorphisms `f` and `g` from `L₁` to `L₂` agree on all elements of `L₁` (i.e., `f x = g x` for all `x` in `L₁`), then `f` and `g` must be the same homomorphism. In other words, two Lie algebra homomorphisms are identical if they coincide on every element of the domain.

If `R` is a commutative ring and `f` and `g` are Lie algebra homomorphisms from a Lie algebra `L₁` to a Lie algebra `L₂` over `R` such that `f x = g x` for all `x` in `L₁`, then `f = g`.


theorem Filter.HasBasis.prod_self :
    ∀ {α : Type u_1} {ι : Sort u_4} {la : Filter α} {pa : ι → Prop} {sa : ι → Set α},
      Filter.HasBasis la pa sa → Filter.HasBasis (la ×ˢ la) pa fun i => sa i ×ˢ sa i :=
  by sorry

The theorem `Filter.HasBasis.prod_self` states that for any type `α` and any sort `ι`, given a filter `la` on `α`, a predicate `pa` on `ι`, and a function `sa` mapping `ι` to a set of elements of type `α`, if `la` has a basis characterized by the predicate `pa` and the set function `sa`, then the product filter (i.e., `la ×ˢ la`) also has a basis characterized by the same predicate `pa` and the set function that maps `ι` to the product set (i.e., `sa i ×ˢ sa i`). Essentially, this theorem says that the basis of a product filter is the product of the bases of the original filters.

If filters `la` on type `α` and `lb` on sort `ι` have bases characterized by predicate `pa` and set functions `sa` and `sb` respectively, then the product filter `la ×ˢ lb` has a basis characterized by predicate `pa` and the set function mapping `ι` to `sa i ×ˢ sb i`.


theorem CategoryTheory.Comonad.Coalgebra.Hom.ext' :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {G : CategoryTheory.Comonad C}
      (X Y : CategoryTheory.Comonad.Coalgebra G) (f g : X ⟶ Y), f.f = g.f → f = g :=
  by sorry

This theorem states that for any given category `C`, and any comonad `G` on `C`, if we have two coalgebras `X` and `Y` of `G`, and two morphisms `f` and `g` from `X` to `Y`, then if the underlying functions of `f` and `g` are equal (i.e., `f.f = g.f`), then the morphisms themselves are equal, i.e., `f = g`. In mathematical terms, this asserts the uniqueness of morphisms in the category of coalgebras for a given comonad, based solely on their underlying function.

If `C` is a category, `G` is a comonad on `C`, `X` and `Y` are coalgebras of `G`, and `f` and `g` are morphisms from `X` to `Y` with equal underlying functions, then `f = g`.


theorem Fintype.card_le_of_surjective :
    ∀ {α : Type u_1} {β : Type u_2} [inst : Fintype α] [inst_1 : Fintype β] (f : α → β),
      Function.Surjective f → Fintype.card β ≤ Fintype.card α :=
  by sorry

The theorem `Fintype.card_le_of_surjective` states that for any two types `α` and `β`, both of which have a fintype instance, if there exists a surjective function `f` from `α` to `β`, then the cardinality (number of elements) in `β` is less than or equal to the cardinality of `α`. In other words, if every element of `β` can be mapped from some element in `α` using function `f`, then `β` cannot have more elements than `α`.

If `α` and `β` are finite types with a surjective function `f` from `α` to `β`, then the cardinality of `β` is less than or equal to the cardinality of `α`.


theorem CategoryTheory.Equivalence.inv_fun_map :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂}
      [inst_1 : CategoryTheory.Category.{v₂, u₂} D] (e : C ≌ D) (X Y : C) (f : X ⟶ Y),
      e.inverse.map (e.functor.map f) =
        CategoryTheory.CategoryStruct.comp (e.unitInv.app X) (CategoryTheory.CategoryStruct.comp f (e.unit.app Y)) :=
  by sorry

The theorem `CategoryTheory.Equivalence.inv_fun_map` states that in the setting of category theory, for any two categories `C` and `D` that are equivalent (denoted `C ≌ D`), and any two objects `X` and `Y` in `C`, and a morphism `f` from `X` to `Y` (denoted `X ⟶ Y`), the image of the morphism `f` under the functor associated with the equivalence, when mapped back using the inverse of the equivalence, is the same as first applying the unit inverse at `X`, then composing with `f`, and then applying the unit at `Y`.

In simpler terms, this theorem is about "going around in a loop" in a specific way within an equivalence of categories, and ending up where you started. This is a fundamental property in category theory that such a loop, involving functors and natural transformations (the 'unit' and 'unit inverse' are examples of these), doesn't change the morphism you started with.

Given any equivalence of categories `C ≌ D` and morphisms `X ⟶ Y` in `C`, the image of `f` under the functor associated with the equivalence, followed by the inverse equivalence, is equivalent to applying the unit inverse at `X`, then `f`, and then the unit at `Y`.


theorem measurableSet_Ici :
    ∀ {α : Type u_1} [inst : TopologicalSpace α] [inst_1 : MeasurableSpace α] [inst_2 : OpensMeasurableSpace α]
      [inst_3 : Preorder α] [inst : OrderClosedTopology α] {a : α}, MeasurableSet (Set.Ici a) :=
  by sorry

This theorem states that for any type `α` which has a topological space structure, a measurable space structure, an ordered set structure, where the topology is generated by open intervals and the order topology is closed, and for any element `a` of type `α`, the set of all elements `x` in `α` such that `x` is greater than or equal to `a` (represented by `Set.Ici a`) is a measurable set. In other words, it's saying that the left-closed right-infinite interval on a measurable space with an order-closed topology is measurable.

Given a type `α` with a topology generated by open intervals, an order topology that is closed, and a measurable space structure, the set `{x : α | x ≥ a}` is measurable for any `a` in `α`.


theorem Mathlib.Data.Complex.Basic._auxLemma.12 : ∀ (n : ℕ) (r : ℝ), n • ↑r = ↑(n • r) := by sorry

This theorem states that for all natural numbers `n` and for all real numbers `r`, the scalar multiplication of `n` and the complex number form of `r` is equal to the complex number form of the scalar multiplication of `n` and `r`. In mathematical symbols, for all n in ℕ and r in ℝ, n * complex(r) = complex(n * r).

For all natural numbers n and real numbers r, the scalar multiplication of n with the complex number ir is equal to the complex number obtained by scaling ir by n.


theorem Set.compl_Iic : ∀ {α : Type u_1} [inst : LinearOrder α] {a : α}, (Set.Iic a)ᶜ = Set.Ioi a := by sorry

This theorem states that for any type `α` that has a linear order, the complement of the set of all elements `x` that are less than or equal to a given element `a` (denoted as `Set.Iic a`), is exactly the set of all elements `x` that are strictly greater than `a` (denoted as `Set.Ioi a`). In mathematical terms, this theorem states that for any `a` in a linearly ordered set `α`, the property `(∀x ∈ α, x ≤ a)^c = ∀x ∈ α, a < x` holds.

For any linearly ordered type `α` and element `a` in `α`, the complement of the set of elements less than or equal to `a` is equal to the set of elements strictly greater than `a`. In mathematical notation, `Set.Iic a = Set.Ioi a`.


theorem IsLocalization.mk'_spec :
    ∀ {R : Type u_1} [inst : CommSemiring R] {M : Submonoid R} (S : Type u_2) [inst_1 : CommSemiring S]
      [inst_2 : Algebra R S] [inst_3 : IsLocalization M S] (x : R) (y : ↥M),
      IsLocalization.mk' S x y * (algebraMap R S) ↑y = (algebraMap R S) x :=
  by sorry

The theorem `IsLocalization.mk'_spec` states that for any commutative semiring `R`, submonoid `M` of `R`, and a type `S` which is a commutative semiring, an `R`-algebra, and a localization of `R` at `M`, the operation `IsLocalization.mk' S x y` followed by multiplication by the image of `y` under the algebra mapping from `R` to `S`, equals the image of `x` under the same algebra mapping. In mathematical terms, it says that for any `x` in `R` and `y` in `M`, `f(x) * (f(y))^(-1) * f(y) = f(x)`, where `f` is the algebra map from `R` to `S`. Here, `f(x) * (f(y))^(-1)` is the surjection of the pair `(x, y)` by `IsLocalization.mk' S`.

For any commutative semiring `R`, submonoid `M` of `R`, and an `R`-algebra `S` that is a localization of `R` at `M`, the algebra map `f: R -> S` satisfies `f(x) = f(x) * (f(y))^(-1) * f(y)` for all `x in R` and `y in M`.


theorem Ordinal.sup_le_iff :
    ∀ {ι : Type u} {f : ι → Ordinal.{max u v}} {a : Ordinal.{max u v}}, Ordinal.sup f ≤ a ↔ ∀ (i : ι), f i ≤ a := by
  sorry

The theorem `Ordinal.sup_le_iff` states that for any type `ι`, any function `f` from `ι` to the type of ordinals, and any ordinal `a`, the supremum of the family of ordinals given by `f` is less than or equal to `a` if and only if every ordinal `f i` for `i` in `ι` is less than or equal to `a`. In other words, the supremum of a set of ordinals is less than or equal to an ordinal `a` if and only if all ordinals in the set are less than or equal to `a`.

The supremum of a family of ordinals \(f(i)\), where \(f\) is a function from a type \(\ι\) to the type of ordinals, is less than or equal to an ordinal \(a\) if and only if every \(f(i)\) is less than or equal to \(a\) for all \(i\) in \(\ι\).


theorem ContinuousMap.coe_pow :
    ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] [inst_2 : Monoid β]
      [inst_3 : ContinuousMul β] (f : C(α, β)) (n : ℕ), ⇑(f ^ n) = ⇑f ^ n :=
  by sorry

This theorem states that for any types `α` and `β`, where `α` is a topological space and `β` is a topological space with a monoid structure and a continuous multiplication, given a continuous map `f` from `α` to `β` and a natural number `n`, the operation of applying the continuous map `f` `n` times (`f` to the power of `n`) is equivalent to applying the map `f` once and then taking the result to the power of `n`. In other words, the power operation commutes with the application of a continuous map.

For any topological spaces `α` and `β` with `β` a monoid under a continuous multiplication, and for any continuous map `f : α → β` and natural number `n`, the map `f^n` is equivalent to the composition `(f ^ n) (x) = (f (x)) ^ n` for all `x ∈ α`.


theorem Set.mem_smul_set :
    ∀ {α : Type u_2} {β : Type u_3} [inst : SMul α β] {t : Set β} {a : α} {x : β}, x ∈ a • t ↔ ∃ y ∈ t, a • y = x := by
  sorry

This theorem states that for any types `α` and `β` where `α` has a scalar multiplication operation with `β`, any set `t` of type `β`, any element `a` of type `α`, and any element `x` of type `β`, `x` belongs to the scalar multiplication of `a` and `t` if and only if there exists an element `y` in `t` such that `a` scaled by `y` equals `x`. In mathematical terms, for any scalar `a` and any set `t`, an element `x` belongs to the scalar multiplication of `a` and `t` (`a∙t`) if and only if there's an element `y` in `t` such that `a∙y = x`.

For any scalar `a` and set `t`, an element `x` belongs to the scalar multiplication of `a` and `t` if and only if there exists an element `y` in `t` such that `a` scalar-multiplies `y` to obtain `x`. In Lean notation, `a ⊤ t = { y : β | ∃ (y' : β), a * y' = x }`.


theorem refl_le_uniformity : ∀ {α : Type ua} [inst : UniformSpace α], Filter.principal idRel ≤ uniformity α := by sorry

The theorem `refl_le_uniformity` states that for any type `α` equipped with a uniform space structure, the principal filter of the identity relation (`idRel`), which consists of all sets containing pairs `(x, x)` for some `x` in `α`, is a subset of the uniformity of `α`. In other words, every set in the uniformity of `α` contains all pairs of identical elements from `α`. This theorem provides a condition that is always satisfied by the uniformity in any uniform space.

In any uniform space, the principal filter of the identity relation is included in the uniformity.


theorem Finset.val_inj : ∀ {α : Type u_1} {s t : Finset α}, s.val = t.val ↔ s = t := by sorry

This theorem states that for any two finite sets `s` and `t` of some type `α`, the equivalence between the underlying value lists of `s` and `t` is the same as the equivalence between `s` and `t` themselves. In other words, if the lists of values for `s` and `t` are identical, then the two finite sets `s` and `t` are also identical, and vice versa.

For any type `α` and finite sets `s` and `t` of type `α`, `list.eq s t` if and only if `s = t`.


theorem Filter.le_pure_iff : ∀ {α : Type u} {f : Filter α} {a : α}, f ≤ pure a ↔ {a} ∈ f := by sorry

This theorem, `Filter.le_pure_iff`, states that for any type `α`, any filter `f` of type `α`, and any element `a` of type `α`, the filter `f` is less than or equal to the pure filter of `a` if and only if the singleton set containing `a` is in the filter `f`. In other words, a filter `f` includes the pure filter of `a` when the set containing only `a` is an element of the filter `f`.

A filter `f` of type `α` includes the pure filter of `a` if and only if `{a} ∈ f`.


theorem Set.uIcc_of_ge : ∀ {α : Type u_1} [inst : Lattice α] {a b : α}, b ≤ a → Set.uIcc a b = Set.Icc b a := by sorry

The theorem `Set.uIcc_of_ge` states that for any type `α` that forms a lattice, and for any two elements `a` and `b` of this type, if `b` is less than or equal to `a`, then the set of elements lying between `a` and `b` with both `a` and `b` included (`Set.uIcc a b`), is equal to the set of elements lying between `b` and `a` with both `b` and `a` included (`Set.Icc b a`). Essentially, it asserts that the interval from `a` to `b` is the same as the interval from `b` to `a` when `b` is less than or equal to `a` in a lattice structure.

For any lattice type `α` and elements `a` and `b` with `b ≤ a`, `Set.uIcc a b` equals `Set.Icc b a`.


/-- The neighbourhood filter of a nonzero element consists of all sets containing that
element.  -/
theorem WithZeroTopology.nhds_of_ne_zero :
    ∀ {Γ₀ : Type u_2} [inst : LinearOrderedCommGroupWithZero Γ₀] {γ : Γ₀}, γ ≠ 0 → nhds γ = pure γ := by sorry

This theorem states that in the context of a linearly ordered commutative group with zero, the neighborhood filter of a nonzero element consists only of sets containing that element. This means that any set that we consider as a 'neighborhood' of the element must contain the element itself, and this applies to all such elements that are not zero.

In a linearly ordered commutative group with zero, the neighborhood filter of each nonzero element is equal to the filter generated by that element.


theorem List.nil_sublist : ∀ {α : Type u_1} (l : List α), List.Sublist [] l := by sorry

This theorem states that for any given list `l` of elements of some arbitrary type `α`, the empty list (denoted by `[]`) is a sublist of `l`. In other words, it asserts that the empty list is always a sublist of any list regardless of the type of elements in the list.

For any list `l` of type `α`, the empty list `[]` is a sublist of `l`.


theorem MeasureTheory.laverage_eq :
    ∀ {α : Type u_1} {m0 : MeasurableSpace α} (μ : MeasureTheory.Measure α) (f : α → ENNReal),
      ⨍⁻ (x : α), f x ∂μ = (∫⁻ (x : α), f x ∂μ) / ↑↑μ Set.univ :=
  by sorry

This theorem, named `MeasureTheory.laverage_eq`, states that for any type `α` equipped with a measurable space `m0`, given a measure `μ` on that space and a function `f` mapping from the space to the nonnegative extended real numbers (represented by `ENNReal`), the lower integral (or infimum) of `f` with respect to the measure `μ` is equal to the ratio of the Lebesgue integral of `f` with respect to the measure `μ` and the measure of the entire space `Set.univ` (the universal set on the type `α`). This theorem thus establishes a relationship between the lower integral and the Lebesgue integral of a function in a measurable space.

For any measurable space `(α, m0)`, measure `μ`, and measurable function `f : α → ENNReal`, the lower integral of `f` with respect to `μ` equals the Lebesgue integral of `f` divided by the measure of the universal set `Set.univ` in `α` with respect to `m0` and `μ`.


/-- A group is nilpotent if and only if its lower central series eventually reaches
the trivial subgroup.  -/
theorem nilpotent_iff_lowerCentralSeries :
    ∀ {G : Type u_1} [inst : Group G], Group.IsNilpotent G ↔ ∃ n, lowerCentralSeries G n = ⊥ := by sorry

The theorem `nilpotent_iff_lowerCentralSeries` states that a group is nilpotent if and only if its lower central series eventually reaches the trivial subgroup. In other words, a group `G` is considered nilpotent when there exists a natural number `n` such that the `n`th term of its lower central series - a sequence of subgroups starting from the whole group `G` and iteratively taking the commutator of the current term and `G` - is the trivial subgroup (denoted as `⊥`).

A group is nilpotent if and only if its lower central series reaches the trivial subgroup.


/-- Just as `TensorProduct.ext` is marked `ext` instead of `TensorProduct.ext'`, this is
a better `ext` lemma than `TensorProduct.AlgebraTensorModule.ext` below.

See note [partially-applied ext lemmas].  -/
theorem TensorProduct.AlgebraTensorModule.curry_injective :
    ∀ {R : Type uR} {A : Type uA} {M : Type uM} {N : Type uN} {P : Type uP} [inst : CommSemiring R]
      [inst_1 : Semiring A] [inst_2 : Algebra R A] [inst_3 : AddCommMonoid M] [inst_4 : Module R M]
      [inst_5 : Module A M] [inst_6 : IsScalarTower R A M] [inst_7 : AddCommMonoid N] [inst_8 : Module R N]
      [inst_9 : AddCommMonoid P] [inst_10 : Module R P] [inst_11 : Module A P] [inst_12 : IsScalarTower R A P],
      Function.Injective TensorProduct.AlgebraTensorModule.curry :=
  by sorry

This theorem asserts that for all types `R`, `A`, `M`, `N`, `P`, equipped with certain algebraic structures (such as `CommSemiring`, `Semiring`, `Algebra`, `AddCommMonoid`, `Module`, and `IsScalarTower`), the `curry` function of the `AlgebraTensorModule` in the `TensorProduct` namespace is injective. In other words, if `curry f = curry g` then `f = g`. Here, `R`, `A` are rings, `M`, `N`, `P` are modules over the rings `R` and `A` with `M` and `P` forming a scalar tower over both `R` and `A` (meaning the action of `R` on `M` and `P` commutes with the action of `A`). Thus, the `curry` function, which maps linear maps from the tensor product of `M` and `N` to `P` into bilinear maps from `M` and `N` to `P`, is injective in this context.

For types `R`, `A`, `M`, `N`, `P` being rings with certain algebraic structures and `M` and `P` forming a scalar tower over both, the `curry` function of the `AlgebraTensorModule` in Lean's `TensorProduct` namespace mapping bilinear maps from `M` and `N` to `P` to linear maps from the tensor product of `M` and `N` to `P` is injective.


theorem map_ne_zero_iff :
    ∀ {R : Type u_10} {S : Type u_11} {F : Type u_12} [inst : Zero R] [inst_1 : Zero S] [inst_2 : FunLike F R S]
      [inst_3 : ZeroHomClass F R S] (f : F), Function.Injective ⇑f → ∀ {x : R}, f x ≠ 0 ↔ x ≠ 0 :=
  by sorry

The theorem `map_ne_zero_iff` states that for all types `R`, `S`, and `F`, given that `R` and `S` have a zero element, `F` is a function-like structure from `R` to `S`, and `F` is a zero-preserving homomorphism, then for any function `f` of type `F`, if `f` is injective, then for all `x` of type `R`, `f(x)` is not zero if and only if `x` is not zero. In other words, an injective zero-preserving homomorphism sends non-zero elements to non-zero elements.

An injective, zero-preserving homomorphism between two abelian groups maps non-zero elements to non-zero elements.


theorem Mathlib.Topology.EMetricSpace.Basic._auxLemma.13 :
    ∀ {α : Type u} [inst : PseudoEMetricSpace α] {x y : α} {ε : ENNReal}, (y ∈ EMetric.ball x ε) = (edist y x < ε) := by
  sorry

This theorem states that for any type `α` equipped with a pseudo extended metric space structure, and any two points `x` and `y` of type `α` and a nonnegative real number `ε`, the condition that `y` is in the ε-ball centered at `x` is equivalent to the extended distance between `y` and `x` being less than `ε`. In other words, a point `y` lies within the ε-ball around a point `x` if and only if the extended distance from `y` to `x` is less than `ε`.

For any pseudo extended metric space `(α, d)`, given points `x, y : α` and a nonnegative real `ε`, the conditions `y ∈ ε-ball x` and `d(x, y) < ε` are equivalent.


theorem Nat.one_lt_cast :
    ∀ {α : Type u_1} [inst : AddMonoidWithOne α] [inst_1 : PartialOrder α]
      [inst_2 : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] [inst_3 : ZeroLEOneClass α]
      [inst_4 : CharZero α] {n : ℕ}, 1 < ↑n ↔ 1 < n :=
  by sorry

This theorem, `Nat.one_lt_cast`, states that for any type `α` that has the structure of an additive monoid with an element designated as "one", is partially ordered, has a covariant class, has a zero less than or equal to one class, and has a character zero property, a natural number `n` is greater than 1 if and only if its typecast to `α` is also greater than 1. Essentially, it ensures the property of "being greater than 1" is preserved when casting from natural numbers to other number-like types.

For any additive monoid type `α` with one, partial order, covariant class, zero less than or equal to one class, and character zero property, the relation "greater than 1" for natural numbers is equivalent to the relation "greater than 1" for type-casted elements of `α`.


theorem Dilation.edist_eq :
    ∀ {α : Type u_1} {β : Type u_2} {F : Type u_4} [inst : PseudoEMetricSpace α] [inst_1 : PseudoEMetricSpace β]
      [inst_2 : FunLike F α β] [inst_3 : DilationClass F α β] (f : F) (x y : α),
      edist (f x) (f y) = ↑(Dilation.ratio f) * edist x y :=
  by sorry

This theorem, named `Dilation.edist_eq`, states that for any types `α`, `β`, and `F` where `α` and `β` are pseudo-emetric spaces and `F` is a function-like structure that maps `α` to `β` and is also a dilation, any function `f` of type `F`, and any elements `x` and `y` of type `α`, the extended distance between `f(x)` and `f(y)` in the pseudo-emetric space `β` is equal to the dilation ratio of `f` times the extended distance between `x` and `y` in the pseudo-emetric space `α`. In mathematical terms, `edist (f x) (f y) = ↑(Dilation.ratio f) * edist x y`. This theorem essentially describes how a dilation function impacts the distances in a pseudo-emetric space.

The extended distance between the images of two points under a dilation function is equal to the dilation ratio times the extended distance between the original points in a pseudo-metric space.


theorem Mathlib.Data.Fin.Tuple.Basic._auxLemma.4 :
    ∀ {α : Fin 0 → Sort u_1} {P : ((i : Fin 0) → α i) → Prop}, (∀ (x : (i : Fin 0) → α i), P x) = P finZeroElim := by
  sorry

The theorem `Mathlib.Data.Fin.Tuple.Basic._auxLemma.4` states that for any dependent type `α` indexed over `Fin 0` (the finite set with zero elements) and any property `P` that applies to functions from indices in `Fin 0` to elements of `α`, if the property `P` holds for all such functions `x`, then specifically, it holds for the function `finZeroElim`. In other words, since there are no indices in `Fin 0`, any property that is said to hold for all functions from `Fin 0` to `α` must certainly hold for `finZeroElim`, which is the function defined to handle this empty-index situation.

If a property `P` holds for all functions from `Fin 0` to a type `α`, then `P` holds for the function `finZeroElim` from `α` to itself.


theorem CategoryTheory.ShortComplex.LeftHomologyData.liftK_i :
    ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
      {S : CategoryTheory.ShortComplex C} (h : CategoryTheory.ShortComplex.LeftHomologyData S) {A : C} (k : A ⟶ S.X₂)
      (hk : CategoryTheory.CategoryStruct.comp k S.g = 0),
      CategoryTheory.CategoryStruct.comp (CategoryTheory.ShortComplex.LeftHomologyData.liftK h k hk) h.i = k :=
  by sorry

This theorem states that for any category `C` with zero morphisms, any short complex `S` in `C`, any left homology data `h` of `S`, and any morphism `k` from an object `A` to the third object `S.X₂` in `S` such that the composition of `k` and `S.g` (a morphism in `S`) is a zero morphism, the composition of the morphism obtained by lifting `k` with respect to `h` and the morphism `h.i` is equal to `k`. Essentially, this is a property of the lifting operation in the context of left homology data in a short complex in a category.

For any short complex in a category with zero morphisms and any left homology data, the morphism obtained by lifting a given morphism through the homology data equals the morphism itself when composed with the appropriate chain map and homology inclusion.


theorem Mathlib.GroupTheory.Subgroup.Basic._auxLemma.39 :
    ∀ {G : Type u_1} [inst : AddGroup G] (x : G), (x ∈ ⊤) = True := by sorry

This theorem is a statement in group theory related to additive groups. It says that for any type `G`, given that `G` forms an additive group `AddGroup G`, any element `x` of `G` is a member of the top subgroup (denoted by `⊤`). In other words, every element of an additive group is included in the universal subgroup.

In any additive group, every element is contained in the universal subgroup.


theorem Finsupp.sum_zero :
    ∀ {α : Type u_1} {M : Type u_8} {N : Type u_10} [inst : Zero M] [inst_1 : AddCommMonoid N] {f : α →₀ M},
      (Finsupp.sum f fun x x => 0) = 0 :=
  by sorry

The theorem `Finsupp.sum_zero` states that for any type `α`, types `M` and `N` where `M` has an instance of the `Zero` typeclass and `N` has an instance of the `AddCommMonoid` typeclass, and for any function `f` from `α` to `M`, the sum over the support of `f` of the function that constantly returns zero is always zero. In other words, the sum of zeroes over any set (in this case, the support of `f`) is zero.

For any function `f` from a type `α` to an additive commutative monoid `M` with a zero element, the sum of `f` evaluated at the zero element of `α` over the support of `f` is equal to the zero element of `M`.


/-- The complex cosine function is everywhere differentiable, with the derivative `-sin x`.  -/
theorem Complex.hasDerivAt_cos : ∀ (x : ℂ), HasDerivAt Complex.cos (-Complex.sin x) x := by sorry

This theorem states that the complex cosine function, which is defined via the exponential function, is differentiable at every point in its domain. More specifically, the derivative of the complex cosine function at any point `x` is given by the negative of the complex sine function at that same point `x`.

The complex cosine function, defined as the real part of the complex exponential function, is differentiable with derivative given by the negative complex sine function.


theorem ZNum.to_int_inj : ∀ {m n : ZNum}, ↑m = ↑n ↔ m = n := by sorry

This theorem states that for any two `ZNum` numbers `m` and `n`, the statement that their integer equivalents (obtained by using the `↑` coercion operator) are equal is logically equivalent to the statement that `m` and `n` themselves are equal. In other words, mapping `ZNum` numbers to integers preserves uniqueness - no two different `ZNum` numbers will map to the same integer.

For all `m` and `n` in `ZNum`, `m = n` if and only if `↑m = ↑n`.


Filter.Eventually.comap

theorem Filter.Eventually.comap :
    ∀ {α : Type u} {β : Type v} {g : Filter β} {p : β → Prop},
      (∀ᶠ (b : β) in g, p b) → ∀ (f : α → β), ∀ᶠ (a : α) in Filter.comap f g, p (f a) :=
  by sorry

The theorem `Filter.Eventually.comap` states that for any types `α` and `β`, given a filter `g` on `β`, a predicate `p` on `β`, if almost every element `b` of `β` in filter `g` satisfies the predicate `p`, then for any function `f` from `α` to `β`, almost every element `a` of `α` in the co-domain of `f` under the filter `g` (represented by `Filter.comap f g`), `p` holds for `f(a)`. Essentially, it assures that under certain conditions, the `eventually` property of a predicate with respect to a filter is preserved under the application of a function, using the concept of co-map.

If a filter on `β` satisfies `p` almost everywhere, then the co-map `Filter.comap f` of a function `f` from `α` to `β` under that filter satisfies `p` almost everywhere in the image of `f` from `α`.


theorem RingHom.isUnit_map :
    ∀ {α : Type u_2} {β : Type u_3} [inst : Semiring α] [inst_1 : Semiring β] (f : α →+* β) {a : α},
      IsUnit a → IsUnit (f a) :=
  by sorry

This theorem states that for any given types `α` and `β`, with `α` and `β` being semirings, and for a ring homomorphism `f` from `α` to `β`, if an element `a` from `α` is a unit, then the image of `a` under `f` is also a unit in `β`. In mathematical terms, this means that if `a` in a semiring `α` has a multiplicative inverse, then its image under a ring homomorphism `f` in semiring `β` also has a multiplicative inverse.

If `f` is a ring homomorphism from semiring `α` to semiring `β`, and `a` in `α` is a unit, then `f(a)` is a unit in `β`.


theorem Polynomial.degree_add_le :
    ∀ {R : Type u} [inst : Semiring R] (p q : Polynomial R),
      Polynomial.degree (p + q) ≤ max (Polynomial.degree p) (Polynomial.degree q) :=
  by sorry

The theorem `Polynomial.degree_add_le` states that for any given semiring `R` and any two polynomials `p` and `q` over `R`, the degree of the sum of the polynomials `(p + q)` is less than or equal to the maximum of the degrees of `p` and `q`. In other words, adding two polynomials does not increase the degree beyond the highest degree of the original polynomials.

For any semiring R and polynomials p and q over R, the degree of p + q is less than or equal to the maximum of the degrees of p and q.


theorem ENNReal.zero_ne_top : 0 ≠ ⊤ := by sorry

This theorem states that zero is not equal to positive infinity in the context of extended non-negative real numbers. In other words, in the numerical system that includes positive infinity as a value, zero is distinctly different from this infinite value.

Zero is not equal to positive infinity in the extended non-negative real numbers.


theorem Decidable.iff_iff_and_or_not_and_not : ∀ {a b : Prop} [inst : Decidable b], (a ↔ b) ↔ a ∧ b ∨ ¬a ∧ ¬b := by
  sorry

This theorem states that for any two propositions 'a' and 'b', given that 'b' is decidable (meaning it can definitively be proven true or false), the equivalence of 'a' and 'b' is itself equivalent to the logical disjunction (OR operation) of two conditions: 'a' and 'b' both being true, or 'a' and 'b' both being false.

For any propositions 'a' and 'b' where 'b' is decidable, the equivalence of 'a' and 'b' is equivalent to ('a' = 'b') ≤followed by (decidable 'b') → (('a' → 'b') ∧ ('b' → 'a')) ∨ ('~'a' ∧ '~'b').


theorem CochainComplex.HomComplex.Cochain.ext₀ :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C]
      {F G : CochainComplex C ℤ} (z₁ z₂ : CochainComplex.HomComplex.Cochain F G 0),
      (∀ (p : ℤ), z₁.v p p ⋯ = z₂.v p p ⋯) → z₁ = z₂ :=
  by sorry

The theorem named `CochainComplex.HomComplex.Cochain.ext₀` states that for any category `C` that is pre-additive, and for any two cochain complexes `F` and `G` over `C`, if we have two zero-degree cochains `z₁` and `z₂` from `F` to `G`, then `z₁` is equal to `z₂` if and only if their morphisms `z₁.v p p` and `z₂.v p p` are equal for all integers `p`. In other words, two zero-degree cochains between the same pair of cochain complexes are considered identical if they correspond to the same family of morphisms.

For any pre-additive category $C$, two zero-degree cochains between cochain complexes $F$ and $G$ over $C$ are equal if and only if their corresponding morphisms agree at all degrees.


theorem Cardinal.lift_mk_le :
    ∀ {α : Type v} {β : Type w},
      Cardinal.lift.{max u w, v} (Cardinal.mk α) ≤ Cardinal.lift.{max u v, w} (Cardinal.mk β) ↔ Nonempty (α ↪ β) :=
  by sorry

The theorem `Cardinal.lift_mk_le` states that for all types `α` and `β`, the lifted cardinality of `α` is less than or equal to the lifted cardinality of `β` if and only if there exists an injective function from `α` to `β`. Here, "lifted cardinality" refers to the cardinal number of a type after applying the universe lift operation, which lifts the universe level of the cardinal. The cardinality of a type is defined as the size of the set of all elements of that type.

For types α and β, the lifted cardinalities are equal if and only if there exists an injective function from α to β. (Note that this is equivalent to the original statement but phrased in terms of cardinalities rather than lifted cardinalities.)


theorem WithBot.range_coe : ∀ {α : Type u_1} [inst : Preorder α], Set.range WithBot.some = Set.Ioi ⊥ := by sorry

The theorem `WithBot.range_coe` states that for any type `α`, given an instance of `Preorder` for `α`, the range of the canonical function `WithBot.some` (which maps `α` into `WithBot α`) is equal to the set of elements of `α` that are greater than the bottom element (`⊥`). In other words, every element in the range of `WithBot.some` is strictly greater than the bottom element (`⊥`), which makes it equivalent to the set defined by the left-open right-infinite interval (`Set.Ioi ⊥`).

For any type `α` with a preorder structure, the range of `WithBot.some : α → WithBot α` consists of elements strictly greater than the bottom element (⊥), equivalent to `Set.Ioi ⊥`.


Field.toIsField

/-- Transferring from `Field` to `IsField`.  -/
theorem Field.toIsField : ∀ (R : Type u) [inst : Field R], IsField R := by sorry

This theorem states that for any type 'R' which is a 'Field', 'R' is also an 'IsField'. In other words, the structure 'Field' implies the structure 'IsField'. This is a structural transfer theorem, converting or viewing a field as an 'IsField' in the context of abstract algebra.

For any field 'R', 'R' has the structure of an IsField.


SameRay.symm

/-- `SameRay` is symmetric.  -/
theorem SameRay.symm :
    ∀ {R : Type u_1} [inst : StrictOrderedCommSemiring R] {M : Type u_2} [inst_1 : AddCommMonoid M]
      [inst_2 : Module R M] {x y : M}, SameRay R x y → SameRay R y x :=
  by sorry

The theorem `SameRay.symm` states that for any strict ordered commutative semiring `R` and any additive commutative monoid `M` that is also a module over `R`, the relation `SameRay` is symmetric. In other words, if the vectors `x` and `y` from `M` are in the same ray (i.e., if either of them is zero or some positive multiples of them are equal), then `y` and `x` are also in the same ray.

If `x` and `y` are in the same ray in an additive commutative monoid `M` over a strict ordered commutative semiring `R`, then `y` and `x` are also in the same ray.


theorem FirstOrder.Language.LHom.map_onFunction :
    ∀ {L : FirstOrder.Language} {L' : FirstOrder.Language} (ϕ : L →ᴸ L') {M : Type u_1}
      [inst : FirstOrder.Language.Structure L M] [inst_1 : FirstOrder.Language.Structure L' M]
      [inst_2 : FirstOrder.Language.LHom.IsExpansionOn ϕ M] {n : ℕ} (f : L.Functions n) (x : Fin n → M),
      FirstOrder.Language.Structure.funMap (ϕ.onFunction f) x = FirstOrder.Language.Structure.funMap f x :=
  by sorry

The theorem `FirstOrder.Language.LHom.map_onFunction` states that for any two first-order languages `L` and `L'`, a language homomorphism `ϕ` from `L` to `L'`, a structure `M` for the languages `L` and `L'`, and a function `f` from `L` of arity `n`, given that `ϕ` is an expansion on `M`, the interpretation of the function `f` under this homomorphism applied to a sequence `x` of elements from `M` is equal to the interpretation of the function `f` applied to the same sequence `x`. In other words, the homomorphism `ϕ` preserves the interpretation of functions in language `L` to `L'`.

For any first-order languages L and L', homomorphism ϕ from L to L', structure M for L and L', and function f : L^n, if ϕ is an expansion on M, then phi(f^M(x_1, ..., x_n)) = f^M(phi(x_1), ..., phi(x_n)) for all x_1, ..., x_n in M.


theorem Ordinal.zero_opow : ∀ {a : Ordinal.{u_1}}, a ≠ 0 → 0 ^ a = 0 := by sorry

The theorem `Ordinal.zero_opow` states that for any ordinal `a` that is not equal to zero, the ordinal exponentiation of zero to the power of `a` is equal to zero. In other words, raising zero to the power of any non-zero ordinal results in zero.
This is reflected in the standard arithmetic where any non-zero number raised to the power of zero is 1, but zero raised to the power of any non-zero number is still zero.

For any non-zero ordinal `a`, `0^a = 0`.


theorem le_iff_exists_add :
    ∀ {α : Type u} [inst : CanonicallyOrderedAddCommMonoid α] {a b : α}, a ≤ b ↔ ∃ c, b = a + c := by sorry

This theorem, `le_iff_exists_add`, states that for any type `α` that is a canonically ordered additive commutative monoid, for any two elements `a` and `b` of `α`, `a` is less than or equal to `b` if and only if there exists a third element `c` such that `b` equals `a` plus `c`. Essentially, this theorem provides a way to express the order relation (`≤`) in terms of the addition operation in the monoid.

For any additive commutative monoid with a canonical order, element `a` is less than or equal to element `b` if and only if `b` is the sum of `a` and some element `c`.


theorem Set.centralizer_univ : ∀ (M : Type u_1) [inst : Semigroup M], Set.centralizer Set.univ = Set.center M := by
  sorry

This theorem states that for any type `M` that forms a semigroup, the centralizer of the universal set is equal to the center of the magma. The centralizer of a set in a magma is the set of all elements that commute with every element of the original set. The universal set contains all elements of the type `M`. The center of a magma is the set of all elements that commute with every other element in the magma. Therefore, this theorem is essentially stating that every element in a semigroup that commutes with every other element is part of the center of the magma.

In a semigroup, the centralizer of the universal set equals the center of the magma.


theorem Filter.mem_lift' :
    ∀ {α : Type u_1} {β : Type u_2} {f : Filter α} {h : Set α → Set β} {t : Set α}, t ∈ f → h t ∈ Filter.lift' f h := by
  sorry

The theorem `Filter.mem_lift'` states that for any types `α` and `β`, any filter `f` on `α`, any function `h` from sets of `α` to sets of `β`, and any set `t` of `α`, if `t` is in the filter `f`, then the image of `t` under `h` is in the lift of the filter `f` along `h`. In layman's terms, this theorem asserts that lifting a filter along a function preserves membership: if a set belongs to the original filter, its image under the function belongs to the lifted filter.

If `f` is a filter on `α`, `h` is a function from sets of `α` to sets of `β`, and `t ∈ f`, then `h(t) ∈ lift f at h`.


theorem Nat.log_of_left_le_one : ∀ {b : ℕ}, b ≤ 1 → ∀ (n : ℕ), Nat.log b n = 0 := by sorry

The theorem `Nat.log_of_left_le_one` states that for any natural numbers `b` and `n`, if `b` is less than or equal to 1, then the logarithm of `n` in base `b` is equal to 0. In other words, this theorem says that the logarithm, in base `b`, of any natural number `n` is 0 when the base `b` is 1 or less.

For any natural number `n`, if `b` is 1 or less, then the logarithm of `n` in base `b` equals 0.


theorem left_inv_eq_right_inv : ∀ {M : Type u} [inst : Monoid M] {a b c : M}, b * a = 1 → a * c = 1 → b = c := by sorry

This theorem states that for any given monoid `M` and elements `a`, `b`, and `c` of `M`, if the product of `b` and `a` equals the identity of the monoid and the product of `a` and `c` also equals the identity, then `b` and `c` must be the same. The monoid structure here ensures the associativity of the operation and existence of an identity element.

If two elements `a` and `c` of a monoid `M` have `a` and `c` being the inverse of `b` respectively, then `b` and `c` are equal.


theorem Finset.le_max' :
    ∀ {α : Type u_2} [inst : LinearOrder α] (s : Finset α) (x : α) (H2 : x ∈ s), x ≤ Finset.max' s ⋯ := by sorry

This theorem asserts that for any type `α` that has a linear order, and any finset `s` of elements of type `α`, if an element `x` of type `α` is in the finset `s`, then `x` is less than or equal to the maximum element of `s`. This maximum is expressed as `Finset.max' s`, where `Finset.max'` function returns the maximum element of a nonempty finset in a linear order.

For any linear order type `α` and finset `s` of elements from `α`, if `x` is an element of `s`, then `x ≤ Finset.max' s`.


theorem MeasureTheory.Measure.restrict_apply₀ :
    ∀ {α : Type u_2} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} {s t : Set α},
      MeasureTheory.NullMeasurableSet t (μ.restrict s) → ↑↑(μ.restrict s) t = ↑↑μ (t ∩ s) :=
  by sorry

The `MeasureTheory.Measure.restrict_apply₀` theorem states: For any type `α`, given a measurable space `m0` on `α`, a measure `μ` on `α`, and two sets `s` and `t` of `α`, if `t` is a null measurable set under the restriction of `μ` to `s`, then the measure of `t` under the restriction of `μ` to `s` is equal to the measure of the intersection of `t` and `s` under `μ`. In other words, when `t` is null measurable, restricting the measure to a set `s` doesn't change the measure of the intersection of `t` and `s`.

If `μ` is a measure on a measurable space `(α, m0)`, `s ⊆ α`, `t` is null measurable in `s` under `μ`, then `μ(t ∩ s) = μ(t)|s`.


theorem neg_le_abs : ∀ {α : Type u_1} [inst : Lattice α] [inst_1 : AddGroup α] (a : α), -a ≤ |a| := by sorry

This theorem states that for any type `α` which is a Lattice and an AddGroup, the negative of any element `a` of this type is less than or equal to the absolute value of `a`. In mathematical terms, we can say that for all `a` belonging to the type `α`, `-a ≤ |a|`.

For any lattice and add group type `α`, the negation of each of its elements is less than or equal to its absolute value. (i.e., `-a ≤ |a|` for all `a` in `α`).


theorem add_eq_zero_iff' :
    ∀ {α : Type u_1} [inst : AddZeroClass α] [inst_1 : PartialOrder α]
      [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 : α},
      0 ≤ a → 0 ≤ b → (a + b = 0 ↔ a = 0 ∧ b = 0) :=
  by sorry

The theorem `add_eq_zero_iff'` states that for any type `α` that is a member of the `AddZeroClass` (indicating it has addition and zero operations), has a partial order, and is covariant with regards to addition and order, if `a` and `b` are two elements of `α` such that `0 ≤ a` and `0 ≤ b`, then the sum `a + b` equals zero if and only if `a` and `b` are both zero. In simpler terms, in this particular structure, the only way for the sum of two non-negative elements to be zero is if both elements are zero themselves.

For any type `α` in Lean 4 that is an AddMonoid with zero, has a partial order, and is covariant with respect to both addition and order, `0 ≤ a` and `0 ≤ b` imply `a + b = 0` if and only if `a = b = 0`.