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

This theorem, `iSup_pos`, states that for any type `α` which is a complete lattice, and for any proposition `p`, and any function `f` from `p` to `α`, if `p` is true (`hp : p`), then the supremum (or least upper bound, denoted by `⨆`) of `f` over all truth values of `p` is equal to the value of `f` at `p` being true. In other words, if `p` holds, then the supremum of `f` over all instances of `p` is just `f` evaluated at `p` being true.

For any complete lattice `α` and proposition `p`, if `p` holds (`hp : p`) then the supremum of a function `f` from `p` to `α` equals `f` applied to `p`: `⨆ x in p, f x = f hp`.


theorem Finset.mem_insert :
    ∀ {α : Type u_1} [inst : DecidableEq α] {s : Finset α} {a b : α}, a ∈ insert b s ↔ a = b ∨ a ∈ s := by sorry

The theorem `Finset.mem_insert` states that for any type `α` with decidable equality (as denoted by `[inst : DecidableEq α]`), and for any finite set `s` of type `α` and any elements `a` and `b` of type `α`, the condition "`a` is an element of the finite set obtained by inserting `b` into `s`" is equivalent to the logical disjunction "`a` equals `b` or `a` is an element of `s`". In other words, `a` is in the set formed by adding `b` to `s` if and only if `a` is either `b` or already in `s`.

For any finite set `s` of type `α` with decidable equality, and any `a, b` in `α`, `a ∈ s.insert b` if and only if `a = b` or `a ∈ s`.


theorem beq_self_eq_true : ∀ {α : Type u_1} [inst : BEq α] [inst_1 : LawfulBEq α] (a : α), (a == a) = true := by sorry

This theorem, named `beq_self_eq_true`, states that for any type `α`, given that `α` has a binary equality (`BEq`) instance and obeys the laws of binary equality (`LawfulBEq`), the binary equality of any element `a` of type `α` with itself is true. Essentially, it is confirming that binary equality is reflexive, i.e., for all `a` of type `α`, `a` is equal to `a`.

For any type `α` with reflexive binary equality `BEq`, `a BEq a` holds for all `a : α`.


theorem CategoryTheory.epi_comp :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z : C} (f : X ⟶ Y) [inst_1 : CategoryTheory.Epi f]
      (g : Y ⟶ Z) [inst_2 : CategoryTheory.Epi g], CategoryTheory.Epi (CategoryTheory.CategoryStruct.comp f g) :=
  by sorry

This theorem, `CategoryTheory.epi_comp`, states that in any category `C`, if there are two morphisms `f` from `X` to `Y` and `g` from `Y` to `Z` such that both `f` and `g` are epimorphisms (surjective mappings), then their composition `f ≫ g` (denoted as `CategoryTheory.CategoryStruct.comp f g` in Lean) is also an epimorphism. This conforms to the general category theory principle that the composition of two epimorphisms is again an epimorphism.

In any category, the composition of two epimorphisms is an epimorphism.


Sigma.ext

theorem Sigma.ext : ∀ {α : Type u_1} {β : α → Type u_2} {x y : Sigma β}, x.fst = y.fst → HEq x.snd y.snd → x = y := by
  sorry

This theorem, `Sigma.ext`, states that for any types `α` and `β` (where `β` is a function that takes a value of type `α` and returns a type), and any two elements `x` and `y` of the dependent pair type `Sigma β`, if the first components (`fst`) of `x` and `y` are equal and the second components (`snd`) of `x` and `y` are heterogeneously equal (HEq), then `x` is equal to `y`. In other words, it establishes that Sigma types, which are pairs consisting of a value and a value of a type dependent on the first, are equal if and only if both their components are correspondingly equal.

If `x` and `y` are elements of the dependent pair type `Σβ` such that `fst x = fst y` and `HEq (snd x) (snd y)`, then `x = y`.


theorem norm_eq_zero : ∀ {E : Type u_6} [inst : NormedAddGroup E] {a : E}, ‖a‖ = 0 ↔ a = 0 := by sorry

This theorem, `norm_eq_zero`, states that for any type `E` that has an instance of a NormedAddGroup, an element `a` of type `E` has a norm of zero if and only if `a` is zero. In mathematical terms, for any normed addition group, an element's norm is zero if and only if the element itself is zero. This theorem is a critical property of normed spaces in functional analysis.

For any normed additive group, an element has norm zero if and only if it is the additive identity.


theorem Mathlib.Data.Sigma.Basic._auxLemma.1 :
    ∀ {α : Type u_1} {β : α → Type u_4} {a₁ a₂ : α} {b₁ : β a₁} {b₂ : β a₂},
      ({ fst := a₁, snd := b₁ } = { fst := a₂, snd := b₂ }) = (a₁ = a₂ ∧ HEq b₁ b₂) :=
  by sorry

This theorem, `Mathlib.Data.Sigma.Basic._auxLemma.1`, states that for all types `α` and `β`, where `β` is a function of `α`, and for all `a₁`, `a₂` of type `α` and `b₁`, `b₂` of type `β`, a pair with first element `a₁` and second element `b₁` is equal to a pair with first element `a₂` and second element `b₂` if and only if `a₁` is equal to `a₂` and `b₁` is heterogeneously equal (`HEq`) to `b₂`. In other words, two pairs are the same if and only if their corresponding elements are the same, with the second element's equality being type-dependent on the first.

For all types `α` and `β`, and for all `a₁ a₂ : α` and `b₁ b₂ : β(α)`, the pairs `(a₁, b₁)` and `(a₂, b₂)` are equal if and only if `a₁ = a₂` and `b₁` is heterogeneously equal to `b₂`.


theorem Filter.tendstoIxxClass_of_subset :
    ∀ {α : Type u_1} {l₁ l₂ : Filter α} {Ixx Ixx' : α → α → Set α},
      (∀ (a b : α), Ixx a b ⊆ Ixx' a b) →
        ∀ [h' : Filter.TendstoIxxClass Ixx' l₁ l₂], Filter.TendstoIxxClass Ixx l₁ l₂ :=
  by sorry

The theorem `Filter.tendstoIxxClass_of_subset` states that for any given type `α` and any two filters `l₁` and `l₂` on this type, if we have two operations `Ixx` and `Ixx'` from `α` to `α` to `Set α` such that for every pair of elements `(a, b)` from `α`, `Ixx a b` is a subset of `Ixx' a b`, then if `Ixx'` is a TendstoIxxClass from `l₁` to `l₂`, it follows that `Ixx` is also a TendstoIxxClass from `l₁` to `l₂`.

In other words, this theorem says that if one operation between elements of a type that results in a set is always a subset of another operation, and if the second operation gives us a TendstoIxxClass (a certain kind of mapping from one filter to another), then the first operation will also give us a TendstoIxxClass.

Given filters `l₁` and `l₂` on type `α`, if operation `Ixx'` is a TendstoIxxClass from `l₁` to `l₂` and for all `a, b ∈ α`, `Ixx a b` is a subset of `Ixx' a b`, then `Ixx` is also a TendstoIxxClass from `l₁` to `l₂`.


theorem Mathlib.Algebra.Order.Field.Basic._auxLemma.2 :
    ∀ {α : Type u_1} [inst : DivisionCommMonoid α] (a b : α), b⁻¹ * a = a / b := by sorry

This theorem, `Mathlib.Algebra.Order.Field.Basic._auxLemma.2`, states that for any type `α` equipped with the structure of a Division Commutative Monoid (a structure that generalizes fields by allowing zero divisors), for any two elements `a` and `b` of this type, the product of the inverse of `b` and `a` is equal to the division of `a` by `b`. In mathematical terms, it asserts that for all `a, b` in `α`, `b⁻¹ * a = a / b`.

For any divisive Monoid `α`, for all `a, b` in `α`, the product of `b`'s multiplicative inverse and `a` equals their quotient: `b⁻¹ * a = a / b`.


theorem Nat.choose_zero_right : ∀ (n : ℕ), Nat.choose n 0 = 1 := by sorry

The theorem `Nat.choose_zero_right` states that for any natural number `n`, the number of ways to choose zero elements from a set with `n` elements is always 1. This is a specific case of the general binomial coefficient concept, where choosing no elements from any set results in one possibility, which is the empty set.

For any natural number `n`, there is exactly 1 way to choose 0 elements from a set of size `n`.


theorem IsScalarTower.algebraMap_apply :
    ∀ (R : Type u) (S : Type v) (A : Type w) [inst : CommSemiring R] [inst_1 : CommSemiring S] [inst_2 : Semiring A]
      [inst_3 : Algebra R S] [inst_4 : Algebra S A] [inst_5 : Algebra R A] [inst_6 : IsScalarTower R S A] (x : R),
      (algebraMap R A) x = (algebraMap S A) ((algebraMap R S) x) :=
  by sorry

This theorem, `IsScalarTower.algebraMap_apply`, asserts that for any types `R`, `S`, and `A` which form a scalar tower and have the type `R` as a commutative semiring, type `S` as a commutative semiring, and type `A` as a semiring with `R`, `S`, and `A` being algebraic structures, the mapping of any element `x` from `R` to `A` using the algebra map is equivalent to the composition of the mapping of `x` from `R` to `S` and then to `A`. In other words, if we have a scalar tower, the map from the bottom of the tower to the top is the same as going up one level and then to the top: $(R \rightarrow A) = (S \rightarrow A) \circ (R \rightarrow S)$.

For any commutative semirings R, S, and semiring A forming a scalar tower, the algebra map from R to A is equal to the composition of the maps from R to S and then from S to A.


theorem Nat.mul_assoc : ∀ (n m k : ℕ), n * m * k = n * (m * k) := by sorry

This theorem states the associativity of multiplication for natural numbers. In other words, for any three natural numbers `n`, `m`, and `k`, the product of `n`, `m` and `k` remains the same regardless of how they are grouped. That is, `(n * m) * k` is equal to `n * (m * k)`.

The theorem asserts that for all natural numbers `n`, `m`, and `k`, `(n * m) * k` equals `n * (m * k)`.


theorem isLindelof_univ : ∀ {X : Type u} [inst : TopologicalSpace X] [h : LindelofSpace X], IsLindelof Set.univ := by
  sorry

This theorem states that for any type `X` with a topological space structure and the Lindelof property, the universal set (which includes all elements of `X`) is a Lindelof set. In more mathematical terms, a space is said to be Lindelof if every open cover has a countable subcover. The Lindelof property is a weakening of compactness and is important in analysis and topology. Here, the theorem is basically asserting that if the whole space is Lindelof, then so is the universal set within that space.

If `X` is a topological space with the Lindelof property, then the universal set of `X` also has the Lindelof property.


ContinuousWithinAt.mono

theorem ContinuousWithinAt.mono :
    ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] {f : α → β} {s t : Set α}
      {x : α}, ContinuousWithinAt f t x → s ⊆ t → ContinuousWithinAt f s x :=
  by sorry

The theorem `ContinuousWithinAt.mono` states that, for any two types `α` and `β` equipped with topological spaces, a function `f` from `α` to `β`, two subsets `s` and `t` of `α`, and a point `x` in `α`, if the function `f` is continuous at the point `x` within the subset `t` and `s` is a subset of `t`, then `f` is also continuous at `x` within the subset `s`. In other words, the continuity of a function at a point within a set is preserved under restriction to a smaller set.

If a function is continuous at a point in a subset and the smaller subset is a subcollection of the larger one, then the function is also continuous at that point in the smaller subset.


theorem sq_abs : ∀ {α : Type u_1} [inst : LinearOrderedRing α] (a : α), |a| ^ 2 = a ^ 2 := by sorry

This theorem, `sq_abs`, states that for any given element `a` of a type `α`, where `α` is a linear ordered ring, the square of the absolute value of `a` is equal to the square of `a` itself. In mathematical terms, it says that for all `a` in `α`, |a|^2 = a^2. This is a property related to the definition of absolute values in a linear ordered ring.

For any element `a` in a linear ordered ring `α`, |a|^2 = a^2.


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

This theorem states that for any type `α` and for any four sets `s₁`, `s₂`, `t₁`, `t₂` of type `α`, if set `s₁` is a subset of `t₁` and set `s₂` is a subset of `t₂`, then the intersection of `s₁` and `s₂` is a subset of the intersection of `t₁` and `t₂`. In other words, the intersection of subsets results in a subset of the intersection of their respective superset.

If `s₁ ⊆ t₁` and `s₂ ⊆ t₂`, then `s₁ ∩ s₂ ⊆ t₁ ∩ t₂`.


theorem Real.Angle.sin_coe : ∀ (x : ℝ), Real.Angle.sin ↑x = Real.sin x := by sorry

This theorem states that, for any real number `x`, the sine of the angle formed by `x` (when `x` is interpreted as a real angle), is equal to the real sine of `x`. In other words, the function `Real.Angle.sin` applied to the co-domain of `x` (that is, `↑x`) results in the same value as the `Real.sin` function applied directly to `x`. This establishes a consistency between the sine function applied to real numbers and the sine of the angle formed by real numbers.

For any real number x, the sine of the angle x is equal to the real value of the sine function applied to x. (Or, in mathematical notation: ∀x: ℝ, sin(ang x) = sin x)


theorem right_ne_zero_of_mul : ∀ {M₀ : Type u_2} [inst : MulZeroClass M₀] {a b : M₀}, a * b ≠ 0 → b ≠ 0 := by sorry

This theorem states that for any type `M₀` equipped with a multiplication operation and a zero element (i.e., a `MulZeroClass`), if the product of two elements `a` and `b` is not zero, then `b` cannot be zero. In mathematical terms, for all `a` and `b` in `M₀`, if `a * b ≠ 0`, then it must be the case that `b ≠ 0`. This statement implicitly relies on the property of zero in a `MulZeroClass` that anything multiplied by zero equals zero.

If `M₀` is a type with a multiplication operation and a zero element, and `a * b ≠ 0`, then `b ≠ 0` in `M₀`.


Asymptotics.IsBigO.trans

theorem Asymptotics.IsBigO.trans :
    ∀ {α : Type u_1} {E : Type u_3} {G : Type u_5} {F' : Type u_7} [inst : Norm E] [inst_1 : Norm G]
      [inst_2 : SeminormedAddCommGroup F'] {l : Filter α} {f : α → E} {g : α → F'} {k : α → G},
      f =O[l] g → g =O[l] k → f =O[l] k :=
  by sorry

This theorem states that the big O notation, a notation used to describe the limiting behavior of a function when the argument tends towards a particular value or infinity, is transitive for sequences of functions. More specifically, if we have three functions `f`, `g`, and `k` of any types `E`, `F'`, and `G` respectively, and a filter `l` of type `α`, if `f` is big O of `g`, denoted `f =O[l] g`, and `g` is big O of `k`, denoted `g =O[l] k`, then it follows that `f` is big O of `k`, denoted `f =O[l] k`. The filter `l` can be thought of as a "context" in which these functions are being compared. This theorem is a fundamental property of the big O notation and is important in the analysis of computational complexity in computer science, among other fields.

If functions `f`, `g`, and `k` are such that `f =O[l] g` and `g =O[l] k` for some filter `l`, then `f =O[l] k`.


theorem Cardinal.lift_aleph0 : Cardinal.lift.{u_1, u_2} Cardinal.aleph0 = Cardinal.aleph0 := by sorry

The theorem `Cardinal.lift_aleph0` states that the lift operation on the smallest infinite cardinal, often denoted as `ℵ₀` (or `aleph0` in Lean), is equal to `ℵ₀` itself. This means if we take the smallest infinite cardinal and lift it to a different universe (in the context of type theory), the cardinality remains the same. In other words, the cardinality of the set of natural numbers is the same in any universe.

The theorem `Cardinal.lift_aleph0` asserts that the lift of the smallest infinite cardinal `ℵ₀` to any universe is equal to `ℵ₀`.


theorem inf_le_inf : ∀ {α : Type u} [inst : SemilatticeInf α] {a b c d : α}, a ≤ b → c ≤ d → a ⊓ c ≤ b ⊓ d := by sorry

This theorem, `inf_le_inf`, asserts that for any type `α` that forms a semilattice under an infimum operation (denoted by `⊓`), given four elements `a`, `b`, `c`, and `d` of this type, if `a` is less than or equal to `b` and `c` is less than or equal to `d`, then the infimum of `a` and `c` is less than or equal to the infimum of `b` and `d`. In other words, if two elements are each less than or equal to another pair of elements, then their infimum (greatest lower bound) will also be less than or equal to the infimum of the larger elements.

For any semilattice `α` with infimum operation `⊓`, if `a ≤ b` and `c ≤ d` in `α`, then `a \/$ c ≤ b \/$ d`. (Here, `\/` denotes the infimum operator.)


theorem Complex.ofReal_sin : ∀ (x : ℝ), ↑(Real.sin x) = Complex.sin ↑x := by sorry

This theorem states that for all real numbers `x`, casting the real sine of `x` to a complex number yields the same result as calculating the complex sine of `x` cast to a complex number. In other words, the real sine function, when extended to the complex numbers, coincides with the complex sine function on the real line. Mathematically, this is expressed as ∀x ∈ ℝ: `Real.sin(x)` = `Complex.sin(x)`.

The real and complex sine functions agree on the real numbers: `Real.sin(x) = Complex.sin(x)` for all `x ∈ ℝ`.


theorem AlgEquiv.apply_symm_apply :
    ∀ {R : Type uR} {A₁ : Type uA₁} {A₂ : Type uA₂} [inst : CommSemiring R] [inst_1 : Semiring A₁]
      [inst_2 : Semiring A₂] [inst_3 : Algebra R A₁] [inst_4 : Algebra R A₂] (e : A₁ ≃ₐ[R] A₂) (x : A₂),
      e ((AlgEquiv.symm e) x) = x :=
  by sorry

The theorem `AlgEquiv.apply_symm_apply` states that for any commutative semiring `R` and any two algebras `A₁` and `A₂` over `R`, and for any algebra equivalence `e` from `A₁` to `A₂` and any element `x` in `A₂`, applying the equivalence `e` to the result of applying the inverse of `e` (given by `AlgEquiv.symm e`) to `x` yields `x` itself. In other words, it states that applying an algebra equivalence and its inverse to an element in succession is the same as doing nothing, which is a fundamental property of any kind of equivalence.

For any commutative semiring `R`, algebra equivalences `e` between commutative `R`-algebras `A₁` and `A₂`, and elements `x` in `A₂`, we have `e (AlgEquiv.symm e x) = x`.


HasDerivAt.continuousAt

theorem HasDerivAt.continuousAt :
    ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {F : Type v} [inst_1 : NormedAddCommGroup F]
      [inst_2 : NormedSpace 𝕜 F] {f : 𝕜 → F} {f' : F} {x : 𝕜}, HasDerivAt f f' x → ContinuousAt f x :=
  by sorry

This theorem states that if a function `f` has a derivative `f'` at a point `x` in a nontrivially normed field `𝕜` mapped into a normed additive commutative group `F` (where `F` is a normed space over `𝕜`), then the function `f` is continuous at the point `x`. In mathematical terms, it means if `f` is differentiable at a point, then it is also continuous at that point. This is a fundamental concept in calculus and real analysis.

If a function `f : ℝ → ℝ` is differentiable at a point `x`, then it is continuous at `x`.


NormedAddGroupHom.ext

theorem NormedAddGroupHom.ext :
    ∀ {V₁ : Type u_2} {V₂ : Type u_3} [inst : SeminormedAddCommGroup V₁] [inst_1 : SeminormedAddCommGroup V₂]
      {f g : NormedAddGroupHom V₁ V₂}, (∀ (x : V₁), f x = g x) → f = g :=
  by sorry

This theorem, `NormedAddGroupHom.ext`, states that for any two normed additive group homomorphisms `f` and `g` from a seminormed additive commutative group `V₁` to another seminormed additive commutative group `V₂`, if `f` and `g` map every element `x` of `V₁` to the same element in `V₂`, then `f` and `g` are the same homomorphism. In other words, two normed additive group homomorphisms are equal if they agree on all elements of the domain.

If two normed additive group homomorphisms from a seminormed additive commutative group to another agree on all elements, then they are equal.


theorem Quotient.out_eq : ∀ {α : Sort u_1} [s : Setoid α] (q : Quotient s), ⟦Quotient.out q⟧ = q := by sorry

The theorem `Quotient.out_eq` states that for any type `α` with an equivalence relation `s` (specified as a `Setoid α`), and for any quotient `q` of `s`, the equivalence class of the chosen element from `q` (obtained by applying `Quotient.out`) is equal to the original quotient `q`. In other words, it ensures that the element chosen from the equivalence class using the axiom of choice, when considered as an equivalence class again, gives back the original equivalence class.

For any type `α` with an equivalence relation `s`, and quotient `q` of `s`, the element `Quotient.out q` is equal to the equivalence class `{x // s x q}` containing `q`.


theorem one_le_two :
    ∀ {α : Type u_1} [inst : AddMonoidWithOne α] [inst_1 : LE α] [inst_2 : ZeroLEOneClass α]
      [inst_3 : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1], 1 ≤ 2 :=
  by sorry

This theorem states that, for any type `α` which is an additive monoid with a distinguished 'one' element and a 'less than or equal to' relation, and where zero is less than or equal to one, and where the addition operation is covariant (meaning that if `x ≤ y` then `x + z ≤ y + z` for all `z`), we have that one is less than or equal to two. The proof of this theorem is suppressed.

If `α` is an additive monoid with one and a relation `≤` such that `0 ≤ 1`, `1 ≤ 2`, and addition is covariant, then `1 ≤ 2`.


theorem Algebra.adjoin_le :
    ∀ {R : Type uR} {A : Type uA} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A] {s : Set A}
      {S : Subalgebra R A}, s ⊆ ↑S → Algebra.adjoin R s ≤ S :=
  by sorry

This theorem states that for any commutative semiring `R`, semiring `A`, and an algebra `R A`, given a set `s` of elements from `A` and a subalgebra `S` of `R A`, if `s` is a subset of `S` (denoted as `s ⊆ ↑S`), then the minimal subalgebra that includes `s` (created using the `Algebra.adjoin` function) is a subalgebra of `S` (denoted as `Algebra.adjoin R s ≤ S`). In other words, the smallest algebra that contains a particular set of elements is always a subset of any other algebra that contains the same set of elements.

For any commutative semirings R and A, and an algebra R A, if s is a subset of a subalgebra S of R A, then the subalgebra generated by s (using Algebra.adjoin) is included in S.


theorem MeasureTheory.Measure.pi_pi :
    ∀ {ι : Type u_1} {α : ι → Type u_3} [inst : Fintype ι] [inst_1 : (i : ι) → MeasurableSpace (α i)]
      (μ : (i : ι) → MeasureTheory.Measure (α i)) [inst_2 : ∀ (i : ι), MeasureTheory.SigmaFinite (μ i)]
      (s : (i : ι) → Set (α i)),
      ↑↑(MeasureTheory.Measure.pi μ) (Set.pi Set.univ s) = Finset.prod Finset.univ fun i => ↑↑(μ i) (s i) :=
  by sorry

The theorem `MeasureTheory.Measure.pi_pi` states that for a finite index set ι and a family of measurable spaces (α i) indexed by ι, given a family of measures (μ i), each of which is sigma-finite, and a family of sets (s i), the measure of the product set (which is the set of all dependent functions that map each index to its corresponding set) under the product measure is equal to the product of measures of each individual set. More formally, if we apply the product measure to the set of all dependent functions, it's equal to the product, over all indices in our finite set, of the measure of each individual set. This theorem relates the measure of a product space to the measures of the individual component spaces.

Given finite index set ι, measurable spaces (α\_i) with sigma-finite measures (μ\_i), the product measure of the family of measurable sets (s\_i) equals the product of the measures of the individual sets.


Iff.comm

theorem Iff.comm : ∀ {a b : Prop}, (a ↔ b) ↔ (b ↔ a) := by sorry

This theorem, `Iff.comm`, states that for all propositions `a` and `b`, the biconditional statement "if and only if" ('↔') is commutative. In other words, the proposition "a if and only if b" is logically equivalent to the proposition "b if and only if a".

The biconditional relation "a ↔ b" is an equivalence relation and is therefore commutative.


theorem Ordinal.succ_zero : Order.succ 0 = 1 := by sorry

The theorem `Ordinal.succ_zero` states that the successor of zero, in an ordered set that respects the successor relationship, is one. In other words, if you've defined an ordering on a type and the operations of 'successor' in that order, then moving one step from zero in the positive direction will result in one.

In an ordered set, the successor of zero is one.


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

This theorem states that for any element `a` from the set of extended nonnegative real numbers (usually denoted as [0, ∞]), provided `a` is neither zero nor infinity, the result of multiplying `a` by its inverse (`a⁻¹`) is equal to 1. In mathematical terms, this theorem is expressing the property that every nonzero, non-infinite element in the set of extended nonnegative real numbers has a multiplicative inverse.

For all nonzero and finite extended nonnegative real numbers `a`, `a * a⁻¹ = 1`.


theorem Complex.continuous_im : Continuous Complex.im := by sorry

This theorem states that the imaginary part of a complex number is a continuous function. In other words, for every complex number, the function that extracts its imaginary part (denoted as `Complex.im` in Lean 4) doesn't have any jumps or disruptions and changes in a way that you can draw it without lifting your pen from the paper. This is expressed in Lean 4 as `Continuous Complex.im`.

The imaginary part function of complex numbers is a continuous function.


theorem NoZeroDivisors.to_isDomain :
    ∀ (α : Type u_2) [inst : Ring α] [h : Nontrivial α] [inst_1 : NoZeroDivisors α], IsDomain α := by sorry

This theorem states that for any type `α` that has a ring structure, is nontrivial, and has no zero divisors, `α` is a domain. In mathematical terminology, a ring `α` is a domain if it contains no zero divisors and is nontrivial (i.e., it has at least two distinct elements).

A nontrivial ring without zero divisors is a domain.


theorem MeasureTheory.snorm_congr_ae :
    ∀ {α : Type u_1} {F : Type u_3} {m0 : MeasurableSpace α} {p : ENNReal} {μ : MeasureTheory.Measure α}
      [inst : NormedAddCommGroup F] {f g : α → F},
      f =ᶠ[MeasureTheory.Measure.ae μ] g → MeasureTheory.snorm f p μ = MeasureTheory.snorm g p μ :=
  by sorry

The theorem `MeasureTheory.snorm_congr_ae` states that for any two functions `f` and `g` from a measurable space `α` into a normed additive commutative group `F`, if `f` and `g` are equal almost everywhere with respect to a given measure `μ` (i.e., `f =ᶠ[MeasureTheory.Measure.ae μ] g`), then the `ℒp` seminorms of `f` and `g` with respect to the measure `μ` and a specified `p` in the extended nonnegative real numbers are also equal (i.e., `MeasureTheory.snorm f p μ = MeasureTheory.snorm g p μ`).

In other words, if two functions are equal almost everywhere, their `ℒp` seminorms are the same.

If two measurable functions from a measurable space into a normed additive commutative group are equal almost everywhere with respect to a given measure, then they have equal `ℒp` seminorms.


theorem eq_of_sub_eq_zero : ∀ {α : Type u_1} [inst : SubtractionMonoid α] {a b : α}, a - b = 0 → a = b := by sorry

This theorem, `eq_of_sub_eq_zero`, states that for any type `α` that is a subtraction monoid (a set equipped with an operation, here subtraction, that is associative and has an identity element, typically zero), if the difference of two elements `a` and `b` of this type is zero (i.e., `a - b = 0`), then `a` and `b` are equal. In mathematical terms, for all `a` and `b` in some subtraction monoid, if `a - b` equals zero, then `a` equals `b`.

If `α` is a subtraction monoid and `a - b = 0`, then `a = b`.


CategoryTheory.NatTrans.ext

theorem CategoryTheory.NatTrans.ext :
    ∀ {C : Type u₁} {inst : CategoryTheory.Category.{v₁, u₁} C} {D : Type u₂}
      {inst_1 : CategoryTheory.Category.{v₂, u₂} D} {F G : CategoryTheory.Functor C D} (x y : F.NatTrans G),
      x.app = y.app → x = y :=
  by sorry

This theorem states that for any two categories `C` and `D` (of certain types `u₁` and `u₂`, and with Category structures `inst` and `inst_1`, respectively), and for any two functors `F` and `G` from `C` to `D`, if two natural transformations `x` and `y` from `F` to `G` have the same application function (`app`), then `x` and `y` are indeed the same natural transformation. In other words, a natural transformation between two functors is completely determined by its application function.

If two natural transformations between functors have the same application function, then they are equal.


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

This theorem states that for any ordinal number 'a', if you raise 'a' to the power of zero, the result is always 1. This follows the general principle in mathematics that any non-zero number raised to the power of zero equals 1. In this context, the theorem applies to ordinal numbers, which are a type of well orders in a given type, up to order isomorphism.


theorem LinearEquiv.symm_apply_apply :
    ∀ {R : Type u_1} {S : Type u_6} {M : Type u_7} {M₂ : Type u_9} [inst : Semiring R] [inst_1 : Semiring S]
      [inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid M₂] {module_M : Module R M} {module_S_M₂ : Module S M₂}
      {σ : R →+* S} {σ' : S →+* R} {re₁ : RingHomInvPair σ σ'} {re₂ : RingHomInvPair σ' σ} (e : M ≃ₛₗ[σ] M₂) (b : M),
      (LinearEquiv.symm e) (e b) = b :=
  by sorry

This theorem states that for any types `R`, `S`, `M`, and `M₂`, given that `R` and `S` are semirings, `M` and `M₂` are additive commutative monoids, `M` is a module over `R`, and `M₂` is a module over `S`, and given two ring homomorphisms `σ : R →+* S` and `σ' : S →+* R` that form a ring homomorphism inverse pair (both ways), for any linear equivalence `e : M ≃ₛₗ[σ] M₂` and any element `b` of type `M`, applying `e` to `b` and then applying the inverse of `e` to the result yields `b` again. In other words, a linear equivalence and its inverse form a 'round trip': applying one after the other gives you back where you started.

Given two ring homomorphisms forming an inverse pair between semirings `R` and `S`, and modules `M` over `R`, `M₂` over `S`, any linear equivalence between `M` and `M₂` (as `R`-modules) satisfies applying the inverse of the equivalence to the equivalence of elements gives the original element.


theorem Mathlib.Algebra.Order.Group.Defs._auxLemma.34 :
    ∀ {α : Type u} [inst : AddGroup α] [inst_1 : LE α]
      [inst_2 : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1]
      [inst_3 : CovariantClass α α (Function.swap fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] {a b : α},
      (-a ≤ -b) = (b ≤ a) :=
  by sorry

The theorem `Mathlib.Algebra.Order.Group.Defs._auxLemma.34` states that for any type `α` that is an additive group and has a total order, if the order is compatible with addition in both directions (captured by the `CovariantClass` instances), then for any two elements `a` and `b` of `α`, the inequality `-a ≤ -b` is equivalent to `b ≤ a`.

For any additive group with a compatible total order, the inequality -a <= -b holds if and only if b <= a.


/-- Group homomorphisms preserve inverse.  -/
theorem MonoidHom.map_inv :
    ∀ {α : Type u_2} {β : Type u_3} [inst : Group α] [inst_1 : DivisionMonoid β] (f : α →* β) (a : α),
      f a⁻¹ = (f a)⁻¹ :=
  by sorry

This theorem states that for any group homomorphism `f` from a group `α` to a division monoid `β`, the inverse of any element `a` in `α` under the homomorphism `f` is the same as the inverse of the image of `a` under `f` in `β`. In other words, group homomorphisms preserve the property of inverses.

For any group homomorphism `f` from group `α` to a division monoid `β`, `f(a)^-1 = (f(a))^-1` for all inverses `a^-1, (f(a))^-1` in `α` and `β` respectively.


theorem isUnit_iff_dvd_one : ∀ {α : Type u_1} [inst : CommMonoid α] {x : α}, IsUnit x ↔ x ∣ 1 := by sorry

The theorem `isUnit_iff_dvd_one` states that for any commutative monoid `α` and any element `x` of `α`, `x` is a unit if and only if `x` divides `1`. In the context of the monoid, being a unit means that `x` has a two-sided inverse. The phrase "divides `1`" is a way of expressing that there is some element in the monoid such that when it's multiplied by `x`, the result is `1`. So, in simpler terms, an element is a unit, i.e., it has a two-sided inverse, if and only if it can multiply with some element to give `1`.

An element `x` of a commutative monoid is a unit if and only if there exists an element `y` such that `x * y = y * x = 1`.


theorem neg_one_smul :
    ∀ (R : Type u_2) {M : Type u_5} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] (x : M),
      -1 • x = -x :=
  by sorry

This theorem, `neg_one_smul`, states that for any given type `R` that is a ring, and any given type `M` that is an additively commutative group and also a module over `R`, the scalar multiplication of `-1` and any element `x` of type `M` is equal to the negation of `x`. In other words, multiplying any element of the module by `-1` results in the additive inverse of that element.

For any ring `R` and additively commutative group `M` being an `R`-module, for all `x` in `M`, `-1 * x = -x`.


theorem continuous_iff_continuousOn_univ :
    ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] {f : α → β},
      Continuous f ↔ ContinuousOn f Set.univ :=
  by sorry

This theorem states that for any two topological spaces α and β and any function `f` from α to β, the function `f` is continuous everywhere if and only if `f` is continuous on the universal set of α. Here, the universal set of α represents the set of all elements of type α. "Continuous" means that the preimage of any open set in β is open in α, and "Continuous on a set" means that the function is continuous at every point within that set.

A function from one topological space to another is continuous at all points if and only if it is continuous on the space's universal set.


IsometryEquiv.isometry

theorem IsometryEquiv.isometry :
    ∀ {α : Type u} {β : Type v} [inst : PseudoEMetricSpace α] [inst_1 : PseudoEMetricSpace β] (h : α ≃ᵢ β),
      Isometry ⇑h :=
  by sorry

The theorem `IsometryEquiv.isometry` states that for any two pseudoemetric spaces, `α` and `β`, if there is an isometric equivalence `h` between them, then the function represented by `h` is an isometry. In other words, the function `h` preserves the edistance between any two points in `α` when mapping them into `β`. This means that for any two points `x1` and `x2` in `α`, the edistance between `f(x1)` and `f(x2)` in `β` is the same as the edistance between `x1` and `x2` in `α`.

If `h` is an isometric equivalence between pseudometric spaces `α` and `β`, then `h` is an isometry, that is, for all `x₁, x₂` in `α`, the edistances `edist α x₁ x₂` and `edist β (h x₁) (h x₂)` are equal.


theorem Trivialization.mem_source :
    ∀ {B : Type u_2} {F : Type u_3} {Z : Type u_5} [inst : TopologicalSpace B] [inst_1 : TopologicalSpace F]
      {proj : Z → B} [inst_2 : TopologicalSpace Z] (e : Trivialization F proj) {x : Z},
      x ∈ e.source ↔ proj x ∈ e.baseSet :=
  by sorry

This theorem states that for any types `B`, `F`, and `Z`, given that `B` and `F` are topological spaces and `Z` is projected onto `B` through a function `proj`, for any trivialization `e` of `F` with respect to `proj` and any element `x` of `Z`, `x` is in the source of the trivialization `e` if and only if the projection of `x` is in the base set of `e`. In the context of differential geometry, this can be interpreted as a relationship between the preimages of points in a topological space and their corresponding points in a trivializing neighborhood.

For any types `B`, `F`, and `Z`, given that `B` and `F` are topological spaces, `Z` is projected onto `B` through a function `proj`, and `e` is a trivialization of `F` over `B`, the element `x` of `Z` is in the domain of `e` if and only if `proj(x)` is in the base space of `e`.


BilinForm.ext

theorem BilinForm.ext :
    ∀ {R : Type u_1} {M : Type u_2} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
      {B D : BilinForm R M}, (∀ (x y : M), B.bilin x y = D.bilin x y) → B = D :=
  by sorry

This theorem, `BilinForm.ext`, states that for any type `R`, where `R` is a commutative semiring, and any type `M`, where `M` is an additive commutative monoid and also an `R`-module, if `B` and `D` are bilinear forms over `R` and `M`, then `B` and `D` are equal if and only if for all `x` and `y` in `M`, the bilinear forms of `B` and `D` evaluated at `x` and `y` are equal.

For commutative semiring R and additive commutative monoid/R-module M, two bilinear forms B and D over R and M are equal if and only if they have the same value when evaluated on any pair of elements x, y in M.


UniformSpace.ext

theorem UniformSpace.ext : ∀ {α : Type ua} {u₁ u₂ : UniformSpace α}, uniformity α = uniformity α → u₁ = u₂ := by sorry

This theorem states that for any given type `α`, and any two uniform spaces `u₁` and `u₂` on `α`, if the uniformity of `α` in both spaces is the same, then the two uniform spaces are indeed identical. In more mathematical terms, this theorem establishes the uniqueness of a uniform space under a given uniformity for a particular type.

If two uniform spaces on a type `α` have the same uniformity, then they are equal.


theorem Submodule.span_mono :
    ∀ {R : Type u_1} {M : Type u_4} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {s t : Set M},
      s ⊆ t → Submodule.span R s ≤ Submodule.span R t :=
  by sorry

The theorem `Submodule.span_mono` states that for any semiring `R` and additive commutative monoid `M` which is a module over `R`, and for any two sets `s` and `t` of elements of `M`, if set `s` is a subset of set `t`, then the span of set `s` is a submodule of the span of set `t`. In other words, if every element of `s` is also an element of `t`, then every linear combination of elements of `s` is also a linear combination of elements of `t`.

If `s` is a subset of `t` in an additive commutative `R`-module `M`, then the span of `s` is contained in the span of `t`.


ExistsUnique.exists

theorem ExistsUnique.exists : ∀ {α : Sort u_1} {p : α → Prop}, (∃! x, p x) → ∃ x, p x := by sorry

This theorem states that for any type `α` and any property `p` of `α`, if there exists a unique `x` of type `α` for which the property `p` is true (denoted as `∃! x, p x`), then there exists at least one `x` such that the property `p` is true (denoted as `∃ x, p x`). Essentially, it says that if something is uniquely true for a particular element, then it is at least true for one element.

If there exists a unique element `x` of type `α` with property `p`, then there exists at least one element `x` of type `α` with property `p`.


CategoryTheory.Sheaf.Hom.ext

theorem CategoryTheory.Sheaf.Hom.ext :
    ∀ {C : Type u₁} {inst : CategoryTheory.Category.{v₁, u₁} C} {J : CategoryTheory.GrothendieckTopology C}
      {A : Type u₂} {inst_1 : CategoryTheory.Category.{v₂, u₂} A} {X Y : CategoryTheory.Sheaf J A}
      (x y : CategoryTheory.Sheaf.Hom X Y), x.val = y.val → x = y :=
  by sorry

This theorem states that for any two category-theory sheaves `X` and `Y` over a given Grothendieck topology `J`, any two morphisms (or homomorphisms) `x` and `y` from `X` to `Y` are equal if and only if their underlying functions (accessed by `.val`) are equal. This is often referred to as an extensionality theorem because it extends the concept of function equality (equality of outputs for all inputs) to a higher-level concept, in this case morphisms in a category.

For any two sheaves X and Y over a Grothendieck topology J, two morphisms x and y from X to Y are equal if and only if their underlying functions have equal values.


CategoryTheory.Functor.ext

/-- Proving equality between functors. This isn't an extensionality lemma,
because usually you don't really want to do this.  -/
theorem CategoryTheory.Functor.ext :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂}
      [inst_1 : CategoryTheory.Category.{v₂, u₂} D] {F G : CategoryTheory.Functor C D}
      (h_obj : ∀ (X : C), F.obj X = G.obj X),
      autoParam
          (∀ (X Y : C) (f : X ⟶ Y),
            F.map f =
              CategoryTheory.CategoryStruct.comp (CategoryTheory.eqToHom ⋯)
                (CategoryTheory.CategoryStruct.comp (G.map f) (CategoryTheory.eqToHom ⋯)))
          _auto✝ →
        F = G :=
  by sorry

This theorem, `CategoryTheory.Functor.ext`, states that for two functors `F` and `G` from a category `C` to a category `D`, if for all objects `X` in `C`, `F.obj X` equals `G.obj X`, and if for all objects `X`, `Y` in `C` and morphism `f` from `X` to `Y`, the mapping of `f` by `F` equals the composition of the morphism induced by the equality between `F.obj X` and `G.obj X`, the mapping of `f` by `G`, and the morphism induced by the equality between `F.obj Y` and `G.obj Y`, then the two functors `F` and `G` are equal. The second condition is implicitly provided by an `autoParam`, a mechanism that provides default arguments during elaboration. It's important to note that this isn't an extensionality lemma, because in most cases, proving equality between functors is not desirable or necessary.

If functors `F` and `G` from category `C` to category `D` have equal objects and morphisms induced by morphisms between objects, then `F` and `G` are equal.


theorem Filter.EventuallyEq.filter_mono :
    ∀ {α : Type u} {β : Type v} {l l' : Filter α} {f g : α → β}, f =ᶠ[l] g → l' ≤ l → f =ᶠ[l'] g := by sorry

This theorem states that for any two types `α` and `β`, any two filters `l` and `l'` on `α`, and any two functions `f` and `g` from `α` to `β`, if `f` is eventually equal to `g` at filter `l` and filter `l'` is a subfilter of `l`, then `f` is also eventually equal to `g` at filter `l'`. In other words, if two functions are eventually equal under a certain filter, they remain eventually equal when we move to a finer (sub)filter.

If `l` is a filter on type `α`, `l'` is a subfilter of `l`, functions `f` and `g` from `α` to type `β`, and `f` is eventually equal to `g` at filter `l`, then `f` is eventually equal to `g` at filter `l'`.


theorem Finsupp.support_single_subset :
    ∀ {α : Type u_1} {M : Type u_5} [inst : Zero M] {a : α} {b : M}, (fun₀ | a => b).support ⊆ {a} := by sorry

This theorem states that for any types `α` and `M` where `M` is a zero type, and for any elements `a` of type `α` and `b` of type `M`, the support of the function `fun₀` that maps `a` to `b` is a subset of the set containing `a`. In other words, the only element that possibly has a non-zero image under `fun₀` is `a`.

For any type `M` that is a zero type and any function `f : α → M` with `α` being an arbitrary type and `f a` being the only non-zero element for some `a` in `α`, the support of `f` is equal to `{a}`.


theorem Set.image_eq_preimage_of_inverse :
    ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {g : β → α},
      Function.LeftInverse g f → Function.RightInverse g f → Set.image f = Set.preimage g :=
  by sorry

The theorem `Set.image_eq_preimage_of_inverse` states that for any two types `α` and `β`, and any two functions `f : α → β` and `g : β → α`, if `g` is a left inverse to `f` (meaning, applying `g` after `f` yields the identity function, or `g ∘ f = id`) and `g` is also a right inverse to `f` (meaning, applying `f` after `g` also gives the identity function, or `f ∘ g = id`), then the image of a set under `f` equals the preimage of the same set under `g`. In other words, applying `f` to all elements of a set `s` in `α` yields exactly the same set of `β` elements as those that would be mapped back into `s` by `g`.

If functions `f : α → β` and `g : β → α` satisfy `g ∘ f = id_α` and `f ∘ g = id_β`, then `f''(S) = g⁻¹''(S)` for any set `S ⊆ α`.


theorem PMF.toMeasure_apply_eq_toOuterMeasure_apply :
    ∀ {α : Type u_1} [inst : MeasurableSpace α] (p : PMF α) (s : Set α),
      MeasurableSet s → ↑↑(PMF.toMeasure p) s = ↑(PMF.toOuterMeasure p) s :=
  by sorry

This theorem states that for any type `α` equipped with a measurable space, any probability mass function `p` of type `α`, and any set `s` of type `α` that is measurable, the measure assigned to the set `s` by the measure derived from the `PMF p` is equal to the measure assigned to the set `s` by the outer measure derived from the `PMF p`. In other words, when applied to a measurable set, the measure and the outer measure derived from a probability mass function assign the same measure to that set.

For any measurable space, measurable set, and probability mass function, the measure and outer measure derived from the probability mass function agree on the measurable set.


theorem Multiset.coe_count :
    ∀ {α : Type u_1} [inst : DecidableEq α] (a : α) (l : List α), Multiset.count a ↑l = List.count a l := by sorry

The theorem `Multiset.coe_count` states that, for any type `α` with a decidable equality, and any element `a` of type `α` and list `l` of type `α`, the multiplicity of `a` in the multiset representation of `l` (i.e., `Multiset.count a ↑l`) is equal to the number of occurrences of `a` in `l` itself (i.e., `List.count a l`). In other words, converting a list to a multiset does not change the count of any specific element in the collection.

For any type `α` with decidable equality and list `l` of elements from `α`, the number of occurrences of an element `a` in the list equals the multiplicity of `a` in the multiset representation of `l`. (i.e., `List.count a l = Multiset.count a (Multiset.ofList l)`)


theorem one_zsmul : ∀ {G : Type w} [inst : SubNegMonoid G] (a : G), 1 • a = a := by sorry

This theorem states that for any type `G` which is a subnegmonoid (i.e., a structure with subtraction and a unary negation operation), the scalar multiplication of any element `a` of type `G` by 1 results in the element `a` itself. In other words, 1 is the multiplicative identity in the scalar multiplication operation for any element of a subnegmonoid.

For any subnegmonoid type `G` and element `a` in `G`, 1 * a = a.


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

This theorem, `inner_zero_left`, states that for any scalar type `𝕜` and any normed add commutative group `E` with an inner product space over `𝕜`, the inner product of the zero vector and any vector `x` in `E` is always zero. This is a fundamental property of inner product spaces, essentially stating that the zero vector is orthogonal to all other vectors.

For any inner product space `(E, ⟨·, ·⟩)` over commutative scalar type `𝕜`, ⟨0, x⟩ = 0 for all `x ∈ E`.


theorem Equiv.tsum_eq :
    ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : AddCommMonoid α] [inst_1 : TopologicalSpace α] (e : γ ≃ β)
      (f : β → α), ∑' (c : γ), f (e c) = ∑' (b : β), f b :=
  by sorry

This theorem, `Equiv.tsum_eq`, states that for any types `α`, `β`, and `γ` where `α` is an additive commutative monoid and is also a topological space, given a bijective function `e` from `γ` to `β` and another function `f` from `β` to `α`, the sum over all `γ` of `f` applied to `e(c)` (where `c` is a value of type `γ`) is equal to the sum over all `β` of `f(b)`. Essentially, this means that summing over a function applied to a bijective transformation yields the same result as summing over the function itself.

Given an additive commutative monoid and topological space α, a bijective function e from γ to β, and a function f from β to α, the sum over all c in γ of f(e(c)) equals the sum over all b in β of f(b).


/-- Extensionality lemma for monoid homomorphisms `M ∗ N →* P`.
If two homomorphisms agree on the ranges of `Monoid.Coprod.inl` and `Monoid.Coprod.inr`,
then they are equal.  -/
theorem Monoid.Coprod.hom_ext :
    ∀ {M : Type u_1} {N : Type u_2} {P : Type u_5} [inst : MulOneClass M] [inst_1 : MulOneClass N]
      [inst_2 : MulOneClass P] {f g : Monoid.Coprod M N →* P},
      MonoidHom.comp f Monoid.Coprod.inl = MonoidHom.comp g Monoid.Coprod.inl →
        MonoidHom.comp f Monoid.Coprod.inr = MonoidHom.comp g Monoid.Coprod.inr → f = g :=
  by sorry

This theorem is an extensionality lemma for monoid homomorphisms from the coproduct of two monoids `M` and `N` to a monoid `P`. It states that if two homomorphisms `f` and `g` from `M ∗ N` to `P` agree on the ranges of the natural embeddings `Monoid.Coprod.inl` and `Monoid.Coprod.inr`, then `f` and `g` are equal. In other words, two such monoid homomorphisms are determined entirely by their behavior on the original monoids `M` and `N`.

Given monoids M, N, and P, and homomorphisms f and g from their coproduct M ∗ N to P, if f(inl x) = g(inl x) for all x in M and f(inr y) = g(inr y) for all y in N, then f = g.


theorem MeasureTheory.ae_all_iff :
    ∀ {α : Type u_1} {ι : Sort u_5} [inst : MeasurableSpace α] {μ : MeasureTheory.Measure α} [inst_1 : Countable ι]
      {p : α → ι → Prop}, (∀ᵐ (a : α) ∂μ, ∀ (i : ι), p a i) ↔ ∀ (i : ι), ∀ᵐ (a : α) ∂μ, p a i :=
  by sorry

This theorem states that, given a measurable space `α`, a countably infinite set `ι`, a measure `μ` on `α`, and a property `p` that relates elements of `α` and `ι`, the property `p` holds almost everywhere (i.e., everywhere except on a set of measure zero) for all elements of `α` and `ι` if and only if for each element of `ι`, `p` holds almost everywhere for all elements of `α`. In mathematical terms, this is written as `∀ᵐ (a : α) ∂μ, ∀ (i : ι), p a i` is equivalent to `∀ (i : ι), ∀ᵐ (a : α) ∂μ, p a i`.

Given a measurable space `(α, Σ, μ)`, a countably infinite index set `ι`, and a property `p(a, i)` relating elements `a ∈ α` and `i ∈ ι`, the property `p` holds almost everywhere for all `a ∈ α` if and only if it holds almost everywhere for all `i ∈ ι`, i.e., `∀ᵐ a ∂μ ∀ i ∈ ι, p(a, i)` is equivalent to `∀ i ∈ ι, ∀ᵐ a ∂μ, p(a, i)`.


theorem ENNReal.inv_top : ⊤⁻¹ = 0 := by sorry

This theorem states that the inverse of positive infinity (denoted by ⊤) in the extended non-negative real number system equals zero. In other words, if you take the reciprocal of positive infinity, you get zero. This is consistent with the intuition that dividing any finite number by infinity results in zero.

In the extended non-negative real numbers, ⊤^(-1) = 0.


/-- **Alias** of `zero_lt_two`.

---

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

This theorem, named `two_pos`, asserts that in any additive monoid with one (AddMonoidWithOne), which also has a partial order and satisfies the properties of ZeroLEOneClass, where 1 is not zero (NeZero 1) and where addition is a covariant operation, the number two is strictly greater than zero. This theorem is an alias for `zero_lt_two`. For a version where the type is made explicit, refer to `zero_lt_two'`.

In an additive monoid with one and a partial order, where 1 is non-zero and addition is covariant, the element 2 is strictly greater than the identity element (zero).


/-- Two vectors have inner product 0 if and only if the angle between
them is π/2.  -/
theorem InnerProductGeometry.inner_eq_zero_iff_angle_eq_pi_div_two :
    ∀ {V : Type u_1} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] (x y : V),
      ⟪x, y⟫_ℝ = 0 ↔ InnerProductGeometry.angle x y = Real.pi / 2 :=
  by sorry

This theorem states that for any two vectors `x` and `y` in a real inner product space, the inner product of the vectors is zero if and only if the angle between them is π/2. In other words, in terms of linear algebra, two vectors are orthogonal (i.e., they are at a right angle to each other) if and only if their inner product (dot product) is zero.

In a real inner product space, two vectors are orthogonal if and only if their inner product is zero.


theorem Int.coe_nat_pos : ∀ {n : ℕ}, 0 < ↑n ↔ 0 < n := by sorry

This theorem states that for any natural number `n`, the statement "zero is less than the integer representation of `n`" is equivalent to "zero is less than `n`". In other words, a natural number `n` is positive if and only if its corresponding integer is positive.

For any natural number `n`, the statement "0 < int.of_nat `n`" is equivalent to "0 < `n`".


Ordinal.inductionOn

theorem Ordinal.inductionOn :
    ∀ {C : Ordinal.{u_3} → Prop} (o : Ordinal.{u_3}),
      (∀ (α : Type u_3) (r : α → α → Prop) [inst : IsWellOrder α r], C (Ordinal.type r)) → C o :=
  by sorry

The theorem `Ordinal.inductionOn` is a principle of mathematical induction for ordinals. For any property `C` and any ordinal `o`, if for all well-ordered types `α` and relations `r` on `α` (which is a well-order), the property `C` holds on the ordinal type of `r`, then the property `C` holds on `o`. Essentially, this theorem states that if a property is true for all well-orders, then it is true for all ordinals.

If a property holds for all well-ordered types and relations, then it holds for any ordinal.


theorem CategoryTheory.FunctorToTypes.map_id_apply :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (F : CategoryTheory.Functor C (Type w)) {X : C}
      (a : F.obj X), F.map (CategoryTheory.CategoryStruct.id X) a = a :=
  by sorry

This theorem is stating that for any category `C`, and any functor `F` from that category into the category of types, for any object `X` in the category `C` and any object `a` in the image of `X` under the functor `F`, the image of `a` under the mapping induced by the identity morphism on `X` is equal to `a` itself. In other words, it states that the functor `F` preserves the identity morphisms of the category `C`, a key property of functors in category theory.

For any functor F from a category C to Type, and for any object X in C and its image a under F, the image of the identity morphism on X maps a to itself. (Alternatively: Identity morphisms are preserved under functor F.)


/-- A homomorphism from an additive group to an additive monoid is injective iff
its kernel is trivial. For the iff statement on the triviality of the kernel,
see `injective_iff_map_eq_zero'`. -/
theorem injective_iff_map_eq_zero :
    ∀ {F : Type u_8} {G : Type u_9} {H : Type u_10} [inst : AddGroup G] [inst_1 : AddZeroClass H]
      [inst_2 : FunLike F G H] [inst_3 : AddMonoidHomClass F G H] (f : F),
      Function.Injective ⇑f ↔ ∀ (a : G), f a = 0 → a = 0 :=
  by sorry

The theorem `injective_iff_map_eq_zero` states that for any types `F`, `G`, and `H`, where `G` is an additive group, `H` is an additive monoid with zero, `F` is a function-like structure from `G` to `H`, and `F` is a homomorphism from the additive group `G` to the additive monoid `H`, a function `f` of type `F` is injective if and only if for all elements `a` of `G`, `f` maps `a` to zero if and only if `a` is zero. This theorem is relating the injectivity of a function to the triviality of its kernel. In other words, a homomorphism between these structures is injective if the only element it maps to zero is zero itself.

A homomorphism from an additive group to an additive monoid with zero is injective if and only if it maps every element to zero if and only if that element is the additive identity.


theorem DFinsupp.single_apply :
    ∀ {ι : Type u} {β : ι → Type v} [inst : DecidableEq ι] [inst_1 : (i : ι) → Zero (β i)] {i i' : ι} {b : β i},
      (DFinsupp.single i b) i' = if h : i = i' then Eq.recOn h b else 0 :=
  by sorry

This theorem, `DFinsupp.single_apply`, states that for any index set `ι`, any function `β` from `ι` to types, and given a decidable equality on `ι` and a zero element for each `β i`, if `i` and `i'` are elements of `ι` and `b` is an element of `β i`, then applying the function `DFinsupp.single` on `i` and `b` and then applying the result to `i'` equals `b` if `i` equals `i'` (as asserted by hypothesis `h`) and `0` otherwise. The function `Eq.recOn` is used to ensure that `b` has the correct type in the context of the equality `i = i'`.

For any indexed family of types `β` over a decidably equalizable index set `ι`, the application of `DFinsupp.single` on an index `i` and an element `b` of `β i` equals `b` if `i` equals `i'`, and `0` otherwise.


AddSubmonoid.ext

/-- Two `AddSubmonoid`s are equal if they have the same elements. -/
theorem AddSubmonoid.ext :
    ∀ {M : Type u_1} [inst : AddZeroClass M] {S T : AddSubmonoid M}, (∀ (x : M), x ∈ S ↔ x ∈ T) → S = T := by sorry

This theorem states that two addition submonoids (`AddSubmonoid`s) `S` and `T` of a certain type `M` (which forms an additive zero class) are equal if they contain exactly the same elements. Formally, if for every element `x` of type `M`, `x` belongs to `S` if and only if `x` belongs to `T`, then `S` and `T` must be equal.

If two additive submonoids `S` and `T` of an additive zero class `M` in Lean 4 have the same elements, then `S` is equal to `T`.


theorem Fintype.card_prod :
    ∀ (α : Type u_4) (β : Type u_5) [inst : Fintype α] [inst_1 : Fintype β],
      Fintype.card (α × β) = Fintype.card α * Fintype.card β :=
  by sorry

The theorem `Fintype.card_prod` states that for any two given finite types `α` and `β`, the number of elements in the Cartesian product of the two types (represented as `(α × β)`) is equal to the product of the number of elements in `α` and the number of elements in `β`. In other words, if `α` and `β` are finite sets, then the cardinality (or size) of the Cartesian product of `α` and `β` is the product of the cardinalities of `α` and `β`.

Given finite types `α` and `β`, the cardinality of their Cartesian product `α × β` is equal to the product of the cardinalities of `α` and `β`.


theorem Filter.comap_mono : ∀ {α : Type u} {β : Type v} {m : α → β}, Monotone (Filter.comap m) := by sorry

The theorem `Filter.comap_mono` states that for all types `α` and `β`, and for all functions `m` from `α` to `β`, the function `Filter.comap m` is monotone. This means for any given function `m`, if `a` and `b` are elements of type `α` such that `a ≤ b`, then the result of `Filter.comap m` applied to `a` is less than or equal to the result of `Filter.comap m` applied to `b`. In other words, `Filter.comap` preserves the order of elements under the function `m`.

For all types α and β, and for all functions m from α to β, the monotone function Filter.comap m preserves the order, that is, a ≤ b implies Filter.m a ≤ Filter.m b.


ModuleCat.ext

theorem ModuleCat.ext :
    ∀ (R : Type u) [inst : Ring R] {M N : ModuleCat R} {f₁ f₂ : M ⟶ N}, (∀ (x : ↑M), f₁ x = f₂ x) → f₁ = f₂ := by sorry

This theorem states that given a type `R` that forms a ring, for any two modules `M` and `N` over `R` and any two morphisms `f₁` and `f₂` from `M` to `N`, if `f₁` and `f₂` are equal for all elements of `M` then `f₁` is equal to `f₂`. In other words, two morphisms between two modules over a ring are identical if they agree on every point in the domain module.

If two morphisms between two modules over a ring agree on all elements of the domain module, then they are equal.


theorem Function.comp_def :
    ∀ {α : Sort u_1} {β : Sort u_2} {δ : Sort u_3} (f : β → δ) (g : α → β), f ∘ g = fun x => f (g x) := by sorry

The theorem `Function.comp_def` states that for all types `α`, `β`, and `δ`, and any two functions `f` from `β` to `δ` and `g` from `α` to `β`, the composition of `f` and `g` (denoted as `f ∘ g`) is the same as the function that takes an input `x` of type `α`, applies the function `g` to `x`, and then applies the function `f` to the result. In mathematical terms, this expresses the definition of function composition: `(f ∘ g)(x) = f(g(x))`.

The `Function.comp_def` theorem in Lean 4 asserts that for all types `α`, `β`, and `δ`, and functions `f : β → δ` and `g : α → β`, `f ∘ g` is equal to the function that maps `x` in `α` to `f(g(x))`.


OrderHomClass.mono

theorem OrderHomClass.mono :
    ∀ {F : Type u_1} {α : Type u_2} {β : Type u_3} [inst : Preorder α] [inst_1 : Preorder β] [inst_2 : FunLike F α β]
      [inst_3 : OrderHomClass F α β] (f : F), Monotone ⇑f :=
  by sorry

The theorem `OrderHomClass.mono` states that for any types `F`, `α`, and `β`, given that `α` and `β` are preordered, `F` is a function-like from `α` to `β`, and `F` is a type of less-than-or-equal-to preserving morphisms, then any function `f` of type `F` is monotone. In other words, if `a ≤ b` in the preorder `α`, then `f(a) ≤ f(b)` in the preorder `β`.

If `F` is a function-like from a preordered type `α` to a preordered type `β`, and `F` preserves the preorder relation, then `F` is a monotone function.


theorem inf_sup_right : ∀ {α : Type u} [inst : DistribLattice α] (a b c : α), (a ⊔ b) ⊓ c = a ⊓ c ⊔ b ⊓ c := by sorry

This theorem, `inf_sup_right`, states that for all types `α` that form a distributive lattice, and for all elements `a`, `b`, and `c` of this type, the supremum (join, denoted by `⊔`) of `a` and `b`, followed by the infimum (meet, denoted by `⊓`) with `c`, equals the supremum of the infimum of `a` and `c` with the infimum of `b` and `c`. In mathematical terms, it expresses the distributive property of a lattice: `(a ∨ b) ∧ c = (a ∧ c) ∨ (b ∧ c)`, where `∨` represents the join operation and `∧` represents the meet operation.

For all types `α` that form a distributive lattice and all elements `a`, `b`, and `c` of this type, `(a ⊔ b) ⊓ c = a ⊓ c ⊔ b ⊓ c`.


theorem Cardinal.lift_lift :
    ∀ (a : Cardinal.{u_1}), Cardinal.lift.{w, max v u_1} (Cardinal.lift.{v, u_1} a) = Cardinal.lift.{max v w, u_1} a :=
  by sorry

The theorem `Cardinal.lift_lift` states that for every cardinal number `a` in the universe `u_1`, lifting `a` first to the universe `max v u_1` and then to the universe `max w (max v u_1)` is the same as lifting `a` directly to the universe `max v w u_1`. This means that the process of lifting cardinal numbers to higher universes is associative, i.e., the order in which we perform the lifting operations does not affect the final result.

For any cardinal number `a` and universes `v`, `w`, the cardinal liftings `Cardinal.lift a v u_1` and `Cardinal.lift (Cardinal.lift a v) w (u_1)` are equal to `Cardinal.lift a w u_1`.


theorem Finset.filter_congr_decidable :
    ∀ {α : Type u_1} (s : Finset α) (p : α → Prop) (h : DecidablePred p) [inst : DecidablePred p],
      Finset.filter p s = Finset.filter p s :=
  by sorry

This theorem states that for any given set `s` of type `Finset α`, and any predicate `p` which is a decidable property on elements of type `α`, the filtered subset of `s` where elements satisfy the predicate `p` remains the same regardless of the decidable instance being used. In other words, the specific decidable instance, which is used to determine whether each element satisfies `p`, does not affect the outcome of the `Finset.filter` operation. This ensures consistency in the filtered results even when multiple decidable instances for the same predicate are present.

For any decidable predicate `p` on type `α` and finite set `s` of type `Finset α`, the filtered subsets `{x : s | p x}` are equal for all decidable instances of `p`.


/-- **Alias** of the forward direction of `lipschitzWith_iff_dist_le_mul`. -/
theorem LipschitzWith.dist_le_mul :
    ∀ {α : Type u} {β : Type v} [inst : PseudoMetricSpace α] [inst_1 : PseudoMetricSpace β] {K : NNReal} {f : α → β},
      LipschitzWith K f → ∀ (x y : α), dist (f x) (f y) ≤ ↑K * dist x y :=
  by sorry

The theorem `LipschitzWith.dist_le_mul` asserts that for any objects `α` and `β` (which are types equipped with a pseudo metric space structure), a nonnegative real number `K`, and a function `f` mapping from `α` to `β`, if `f` is Lipschitz continuous with constant `K`, then for any two elements `x` and `y` in `α`, the distance between `f(x)` and `f(y)` is less than or equal to `K` times the distance between `x` and `y`. This theorem is a restatement or alias of the forward direction of a related theorem `lipschitzWith_iff_dist_le_mul`.

Given types `α` and `β` with pseudo metric spaces structures, a Lipschitz continuous function `f` from `α` to `β` with constant `K`, and elements `x` and `y` in `α`, we have `dist(f(x), f(y)) ≤ K * dist(x, y)`.


theorem smul_mul' :
    ∀ {M : Type u_1} {A : Type u_4} [inst : Monoid M] [inst_1 : Monoid A] [inst_2 : MulDistribMulAction M A] (a : M)
      (b₁ b₂ : A), a • (b₁ * b₂) = a • b₁ * a • b₂ :=
  by sorry

This theorem, `smul_mul'`, states that for any two types, `M` and `A`, where `M` is a monoid and `A` is also a monoid with an additional structure of a multiplication-distribution action of `M` on `A`, the scalar multiplication of a number `a` (from `M`) and the multiplication of any two elements `b₁` and `b₂` (from `A`), is equal to the multiplication of the scalar multiplication of `a` with `b₁` and the scalar multiplication of `a` with `b₂`. This is an important property that shows the compatibility of the scalar multiplication with the monoid multiplication in `A`.

For any monoid `M` and monoid `A` with a multiplication-distribution action of `M` on `A`, the scalar multiplication of an element `a` in `M` with the product of elements `b₁` and `b₂` in `A` is equal to the product of the scalar multiplication of `a` with `b₁` and the scalar multiplication of `a` with `b₂`.


theorem Set.nonempty_Ioo :
    ∀ {α : Type u_1} [inst : Preorder α] {a b : α} [inst_1 : DenselyOrdered α], Set.Nonempty (Set.Ioo a b) ↔ a < b := by
  sorry

This theorem states that for any type `α` with a preorder (i.e., a relation that is reflexive and transitive) and any two elements `a` and `b` of this type, if the type is densely ordered (meaning that for any two distinct elements, there's always another element strictly between them), then the left-open right-open interval between `a` and `b` is nonempty if and only if `a` is less than `b`. Essentially, it asserts that in a densely ordered type, there exist elements in the open interval between `a` and `b` if `a` is less than `b`.

In a densely ordered type with preorder relation, an element `a` is strictly less than `b` if and only if the open interval `(a, b)` is nonempty.


theorem CategoryTheory.Limits.prod.hom_ext :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {W X Y : C}
      [inst_1 : CategoryTheory.Limits.HasBinaryProduct X Y] {f g : W ⟶ X ⨯ Y},
      CategoryTheory.CategoryStruct.comp f CategoryTheory.Limits.prod.fst =
          CategoryTheory.CategoryStruct.comp g CategoryTheory.Limits.prod.fst →
        CategoryTheory.CategoryStruct.comp f CategoryTheory.Limits.prod.snd =
            CategoryTheory.CategoryStruct.comp g CategoryTheory.Limits.prod.snd →
          f = g :=
  by sorry

The theorem `CategoryTheory.Limits.prod.hom_ext` states that in a category `C` with a binary product of objects `X` and `Y`, for any two morphisms `f` and `g` from an object `W` to the binary product `X ⨯ Y`, if the composition of `f` with the projection to the first component of the product equals the composition of `g` with the same projection, and similarly for the second component, then `f` must be equal to `g`. In other words, a morphism to a binary product in a category is determined by its compositions with the projection morphisms.

In a category with binary products, if two morphisms from an object to the product have the same compositions with both projection morphisms, then they are equal.


theorem Filter.tendsto_congr' :
    ∀ {α : Type u} {β : Type v} {f₁ f₂ : α → β} {l₁ : Filter α} {l₂ : Filter β},
      f₁ =ᶠ[l₁] f₂ → (Filter.Tendsto f₁ l₁ l₂ ↔ Filter.Tendsto f₂ l₁ l₂) :=
  by sorry

The theorem `Filter.tendsto_congr'` states that for any two functions `f₁` and `f₂` from a type `α` to another type `β`, and any two filters `l₁` on `α` and `l₂` on `β`, if `f₁` is eventually equal to `f₂` at `l₁` (denoted by `f₁ =ᶠ[l₁] f₂`), then `f₁` tends to `l₂` along `l₁` if and only if `f₂` also tends to `l₂` along `l₁`. Here, "tends to `l₂` along `l₁`" means that for every neighborhood `a` of `l₂`, the preimage of `a` under the function is a neighborhood of `l₁`.

For functions `f₁` and `f₂` from type `α` to type `β`, and filters `l₁` on `α` and `l₂` on `β`, if `f₁` is eventually equal to `f₂` at `l₁` and for every neighborhood `a` of `l₂`, the preimage of `a` under `f₁` is a neighborhood of `l₁` if and only if the same holds for `f₂`, then `f₁` and `f₂` both tend to `l₂` along `l₁`.


/-- **Alias** of `Rat.cast_natCast`. -/
theorem Rat.cast_coe_nat : ∀ {α : Type u_3} [inst : DivisionRing α] (n : ℕ), ↑↑n = ↑n := by sorry

This theorem, known as `Rat.cast_coe_nat`, is an alias of `Rat.cast_natCast`. It states that for any division ring α and any natural number `n`, the double coercion of `n` to rational numbers and then to elements of α is the same as the direct coercion of `n` to elements of α. In simpler terms, it's asserting that casting a natural number to a rational and then to any element of a division ring is equivalent to casting the natural number directly to that division ring.

For any division ring α and natural number n, the coercion of n to α via the rational numbers is equal to the direct coercion of n to α.


theorem Finset.card_image_of_injective :
    ∀ {α : Type u_1} {β : Type u_2} {f : α → β} [inst : DecidableEq β] (s : Finset α),
      Function.Injective f → (Finset.image f s).card = s.card :=
  by sorry

The theorem `Finset.card_image_of_injective` states that for any types `α` and `β`, any function `f : α → β`, and any finite set `s : Finset α`, if the function `f` is injective (meaning that the same output value can only be produced by the same input value), then the cardinality (or size) of the image of the finite set `s` under the function `f` is equal to the cardinality of the original set `s`. In other words, if a function is injective, it does not change the number of distinct elements when mapping a finite set to another. The context `DecidableEq β` signifies that equality between elements of type `β` is decidable.

If `f : α → β` is an injective function and `s : Finset α` is a finite set, then `#(map f s) = #s`. (Here, `#` denotes the cardinality or size of a set.)


/-- Sum of elements in an `AddSubmonoid` of an `AddCommMonoid` indexed by a `Finset`
is in the `AddSubmonoid`. -/
theorem sum_mem :
    ∀ {B : Type u_3} {S : B} {M : Type u_4} [inst : AddCommMonoid M] [inst_1 : SetLike B M]
      [inst_2 : AddSubmonoidClass B M] {ι : Type u_5} {t : Finset ι} {f : ι → M},
      (∀ c ∈ t, f c ∈ S) → (Finset.sum t fun c => f c) ∈ S :=
  by sorry

This theorem states that the sum of elements in an additive submonoid of an additive commutative monoid, when indexed by a finite set, is also in the same additive submonoid. Specifically, given a type `B` representing the additive submonoid `S` of a type `M` that forms an additive commutative monoid, and given a function `f` that maps elements from a finite set `t` of an arbitrary type `ι` to the monoid `M`, if every element in `t` is mapped to an element in `S` by `f`, then the sum of the mapped elements (i.e., the sum of `f c` for all `c` in `t`) is also an element of `S`.

Given an additive submonoid `S` of an additive commutative monoid `M`, and a function `f` mapping a finite set to `M` such that `f(t)` is in `S` for all `t` in the set, then the sum of `f(t)` for all `t` in the set is also in `S`.


theorem Int.sub_eq_zero_of_eq : ∀ {a b : ℤ}, a = b → a - b = 0 := by sorry

The theorem `Int.sub_eq_zero_of_eq` states that for any two integers `a` and `b`, if `a` equals `b`, then the result of subtracting `b` from `a` is `0`. In mathematical terms, this theorem asserts that for all integers `a` and `b`, if `a = b`, then `a - b = 0`.

For all integers `a` and `b`, if `a = b`, then `a - b = 0`.


theorem CategoryTheory.Limits.biproduct.ι_desc :
    ∀ {J : Type w} {C : Type u} [inst : CategoryTheory.Category.{v, u} C]
      [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] {f : J → C} [inst_2 : CategoryTheory.Limits.HasBiproduct f]
      {P : C} (p : (b : J) → f b ⟶ P) (j : J),
      CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.biproduct.ι f j)
          (CategoryTheory.Limits.biproduct.desc p) =
        p j :=
  by sorry

This theorem, `CategoryTheory.Limits.biproduct.ι_desc`, states that for any category `C` with zero morphisms and a given type `J`, if we have a function `f : J → C` forming a biproduct in `C`, and a morphism `p` from each component of `f` to an object `P` in `C`, then the composition of the inclusion from `f j` into the biproduct and the morphism from the biproduct to `P` given by `p` is equal to the morphism `p j` itself. In other words, this theorem states a universal property of biproducts in a category, providing a way to describe and work with such objects in a general and abstract manner.

 For any category with zero morphisms and a biproduct `(i, s, t, μ, λ)` over a type `J`, the following commutative square holds:

`di ⊎ f j ⥤ P ⊆ biproduct i j ⥤ P ≅ p j`

where `di` is the inclusion morphism of the biproduct component, `f j` is the morphism from the function `f : J → C` to the biproduct component, and `p j` is the given morphism from each component to an object `P` in the category.


theorem Set.iUnion_of_empty : ∀ {α : Type u_1} {ι : Sort u_4} [inst : IsEmpty ι] (s : ι → Set α), ⋃ i, s i = ∅ := by
  sorry

This theorem states that for any type `α` and an index type `ι`, if `ι` is empty (i.e., there are no elements of type `ι`), then the indexed union of sets `s i` (from `ι` to `Set α`) results in the empty set. In other words, if we have a family of sets but no indices to pick any set from that family, the union of these sets would be empty.

If `ι` is empty, then the indexed union of sets `s i` (for `i` in `ι`) is the empty set.


theorem CategoryTheory.Functor.map_inv :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
      (F : CategoryTheory.Functor C D) {X Y : C} (f : X ⟶ Y) [inst_2 : CategoryTheory.IsIso f],
      F.map (CategoryTheory.inv f) = CategoryTheory.inv (F.map f) :=
  by sorry

The theorem `CategoryTheory.Functor.map_inv` states that for any category `C` and `D`, and any functor `F` from `C` to `D`, if `f` is an isomorphism in the category `C` from `X` to `Y`, then the image of the inverse of `f` under the functor `F` is equal to the inverse of the image of `f` under `F`. In other words, a functor preserves the inverse of isomorphisms.

If `f: X → Y` is an isomorphism in a category `C` and `F: C → D` is a functor, then `F(f)^-1 = F(f^-1)`.


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

This theorem, referred to as `Set.preimage_iUnion`, establishes a property related to the preimage of a union of sets through a function. Specifically, for any types `α` and `β`, any indexing type `ι`, any function `f` from `α` to `β`, and any indexed collection of sets `s` from `ι` to the sets of `β`, the preimage of the union of the sets `s i` under the function `f` equals the union of the preimages of each individual set `s i` under the same function. In more mathematical language, it states that $f^{-1}(\bigcup_{i} s_i) = \bigcup_{i} f^{-1}(s_i)$, where $f^{-1}$ denotes the preimage of a set under the function `f`.

For any function `f` from type `α` to type `β`, and any indexed collection of sets `s` from `ι` to the sets of `β`, the preimage of the union of the sets `s i` under `f` is equal to the union of the preimages of each individual set `s i` under `f`. In symbols, $f^{-1}(\bigcup\_{i} s\_i) = \bigcup\_{i} f^{-1}(s\_i)$.


theorem pow_bit0_nonneg : ∀ {R : Type u_3} [inst : LinearOrderedRing R] (a : R) (n : ℕ), 0 ≤ a ^ bit0 n := by sorry

This theorem, `pow_bit0_nonneg`, states that for any linearly ordered ring `R` and any element `a` of `R`, the power of `a` raised to the `bit0` of any natural number `n` is always non-negative (`0 ≤ a ^ bit0 n`). In simpler terms, it's saying that for any real number `a` and natural number `n`, `a` to the power of twice `n` (since `bit0 n = n + n`) is always greater than or equal to zero.

For any linearly ordered ring R and its element a, 0 ≤ a ^ bit0 n. (Or, equivalently, a ^ (2 * n) ≥ 0 for any natural number n.)


theorem Mathlib.Algebra.Function.Support._auxLemma.2 :
    ∀ {α : Type u_1} {M : Type u_5} [inst : Zero M] {f : α → M} {x : α}, (x ∈ Function.support f) = (f x ≠ 0) := by
  sorry

The theorem `Mathlib.Algebra.Function.Support._auxLemma.2` states that for any type `α`, any type `M` with a zero element, any function `f` from `α` to `M`, and any element `x` of type `α`, the element `x` belongs to the support of function `f` if and only if the function `f` at `x` is not equal to zero. In other words, a point `x` is in the support of a function `f` precisely when `f(x)` is nonzero.

A function's support equals the set of arguments where the function does not equal the zero element.


theorem Set.Ioi_inter_Iio : ∀ {α : Type u_1} [inst : Preorder α] {a b : α}, Set.Ioi a ∩ Set.Iio b = Set.Ioo a b := by
  sorry

This theorem states that for any type `α` that has a preorder (a relation that is reflexive and transitive), and any two elements `a` and `b` of that type, the intersection of the set of all elements greater than `a` (denoted as `Set.Ioi a`) and the set of all elements less than `b` (denoted as `Set.Iio b`) is exactly the set of all elements `x` such that `a < x < b` (denoted as `Set.Ioo a b`). In mathematical terms, it can be written as $(a, \infty) \cap (-\infty, b) = (a, b)$.

For any type `α` with a preorder, and elements `a` and `b` of `α`, `Set.Ioi a ∩ Set.Iio b` equals `Set.Ioo a b`.


Substring.ValidFor.toString

theorem Substring.ValidFor.toString :
    ∀ {l m r : List Char} {s : Substring}, Substring.ValidFor l m r s → Substring.toString s = { data := m } := by sorry

The theorem `Substring.ValidFor.toString` states that for any three lists of characters `l`, `m`, and `r`, and any substring `s`, if `s` is a valid substring for the concatenation of `l`, `m`, and `r`, then the string representation of `s` is equivalent to the list `m`. In simpler terms, this theorem guarantees that the `toString` function of a valid substring derived from a concatenation of character lists correctly returns the middle part `m` of the concatenation as a string.

If `s` is a valid substring of the concatenation of lists `l`, `m`, and `r` in Lean's `Char` type, then `toString s = m`.


theorem top_inf_eq : ∀ {α : Type u} [inst : SemilatticeInf α] [inst_1 : OrderTop α] (a : α), ⊤ ⊓ a = a := by sorry

This theorem states that for any type `α` that is a semilattice under the operation of infimum (`⊓`) and has a defined top element (`⊤`), the infimum of the top element and any element `a` of the type is `a` itself. In more familiar mathematical terms, this says that in any partially ordered set which is a semilattice with greatest element, the greatest element 'meet' any element is that element itself. This reflects the intuitive idea that the intersection of any set with a universal set gives back the original set.

In a semilattice with a top element, the infimum of the top element and any element is that element itself.


MvPowerSeries.ext

/-- Two multivariate formal power series are equal if all their coefficients are equal. -/
theorem MvPowerSeries.ext :
    ∀ {σ : Type u_1} {R : Type u_2} [inst : Semiring R] {φ ψ : MvPowerSeries σ R},
      (∀ (n : σ →₀ ℕ), (MvPowerSeries.coeff R n) φ = (MvPowerSeries.coeff R n) ψ) → φ = ψ :=
  by sorry

The theorem `MvPowerSeries.ext` states that for any semiring `R` and index set `σ`, if two multivariate formal power series `φ` and `ψ` have all their coefficients equal, i.e., for each `n` which is a function from the index set `σ` to non-negative integers, the `n`th coefficient of `φ` equals the `n`th coefficient of `ψ`, then these two power series `φ` and `ψ` are identical. The theorem essentially establishes the principle of coefficient-wise equality for multivariate formal power series over a semiring.

If two multivariate formal power series over a semiring have equal coefficients for all monomials, then they are equal.


Function.RightInverse.surjective

theorem Function.RightInverse.surjective :
    ∀ {α : Sort u₁} {β : Sort u₂} {f : α → β} {g : β → α}, Function.RightInverse g f → Function.Surjective f := by sorry

The theorem `Function.RightInverse.surjective` states that for any two types `α` and `β`, and any two functions `f : α → β` and `g : β → α`, if `g` is a right inverse to `f` (i.e., the composition `f ∘ g` equals the identity function), then `f` is surjective. In other words, for every element `b` in `β`, there exists an element `a` in `α` such that `f(a) = b`.

If `f : α → β` has a right inverse `g : β → α` in Lean 4, then `f` is surjective.


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

This theorem states that for all instances of a type `α` in a subtraction commutative monoid, the subtraction of `b` and `c` from `a` in sequence (i.e., `(a - b) - c`) is the same as subtracting the sum of `b` and `c` from `a` once (i.e., `a - (b + c)`). This is a property of subtraction in the context of commutative monoids.

For all commutative monoids `α`, and all elements `a`, `b`, and `c` of `α`, `(a - b) - c = a - (b + c)`.


theorem Mathlib.Combinatorics.SimpleGraph.Basic._auxLemma.6 :
    ∀ {V : Type u} (G : SimpleGraph V) {v : V}, G.Adj v v = False := by sorry

This theorem states that for any type `V`, any simple graph `G` of type `SimpleGraph V`, and any vertex `v` of type `V`, the adjacency of `v` to itself in `G` is always `False`. In other words, in a simple graph, no vertex is adjacent to itself.

In a simple graph, no vertex is adjacent to itself. (Or, formally in Lean: `∀ (V : Type) (G : SimpleGraph V) (v : V), ¬ Adj G v v`)


theorem measurable_prod_mk_left :
    ∀ {α : Type u_1} {β : Type u_2} {m : MeasurableSpace α} {mβ : MeasurableSpace β} {x : α}, Measurable (Prod.mk x) :=
  by sorry

The theorem `measurable_prod_mk_left` states that for all types `α` and `β`, given measurable spaces `m` over `α` and `mβ` over `β`, and for any element `x` of type `α`, the function `Prod.mk x`, which creates a pair with `x` as the first element and a variable element of type `β` as the second, is a measurable function. In other words, the preimage of any measurable set under this function is also a measurable set.

For measurable spaces (m : MeasurableSpace α) and (mβ : MeasurableSpace β), the function Prod.mk : α → α × β is measurable.


theorem even_iff_two_dvd : ∀ {α : Type u_2} [inst : Semiring α] {a : α}, Even a ↔ 2 ∣ a := by sorry

This theorem states that for any element `a` of a type `α` that forms a semiring, `a` is even if and only if `a` is divisible by 2. In more mathematical terms, let `α` be a semiring. For any `a` in `α`, `a` satisfies the property `Even` (i.e., there exists some `r` in `α` such that `a = r + r`) if and only if `2` divides `a` (i.e., there exists some `k` in `α` such that `a = 2 * k`).

In a semiring, an element is even if and only if it is divisible by 2.


/-- **Alias** of the reverse direction of `sub_eq_zero`. -/
theorem sub_eq_zero_of_eq : ∀ {G : Type u_3} [inst : AddGroup G] {a b : G}, a = b → a - b = 0 := by sorry

This theorem, `sub_eq_zero_of_eq`, is essentially an alias of the reverse direction of another theorem named `sub_eq_zero`. The theorem states that for any AddGroup `G` and any two element `a` and `b` of the same type, if `a` equals `b`, then the subtraction of `b` from `a` equals zero. The `AddGroup` is a mathematical structure in group theory where addition is the group operation.

If `a` and `b` are elements of an AddGroup, then `a - b = 0` if and only if `a = b`.


theorem Finset.prod_subset :
    ∀ {α : Type u_3} {β : Type u_4} {s₁ s₂ : Finset α} {f : α → β} [inst : CommMonoid β],
      s₁ ⊆ s₂ → (∀ x ∈ s₂, x ∉ s₁ → f x = 1) → (Finset.prod s₁ fun x => f x) = Finset.prod s₂ fun x => f x :=
  by sorry

The `Finset.prod_subset` theorem states that for any two finite sets `s₁` and `s₂` of type `α`, and a function `f` mapping `α` to `β`, in the context of a commutative monoid structure on `β`, if `s₁` is a subset of `s₂` and for every element `x` in `s₂` that is not in `s₁`, the function `f` maps `x` to the identity element `1`, then the product of `f(x)` as `x` ranges over `s₁` is equal to the product of `f(x)` as `x` ranges over `s₂`. In mathematical notation, given $s_1 \subseteq s_2$ and $\forall x \in s_2, x \notin s_1 \Rightarrow f(x) = 1$, we have $\prod_{x \in s_1} f(x) = \prod_{x \in s_2} f(x)$.

If `s₁` is a subset of `s₂`, and for every `x` in `s₂` not in `s₁`, `f(x)` equals the identity element `1`, then the product of `f(x)` over `s₁` equals the product of `f(x)` over `s₂`.


theorem lt_iff_lt_of_le_iff_le' :
    ∀ {α : Type u} {β : Type u_3} [inst : Preorder α] [inst_1 : Preorder β] {a b : α} {c d : β},
      (a ≤ b ↔ c ≤ d) → (b ≤ a ↔ d ≤ c) → (b < a ↔ d < c) :=
  by sorry

This theorem states that for all types `α` and `β` with a preorder relation, given any elements `a`, `b` from `α` and `c`, `d` from `β`, if the implication that `a` is less than or equal to `b` if and only if `c` is less than or equal to `d` holds, and also the implication that `b` is less than or equal to `a` if and only if `d` is less than or equal to `c` holds, then the theorem guarantees that the implication that `b` is strictly less than `a` holds if and only if `d` is strictly less than `c`. In simpler terms, this is about the equivalence of order relations in two preordered sets under certain conditions.

If `α` and `β` are preordered sets with equivalent order relations between `a ≤ b` in `α` and `c ≤ d` in `β`, and between `b ≤ a` in `α` and `d ≤ c` in `β`, then `b < a` in `α` if and only if `d < c` in `β`.


theorem Nat.mul_le_mul_right : ∀ {n m : ℕ} (k : ℕ), n ≤ m → n * k ≤ m * k := by sorry

This theorem states that for all natural numbers `n`, `m`, and `k`, if `n` is less than or equal to `m`, then the product of `n` and `k` is less than or equal to the product of `m` and `k`. This is a formal statement of the property that multiplication by a given natural number preserves the order of natural numbers.

For all natural numbers `n`, `m`, and `k`, if `n ≤ m` then `n * k ≤ m * k`.


theorem isClosed_singleton : ∀ {X : Type u_1} [inst : TopologicalSpace X] [inst_1 : T1Space X] {x : X}, IsClosed {x} :=
  by sorry

This theorem states that for any given type `X` with an instance of a topological space and a T1 space, any singleton set which contains a single element `x` of type `X` is a closed set. In other words, in a T1 topological space, singletons are always closed sets.

In a T1 topological space, the singleton set of any point is a closed set.


/-- `lift.{max u v, u}` equals `lift.{v, u}`.  -/
theorem Cardinal.lift_umax : Cardinal.lift.{max u v, u} = Cardinal.lift.{v, u} := by sorry

This theorem states that for any two universes `u` and `v`, the operation of "lifting" a cardinal from universe `v` to `u` (denoted by `Cardinal.lift.{v, u}`) is equivalent to the operation of "lifting" a cardinal from the universe `max(u, v)` to `u` (denoted by `Cardinal.lift.{max u v, u}`). In other words, for any cardinal, whether we first lift it to a larger universe and then to `u`, or directly lift it to `u`, the result will be the same.

For any cardinals $c$ and universes $u$ and $v$, the lifting of $c$ from universe $v$ to $u$ is equal to the lifting of $c$ from the maximum of $u$ and $v$ to $u$ in Lean 4. (i.e., `Cardinal.lift.{v, u} c = Cardinal.lift.{max u v, u} c`).


theorem mem_connectedComponent : ∀ {α : Type u} [inst : TopologicalSpace α] {x : α}, x ∈ connectedComponent x := by
  sorry

This theorem states that for any type `α` that has a topological space structure and any element `x` of the type `α`, `x` is an element of its own connected component. In other words, every point in a topological space is contained within its connected component. A connected component of a point in a topological space is the largest connected set that includes that point.

Every point in a topological space is contained in its connected component.


theorem neg_zsmul : ∀ {α : Type u_1} [inst : SubtractionMonoid α] (a : α) (n : ℤ), -n • a = -(n • a) := by sorry

This theorem, `neg_zsmul`, states that for any type `α` that forms a SubtractionMonoid (an algebraic structure with an operation that combines any two elements to form a third and an operation that subtracts one element from another), and any element `a` of type `α`, the operation of scalar multiplication by the negative of an integer `n` applied to `a` is equal to the negation of the result of scalar multiplication by `n` applied to `a`. In simpler terms, it asserts that the negative of `n` times `a` equals to the negative of (`n` times `a`).

For any type `α` that forms a SubtractionMonoid and any element `a` of type `α`, we have -(n * a) = n \* (-a) for any integer `n`.


theorem not_lt_bot : ∀ {α : Type u} [inst : Preorder α] [inst_1 : OrderBot α] {a : α}, ¬a < ⊥ := by sorry

This theorem states that for any type `α` that has a `Preorder` and `OrderBot` structure, any element `a` of type `α` cannot be less than the bottom element, denoted by `⊥`. In other words, in any preordered set with a smallest element, no element is less than this smallest element.

In any preordered type with a bottom element, no element is strictly less than the bottom element.


theorem Mathlib.Order.Filter.Basic._auxLemma.131 :
    ∀ {α : Type u} {β : Type v} {m : α → β} {f : Filter α} {s : Set β},
      (s ∈ Filter.kernMap m f) = ∃ t, tᶜ ∈ f ∧ m '' t = sᶜ :=
  by sorry

This theorem states that for all types `α` and `β`, a mapping `m` from `α` to `β`, a filter `f` on `α`, and a set `s` of `β` elements, whether `s` is in the kernel map of `m` and `f` is equivalent to the existence of a set `t` such that the complement of `t` is in `f` and the image of `t` under `m` is equal to the complement of `s`. In other words, `s` belongs to the kernel map of `m` and `f` if and only if there is a set `t` with these properties regarding `f` and `m`.

For any filter $f$ on type $\alpha$, set $s$ in type $\beta$, and mapping $m$ from $\alpha$ to $\beta$, $s$ is in the kernel of $m$ with respect to $f$ if and only if there exists a set $t$ such that $t$ is disjoint from $f$ and $m(t) = \complement s$.


Set.Countable.mono

theorem Set.Countable.mono : ∀ {α : Type u} {s₁ s₂ : Set α}, s₁ ⊆ s₂ → Set.Countable s₂ → Set.Countable s₁ := by sorry

The theorem `Set.Countable.mono` asserts that for any two sets `s₁` and `s₂` of a certain type `α`, if `s₁` is a subset of `s₂` and if `s₂` is countable, then `s₁` is also countable. In other words, countability is preserved under taking subsets: if you have a countable set and you select some elements from it to form a new set, the resulting set will also be countable.

If `s₁` is a subset of countable set `s₂` of type `α`, then `s₁` is also countable.


theorem CategoryTheory.NatTrans.comp_app :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂}
      [inst_1 : CategoryTheory.Category.{v₂, u₂} D] {F G H : CategoryTheory.Functor C D} (α : F ⟶ G) (β : G ⟶ H)
      (X : C),
      (CategoryTheory.CategoryStruct.comp α β).app X = CategoryTheory.CategoryStruct.comp (α.app X) (β.app X) :=
  by sorry

The theorem `CategoryTheory.NatTrans.comp_app` states that for any categories `C` and `D`, and any functors `F`, `G`, and `H` from `C` to `D`, and for all natural transformations `α` from `F` to `G` and `β` from `G` to `H`, and any object `X` in `C`, the application of the composite of `α` and `β` to `X` is equal to the composition of the applications of `α` and `β` to `X`. This is essentially asserting the functoriality of natural transformations in the category of functors from `C` to `D`.

Given categories C and D, functors F, G, and H from C to D, and natural transformations α: F ➝ G and β: G ➝ H, the composition of α and β, β ∘ α, is equal to the composition of their applications to any object X in C, (β ∘ α)(X) = β(G(α(X))).


theorem CategoryTheory.Limits.prod.map_snd :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {W X Y Z : C}
      [inst_1 : CategoryTheory.Limits.HasBinaryProduct W X] [inst_2 : CategoryTheory.Limits.HasBinaryProduct Y Z]
      (f : W ⟶ Y) (g : X ⟶ Z),
      CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.prod.map f g) CategoryTheory.Limits.prod.snd =
        CategoryTheory.CategoryStruct.comp CategoryTheory.Limits.prod.snd g :=
  by sorry

This theorem is a statement about the behavior of morphisms and binary products in a category. Specifically, it asserts that for any category `C` and given objects `W`, `X`, `Y`, and `Z` in `C`, if `W ⨯ X` and `Y ⨯ Z` are binary products in `C`, and `f` is a morphism from `W` to `Y` and `g` is a morphism from `X` to `Z`, then the composition of `f` and `g` followed by the projection map to the second component of the product is equal to the composition of the projection map to the second component of the product and `g`. In mathematical terms, this can be written as `(f ⨯ g) ∘ π₂ = π₂ ∘ g`, where `π₂` denotes the second projection map.

Given any category `C`, morphisms `f: W → Y` and `g: X → Z`, and objects `W`, `X`, `Y`, and `Z` such that `W ⨯ X` and `Y ⨯ Z` are binary products, then `(f ⨯ g) ∘ π₂ = π₂ ∘ g`, where `π₂` denotes the second projection map.


theorem Nat.Ico_zero_eq_range : Finset.Ico 0 = Finset.range := by sorry

This theorem states that the `Finset.Ico 0` function is equivalent to the `Finset.range` function. In other words, the set of natural numbers `x` such that `0 ≤ x` and `x < n`, which is given by `Finset.Ico 0 n`, is the same as the set of natural numbers less than `n`, given by `Finset.range n`.

The `Finset.Ico 0` function over natural numbers is equal to the `Finset.range` function with the same upper bound.


theorem div_div_eq_mul_div : ∀ {α : Type u_1} [inst : DivisionMonoid α] (a b c : α), a / (b / c) = a * c / b := by sorry

This theorem, `div_div_eq_mul_div`, states that for any type α which forms a division monoid, for any three elements `a`, `b`, `c` of this type, the operation of dividing `a` by the result of `b / c` is equivalent to multiplying `a` and `c` and then dividing the result by `b`. Formally in mathematical terms, it asserts that $\frac{a}{\frac{b}{c}} = \frac{a \cdot c}{b}$.

For any type α forming a division monoid, $\frac{a}{\frac{b}{c}} = \frac{a \cdot c}{b}$.


/-- An additive submonoid `S` includes `closure s` if and only if it includes `s` -/
theorem AddSubmonoid.closure_le :
    ∀ {M : Type u_1} [inst : AddZeroClass M] {s : Set M} {S : AddSubmonoid M}, AddSubmonoid.closure s ≤ S ↔ s ⊆ ↑S := by
  sorry

The theorem `AddSubmonoid.closure_le` states that for any type `M` equipped with an additive zero class structure, any set `s` of elements of type `M`, and any additive submonoid `S` of type `M`, the additive submonoid generated by `s` (denoted `AddSubmonoid.closure s`) is contained within `S` if and only if the set `s` is a subset of the underlying set of `S`, denoted as `↑S`. In other words, the theorem provides a criterion for an additive submonoid to contain the submonoid generated by a certain set.

For any additive zero class structure on a type `M`, a set `s` of `M` is contained in the additive submonoid generated by `s` if and only if `s` is a subset of an additive submonoid `S` of `M`.


theorem trichotomous_of :
    ∀ {α : Sort u} (r : α → α → Prop) [inst : IsTrichotomous α r] (a b : α), r a b ∨ a = b ∨ r b a := by sorry

This theorem states that for any type `α` and a binary relation `r` on `α`, if `IsTrichotomous α r` is a trichotomous relation (a mathematical term meaning that for any two elements `a` and `b` of type `α`, exactly one of the following is true: `r a b`, `a = b`, or `r b a`), then for all elements `a` and `b` of the type `α`, one and only one of these possibilities must hold: `r a b`, `a = b`, or `r b a`.

If `r` is a trichotomous relation on type `α`, then for all `a` and `b` in `α`, exactly one of `r a b`, `a = b`, or `r b a` holds.


IsCompact.isBounded

/-- A compact set is bounded  -/
theorem IsCompact.isBounded :
    ∀ {α : Type u} [inst : PseudoMetricSpace α] {s : Set α}, IsCompact s → Bornology.IsBounded s := by sorry

This theorem states that for any set `s` in a pseudometric space `α`, if `s` is a compact set, then it is also a bounded set. Compactness here means that for every nontrivial filter on `s`, there exists an element in `s` such that every set in the filter intersects every neighborhood of this element. Boundedness, on the other hand, is defined relative to the ambient bornology on `α`, meaning the set `s` is bounded if its complement is cobounded in this bornology.

In a pseudometric space, every compact set is bounded.


theorem Polynomial.coeff_smul :
    ∀ {R : Type u} {S : Type v} [inst : Semiring R] [inst_1 : SMulZeroClass S R] (r : S) (p : Polynomial R) (n : ℕ),
      Polynomial.coeff (r • p) n = r • Polynomial.coeff p n :=
  by sorry

The theorem `Polynomial.coeff_smul` states that for any given semiring `R`, smul-zero class `S`, scalar `r` of type `S`, polynomial `p` of type `Polynomial R`, and natural number `n`, the coefficient of `X^n` in the scalar multiplication of `r` and `p` is the same as the scalar multiplication of `r` and the coefficient of `X^n` in `p`. In notation, if `coeff` denotes the coefficient function and `•` denotes scalar multiplication, then `coeff (r • p) n = r • coeff p n` for all `r`, `p`, and `n` of the appropriate types.

For any semiring R, scalar s of type S, polynomial p of type Polynomial R, and natural number n, the coefficient of X^n in the scalar multiplication of s and p is equal to the scalar multiplication of s and the coefficient of X^n in p. That is, coeff (s • p) n = s • coeff p n.


theorem MultilinearMap.map_add :
    ∀ {R : Type uR} {ι : Type uι} {M₁ : ι → Type v₁} {M₂ : Type v₂} [inst : Semiring R]
      [inst_1 : (i : ι) → AddCommMonoid (M₁ i)] [inst_2 : AddCommMonoid M₂] [inst_3 : (i : ι) → Module R (M₁ i)]
      [inst_4 : Module R M₂] (f : MultilinearMap R M₁ M₂) [inst_5 : DecidableEq ι] (m : (i : ι) → M₁ i) (i : ι)
      (x y : M₁ i), f (Function.update m i (x + y)) = f (Function.update m i x) + f (Function.update m i y) :=
  by sorry

This theorem, `MultilinearMap.map_add`, states that for any semiring `R`, types `ι`, `M₁` indexed by `ι`, and `M₂`, given instances of `AddCommMonoid` for `M₁ i` and `M₂`, and `Module R` for `M₁ i` and `M₂`, a multilinear map `f` from `M₁` to `M₂`, a decidable equality on ι, and a function `m` from `ι` to `M₁ i`, for any `ι` value and two elements of `M₁ i`, the result of updating the function `m` at `i` with the sum of these two elements and applying the multilinear map `f` on it, is equal to the sum of the results of separately updating the function `m` at `i` with each of these two elements and applying `f`. In mathematical terms, `f(m(i ↦ x + y)) = f(m(i ↦ x)) + f(m(i ↦ y))` for a multilinear map `f` and elements `x`, `y` of a module over a semiring.

For any semiring `R`, types `ι`, `M₁` indexed by `ι`, and `M₂`, given instances of `AddCommMonoid` for `M₁ i` and `M₂`, and a multilinear map `f` from `M₁` to `M₂`, the operation of updating `m : ι → M₁ i` at `i` with the sum of two elements `x` and `y` in `M₁ i`, and applying `f`, equals the sum of the results of updating `m` at `i` with each of `x` and `y` separately and applying `f`. In symbols, `f(m.update i (x + y)) = f(m.update i x) + f(m.update i y)`.