theorem ContinuousMap.coe_nat_cast :
    ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] [inst_2 : NatCast β]
      (n : ℕ), ⇑↑n = ↑n :=
  by sorry

This theorem states that for any natural number `n`, the function application of `n` cast to a continuous map is equal to the `n` itself cast to the target type `β`. Here the types `α` and `β` are topological spaces and `β` has a natural casting from integers. Essentially, this theorem ensures that the casting of a natural number to a continuous map is equivalent to directly casting it to the target type.

For any topological spaces α and β with a natural casting from integers, the continuous application of a natural number n to a function is equal to the direct casting of n to β.


AddGroup.closure.isAddSubgroup

theorem AddGroup.closure.isAddSubgroup :
    ∀ {G : Type u_1} [inst : AddGroup G] (s : Set G), IsAddSubgroup (AddGroup.closure s) := by sorry

The theorem `AddGroup.closure.isAddSubgroup` states that for any type `G` that forms an additive group, and for any set `s` of elements of type `G`, the closure of `s` under the operation of the additive group, denoted as `AddGroup.closure s`, forms an additive subgroup. In other words, the smallest additive subgroup that contains the set `s` is itself an additive subgroup.

The closure of any set in an additive group under the group operation is an additive subgroup.


theorem ZFSet.mem_sUnion : ∀ {x y : ZFSet}, y ∈ ⋃₀ x ↔ ∃ z ∈ x, y ∈ z := by sorry

The theorem `ZFSet.mem_sUnion` states that for all sets `x` and `y` in the ZFC universe of sets, `y` is an element of the union over `x` if and only if there exists a set `z` such that `z` is an element of `x` and `y` is an element of `z`. This theorem asserts the membership criterion for the union of a collection of sets in the ZFC set theory.

For all sets x and y in the ZFC universe, y is an element of the union of x if and only if there exists a set z in x such that y is an element of z.


theorem one_le_mabs :
    ∀ {α : Type u_1} [inst : Lattice α] [inst_1 : Group α]
      [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 : α), 1 ≤ mabs a :=
  by sorry

The theorem `one_le_mabs` states that for any type `α` that has a lattice structure, a group structure, and satisfies two specific covariance conditions, the absolute value (`mabs`) of any element `a` of type `α` is always greater than or equal to one.

The covariance conditions are given in terms of multiplication (`x * x_1`) and an order relation (`x ≤ x_1`). The first condition requires that for any two elements `x` and `x_1` in `α`, if `x * x_1` increases, then `x` increases. The second condition requires the same but with the arguments to the multiplication operation swapped.

This is a generalization of the property we know from real numbers where the absolute value of a number is always non-negative, and is 1 for non-zero numbers when normalized with respect to the group operation.

For any type `α` with lattice and group structures satisfying multiplicative covariance conditions `x * x_1 => x <= x_1` and `x_1 * x => x <= x_1`, the absolute value `mabs a` of any element `a` in `α` is greater than or equal to one.


theorem Prod.mk_mul_mk :
    ∀ {M : Type u_5} {N : Type u_6} [inst : Mul M] [inst_1 : Mul N] (a₁ a₂ : M) (b₁ b₂ : N),
      (a₁, b₁) * (a₂, b₂) = (a₁ * a₂, b₁ * b₂) :=
  by sorry

This theorem, `Prod.mk_mul_mk`, states that for any types `M` and `N` that have multiplication defined on them, the multiplication of two pairs, `(a₁, b₁)` and `(a₂, b₂)`, is equivalent to the pair of their respective multiplications, `(a₁ * a₂, b₁ * b₂)`. In mathematical terms, given two pairs from the cartesian product of `M` and `N`, their product is the pair made by multiplying the first elements together and then the second elements together.

For types `M` and `N` with multiplication, `(a₁, b₁) * (a₂, b₂) = (a₁ * a₂, b₁ * b₂)`.


theorem TopologicalSpace.Opens.coe_iSup :
    ∀ {α : Type u_2} [inst : TopologicalSpace α] {ι : Sort u_5} (s : ι → TopologicalSpace.Opens α),
      ↑(⨆ i, s i) = ⋃ i, ↑(s i) :=
  by sorry

This theorem states that, for any topological space `α`, and any indexed set of open sets `s : ι → TopologicalSpace.Opens α`, the operation of taking the supremum (`⨆ i, s i`) in the lattice of open sets and then applying the coercion to sets (`↑`) is the same as first applying the coercion to each open set and then taking the union over all indices (`⋃ i, ↑(s i)`). In other words, in the context of topological spaces, the supremum of a collection of open sets, when viewed as a set, is the union of these sets.

For any topological space `α` and indexed family `s : ι → OpenSet α`, the supremum of `s` in the lattice of open sets, as a set, equals the union of `{↑(s i) | i ∈ ι}`.


theorem Finset.dvd_lcm :
    ∀ {α : Type u_1} {β : Type u_2} [inst : CancelCommMonoidWithZero α] [inst_1 : NormalizedGCDMonoid α] {s : Finset β}
      {f : β → α} {b : β}, b ∈ s → f b ∣ Finset.lcm s f :=
  by sorry

The theorem `Finset.dvd_lcm` states that for any types `α` and `β`, given a cancelable commutative monoid with zero for `α` and a normalized GCD monoid for `α`, any finite set `s` of type `β` and a function `f` from `β` to `α`, if an element `b` belongs to the set `s`, then `f(b)` divides the least common multiple (LCM) of the set `s` as mapped by `f`. Essentially, this theorem guarantees that any element's image under `f` is a factor of the LCM of the image of the whole set under `f`.

For any cancelable commutative monoid with zero for type `α`, normalized GCD monoid for type `α`, finite set `s` of type `β`, and function `f` from `β` to `α`, if `b ∈ s`, then `f(b)` divides the LCM of the images of `s` under `f`.


theorem Units.inv_mul_cancel_right : ∀ {α : Type u} [inst : Monoid α] (a : α) (b : αˣ), a * ↑b⁻¹ * ↑b = a := by sorry

This theorem states that for any type `α` that forms a monoid (a structure where we have an associative binary operation, and an identity element relative to this operation), if you take any element `a` of type `α` and another element `b` which is a unit (meaning it has a multiplicative inverse), then multiplying `a` by the inverse of `b` and then by `b` itself will just give you `a` back. This effectively expresses the property that multiplying by a unit's inverse and the unit itself is a form of cancellation, returning you to your original value of `a`.

For any monoid `α` and elements `a` of type `α` with a unit `b`, `a * b ^-1 * b = a`, where `*` denotes the monoid operation and `^-1` denotes the multiplicative inverse.


theorem DFinsupp.comapDomain'_apply :
    ∀ {ι : Type u} {β : ι → Type v} {κ : Type u_1} [inst : (i : ι) → Zero (β i)] (h : κ → ι) {h' : ι → κ}
      (hh' : Function.LeftInverse h' h) (f : Π₀ (i : ι), β i) (k : κ), (DFinsupp.comapDomain' h hh' f) k = f (h k) :=
  by sorry

The theorem `DFinsupp.comapDomain'_apply` states that for every function `h` from a type `κ` to a type `ι`, given an explicit left inverse `h'` of `h` (i.e., `h' ∘ h = id`), and a function `f` from ι to a type `β` that is zero at every index, the application of `DFinsupp.comapDomain' h hh' f` at any `k` in `κ` is equal to the application of `f` at `h k`. In other words, after applying the function `comapDomain'`, which modifies `f` by changing its domain using the function `h`, the value at any point `k` is the same as the original function `f` evaluated at `h k`.

For any function `h: κ → ι`, its left inverse `h'`, and function `f: ι → β` that is zero at every index, `DFinsupp.comapDomain' h h' f k = f (h k)` for all `κ` elements `k`.


theorem ENNReal.mul_rpow_of_nonneg : ∀ (x y : ENNReal) {z : ℝ}, 0 ≤ z → (x * y) ^ z = x ^ z * y ^ z := by sorry

This theorem states that for all extended nonnegative real numbers 'x' and 'y', and for any real number 'z' that is nonnegative (i.e., 'z' is greater than or equal to zero), the power of the product 'x * y' raised to 'z' is equal to the product of 'x' raised to 'z' and 'y' raised to 'z'. In mathematical notation, this is saying that $(x * y) ^ z = x ^ z * y ^ z$ for $x, y \in [0, \infty]$ and $z \in \mathbb{R}$ with $z \geq 0$. This theorem is a key property of exponents in the context of extended nonnegative real numbers.

For all extended nonnegative real numbers x, y, and nonnegative real number z, $(x * y) ^ z = x ^ z \cdot y ^ z$.


theorem iInf_const :
    ∀ {α : Type u_1} {ι : Sort u_5} [inst : CompleteLattice α] {a : α} [inst_1 : Nonempty ι], ⨅ x, a = a := by sorry

This theorem states that for any type `α` that forms a complete lattice, and any value `a` of this type, the infimum of `a` over all elements `x` is just `a` itself. This holds for all nonempty types `ι`. This theorem basically says that the infimum of a constant is the constant itself, which is a standard property of infimum in lattice theory.

For any complete lattice type `α` and constant `a` in `α`, the infimum of `a` over `α` is `a` itself.


theorem Asymptotics.isBigO_const_const :
    ∀ {α : Type u_1} {E : Type u_3} {F'' : Type u_10} [inst : Norm E] [inst_1 : NormedAddCommGroup F''] (c : E)
      {c' : F''}, c' ≠ 0 → ∀ (l : Filter α), (fun _x => c) =O[l] fun _x => c' :=
  by sorry

This theorem, `Asymptotics.isBigO_const_const`, states that for any types `α`, `E`, and `F''`, where `E` and `F''` are normed, for any `E`-type constant `c`, `F''`-type constant `c'` (which is not zero), and any filter `l` of type `α`, the function that always returns `c` is Big O of the function that always returns `c'`. In other words, the growth rate of a constant function is bounded above by the growth rate of another non-zero constant function, regardless of the input type or the filter used.

For any types `α`, `E`, and `F''`, and non-zero constants `c` of type `E` and `c'` of type `F''`, the constant function `λx:α => c` is Big O of the constant function `λx:α => c'`.


Equiv.Perm.SameCycle.symm

theorem Equiv.Perm.SameCycle.symm :
    ∀ {α : Type u_2} {f : Equiv.Perm α} {x y : α}, Equiv.Perm.SameCycle f x y → Equiv.Perm.SameCycle f y x := by sorry

The theorem `Equiv.Perm.SameCycle.symm` states that for any type `α` and any permutation `f` of type `α`, if two elements `x` and `y` of type `α` are in the same cycle of the permutation `f` (i.e., `Equiv.Perm.SameCycle f x y` is true), then `y` and `x` are also in the same cycle of the permutation `f` (i.e., `Equiv.Perm.SameCycle f y x` is true). In other words, the relation "being in the same cycle of a permutation" is symmetric.

For any type `α` and permutation `f` of type `α`, if `x` and `y` are in the same cycle of `f`, then `y` and `x` are also in the same cycle of `f`. (i.e., `Equiv.Perm.SameCycle f x y` implies `Equiv.Perm.SameCycle f y x`)


theorem MeasureTheory.integrableOn_univ :
    ∀ {α : Type u_1} {E : Type u_3} [inst : MeasurableSpace α] [inst_1 : NormedAddCommGroup E] {f : α → E}
      {μ : MeasureTheory.Measure α}, MeasureTheory.IntegrableOn f Set.univ μ ↔ MeasureTheory.Integrable f μ :=
  by sorry

The theorem `MeasureTheory.integrableOn_univ` states that for any measure space `α`, any normed additive commutative group `E`, any function `f` from `α` to `E`, and any measure `μ` on `α`, the function `f` is integrable across the entire set of `α` (represented as `Set.univ`) with respect to the measure `μ` if and only if `f` is integrable with respect to `μ`. In simpler terms, a function is integrable over the whole space if and only if it is integrable when considered on any subset of the space. This is in line with the definition of integrability that requires the function to be almost everywhere strongly measurable and that the integral of its pointwise norm over the considered set is finite.

For any measure space, normed additive commutative group, function, and measure, a function is integrable with respect to the measure over the entire space if and only if it is integrable on every subset of the space.


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

This theorem, `lt_of_smul_lt_smul_left`, states that for any types `α` and `β`, given elements `a` of type `α` and `b₁`, `b₂` of type `β`, and provided that `α` and `β` are preordered, `α` has a zero element, and the operation of scalar multiplication reflects the "less than" relation, if `a` times `b₁` is less than `a` times `b₂` and `a` is non-negative, then `b₁` is less than `b₂`. In other words, in the given conditions, if scaling `b₁` by `a` results in a value less than scaling `b₂` by `a`, then `b₁` must be less than `b₂`.

If `α` is a preordered type with a zero element and scalar multiplication is order-preserving, then for all `a ∈ α` non-negative and `b₁, b₂ ∈ β`, if `a * b₁` < `a * b₂`, then `b₁` < `b₂`.


theorem CategoryTheory.NonPreadditiveAbelian.add_def :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.NonPreadditiveAbelian C] {X Y : C}
      (a b : X ⟶ Y), a + b = a - -b :=
  by sorry

This theorem states that in the context of a nonpreadditive Abelian category `C`, for any two morphisms `a` and `b` from object `X` to object `Y`, the sum of `a` and `b` is equal to the difference of `a` and the additive inverse of `b`. This is a mathematical theorem related to category theory, which deals with abstract structures in mathematics.

In a nonpreadditive Abelian category, for any two morphisms `a` and `b` from object `X` to object `Y`, `a + b = a - (-b)`.


theorem Cardinal.lift_zero : Cardinal.lift.{u_2, u_1} 0 = 0 := by sorry

This theorem states that the cardinality of the empty set remains zero even after the universe lift operation. In other words, when the universe lift operation, denoted by `Cardinal.lift`, is applied to the cardinal number `0` (which represents the cardinality of the empty set), the resulting cardinal number in a potentially higher universe is still `0`.

The cardinality of the empty set is zero in all universes.


theorem List.indexOf_get :
    ∀ {α : Type u} [inst : DecidableEq α] {a : α} {l : List α} (h : List.indexOf a l < List.length l),
      List.get l { val := List.indexOf a l, isLt := h } = a :=
  by sorry

This theorem, `List.indexOf_get`, states that for any type `α` with decidable equality and any element `a` of type `α` in a list `l` of elements of type `α`, if the index of `a` in the list `l` is less than the length of the list `l`, then getting the element at the index of `a` in the list `l` returns `a`. In other words, if `a` is present in `l`, then the element at the position returned by the `indexOf` function is `a` itself.

For any type `α` with decidable equality and any list `l` of length `n` and element `a` in `α` present at index `i` in `l` with `i < n`, we have `l.get i = a`.


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

The theorem `Polynomial.map_comp` states that for any semirings `R` and `S`, and a ring homomorphism `f` from `R` to `S`, and any polynomials `p` and `q` over `R`, the operation of mapping the composition of `p` and `q` across `f` is the same as the composition of the mappings of `p` and `q` across `f`. In mathematical terms, it asserts that for these given conditions, the operation of polynomial map commutes with the operation of polynomial composition.

For any semirings R and S, ring homomorphism f from R to S, and polynomials p and q over R, the mapping of the composition p q across f is equal to the composition of the mappings f(p) and f(q).


theorem Antitone.comp_monotone :
    ∀ {α : Type u} {β : Type v} {γ : Type w} [inst : Preorder α] [inst_1 : Preorder β] [inst_2 : Preorder γ] {g : β → γ}
      {f : α → β}, Antitone g → Monotone f → Antitone (g ∘ f) :=
  by sorry

This theorem states that for any three types `α`, `β`, and `γ` with preorders, if `g` is a function from `β` to `γ` that is antitone (meaning that if `a ≤ b` then `g(b) ≤ g(a)`) and `f` is a function from `α` to `β` that is monotone (meaning that if `a ≤ b` then `f(a) ≤ f(b)`), then the composition of `g` and `f` (effectively `g(f(x))`) is also an antitone function. In other words, composing an antitone function with a monotone function results in an antitone function.

If `f` is a monotone function from `α` to `β` and `g` is an antitone function from `β` to `γ`, then the composition `g ∘ f` is an antitone function from `α` to `γ`.


List.Sublist.brecOn

theorem List.Sublist.brecOn :
    ∀ {α : Type u_1} {motive : (a a_1 : List α) → List.Sublist a a_1 → Prop} {a a_1 : List α} (x : List.Sublist a a_1),
      (∀ (a a_2 : List α) (x : List.Sublist a a_2), List.Sublist.below x → motive a a_2 x) → motive a a_1 x :=
  by sorry

This is a theorem about recursively applying a motive (a predicate or property) to a pair of lists and a proof that the first list is a sublist of the second. Given a type `α`, a motive that applies to pairs of lists of `α` and a proof that one is a sublist of the other, and specific lists `a` and `a_1` with a proof `x` that `a` is a sublist of `a_1`, the theorem states that if the motive holds for any pair of lists and a sublist proof where the motive holds for all "smaller" sublists, then the motive holds for `a` and `a_1` with the sublist proof `x`. This is essentially a principle of mathematical induction for the structure of sublists.

If a motive holds for all pairs of sublists and their sublist proofs, then it holds for a given sublist `a` of a larger list `a_1` with their corresponding sublist proof `x`.


/-- The edist to a set and to its closure coincide  -/
theorem EMetric.infEdist_closure :
    ∀ {α : Type u} [inst : PseudoEMetricSpace α] {x : α} {s : Set α},
      EMetric.infEdist x (closure s) = EMetric.infEdist x s :=
  by sorry

This theorem states that for any pseudometric space `α` and any set `s` of elements from `α`, the infimum extended distance (infimum of all the distances) of a point `x` from `α` to the closure of `s` is equal to the infimum extended distance of the point `x` to the set `s` itself. In other words, the minimum possible extended distance from any point to a set and its closure (the smallest closed set containing the original set) are the same.

For any pseudometric space `α` and point `x` in `α`, the infimum of the extended distances from `x` to `s` and `x` to the closure of `s` is equal.


theorem Set.Iic_inter_Iic :
    ∀ {α : Type u_1} [inst : SemilatticeInf α] {a b : α}, Set.Iic a ∩ Set.Iic b = Set.Iic (a ⊓ b) := by sorry

The theorem `Set.Iic_inter_Iic` states that for any type `α` with an instance of `SemilatticeInf` (which means `α` has a binary operation "meet" or "infimum"), and for any elements `a` and `b` of type `α`, the intersection of the set of elements less than or equal to `a` (`Set.Iic a`) and the set of elements less than or equal to `b` (`Set.Iic b`) is equal to the set of elements less than or equal to the infimum of `a` and `b` (`Set.Iic (a ⊓ b)`). In other words, the common set of elements that are less than or equal to both `a` and `b` is exactly the set of elements that are less than or equal to their infimum.

For any semilattice type `α` and elements `a` and `b` of `α`, `Set.Iic a ∩ Set.Iic b = Set.Iic (a ⊓ b)`.


theorem Polynomial.coeff_mul_X_pow :
    ∀ {R : Type u} [inst : Semiring R] (p : Polynomial R) (n d : ℕ),
      Polynomial.coeff (p * Polynomial.X ^ n) (d + n) = Polynomial.coeff p d :=
  by sorry

The theorem `Polynomial.coeff_mul_X_pow` states that for any semiring `R`, given a polynomial `p` over `R`, and any natural numbers `n` and `d`, the coefficient of the term with degree `d + n` in the polynomial obtained by multiplying `p` with `X^n` (where `X` is the polynomial variable) is equal to the coefficient of the term with degree `d` in `p`. In other words, multiplying a polynomial by `X^n` simply shifts the coefficients `n` places to the right.

For any polynomial `p` over a semiring `R` and natural numbers `d` and `n`, the coefficient of the term with degree `d+n` in `p * X^n` equals the coefficient of the term with degree `d` in `p`.


IsIntegralClosure.isIntegral

theorem IsIntegralClosure.isIntegral :
    ∀ (R : Type u_1) {A : Type u_2} (B : Type u_3) [inst : CommRing R] [inst_1 : CommRing A] [inst_2 : CommRing B]
      [inst_3 : Algebra R B] [inst_4 : Algebra A B] [inst_5 : IsIntegralClosure A R B] [inst_6 : Algebra R A]
      [inst_7 : IsScalarTower R A B] (x : A), IsIntegral R x :=
  by sorry

The theorem `IsIntegralClosure.isIntegral` states that for any type `R` which is a commutative ring, any type `A` which is a commutative ring, and any type `B` which is a commutative ring, if `A` is an integral closure of `R` in `B`, then for every element `x` of type `A`, `x` is integral over `R`. This means that `x` is a root of some monic polynomial with coefficients in `R`. The structures `[inst_3 : Algebra R B]`, `[inst_4 : Algebra A B]`, `[inst_6 : Algebra R A]` and `[inst_7 : IsScalarTower R A B]` ensure the algebraic structure needed to define integral elements and the integral closure.

If `A` is the integral closure of `R` in `B`, then every element `x` in `A` is integral over `R`.


theorem AddGroupFilterBasis.nhds_zero_hasBasis :
    ∀ {G : Type u} [inst : AddGroup G] (B : AddGroupFilterBasis G), Filter.HasBasis (nhds 0) (fun V => V ∈ B) id := by
  sorry

This theorem states that for any given additive group `G` and any `AddGroupFilterBasis` `B` of `G`, the neighborhood filter at `0` (denoted by `nhds 0`) in `G` has a certain basis. The basis consists of those sets that belong to `B`, each of which is mapped to itself by the identity function (`id`). In the context of topology, having such a basis means that every neighborhood of `0` in the topological space `G` can be represented as a "filter union" of these basis sets.

For any additive group `G` and `AddGroupFilterBasis` `B` of `G`, the neighborhood filter at `0` in `G` has `B` as a basis, where a basis element is a set in `B` that maps to itself under the identity function.


theorem Complex.neg_pi_lt_arg : ∀ (x : ℂ), -Real.pi < Complex.arg x := by sorry

This theorem states that for every complex number `x`, the argument of `x` (denoted as `Complex.arg x` in Lean) is strictly greater than negative pi (`-Real.pi`). In other words, the angle made by the line connecting the origin and the point representing the complex number on the complex plane with the positive real axis, measured in radians, is always more than `-π` radians. The measurement of this angle is done in a counter-clockwise direction and revolves between `-π` and `π`.

For every complex number `x`, the argument of `x` is strictly greater than `-π` radians.


theorem Basis.coe_reindex :
    ∀ {ι : Type u_1} {ι' : Type u_2} {R : Type u_3} {M : Type u_6} [inst : Semiring R] [inst_1 : AddCommMonoid M]
      [inst_2 : Module R M] (b : Basis ι R M) (e : ι ≃ ι'), ⇑(Basis.reindex b e) = ⇑b ∘ ⇑e.symm :=
  by sorry

The theorem `Basis.coe_reindex` states that for any semiring `R`, additively commutative monoid `M`, and for any `R`-module structure on `M`, given a basis `b` indexed by type `ι` for the module and a bijective map `e` from `ι` to another type `ι'`, the function corresponding to the reindexing of basis `b` with `e` (`Basis.reindex b e`) is equivalent to the composition of the function corresponding to basis `b` and the inverse of the function corresponding to `e`. Essentially, reindexing a basis and then mapping an index is the same as first mapping the index with the inverse of the reindexing map and then applying the original basis map.

For any semiring `R`, additively commutative monoid `M` with an `R`-module structure, basis `b` indexed by `ι`, and bijective map `e` from `ι` to `ι'`, `Basis.reindex b e` equals the composition of `b` with the inverse of `e`.


theorem Ordinal.lt_one_iff_zero : ∀ {a : Ordinal.{u_3}}, a < 1 ↔ a = 0 := by sorry

The theorem `Ordinal.lt_one_iff_zero` states that for any ordinal `a` from the universe `u_3`, `a` is less than 1 if and only if `a` is exactly 0. In other words, in the context of ordinals, the only ordinal number that is less than 1 is 0 itself.

For any ordinal number `a`, `a` is less than 1 if and only if `a` equals 0.


theorem BoxIntegral.Prepartition.eq_of_mem_of_mem :
    ∀ {ι : Type u_1} {I J₁ J₂ : BoxIntegral.Box ι} (π : BoxIntegral.Prepartition I) {x : ι → ℝ},
      J₁ ∈ π → J₂ ∈ π → x ∈ J₁ → x ∈ J₂ → J₁ = J₂ :=
  by sorry

This theorem asserts that for any type `ι`, boxes `I`, `J₁`, and `J₂`, and a prepartition `π` of `I`, if `J₁` and `J₂` are both elements of `π` and a point `x` is in both `J₁` and `J₂`, then `J₁` and `J₂` must be the same. Essentially, this is stating that in a prepartition of a box, no point can belong to two distinct sub-boxes.

In a prepartition of a box, no point belongs to two distinct sub-boxes.


theorem Finset.eq_univ_iff_forall :
    ∀ {α : Type u_1} [inst : Fintype α] {s : Finset α}, s = Finset.univ ↔ ∀ (x : α), x ∈ s := by sorry

The theorem `Finset.eq_univ_iff_forall` states that for any type `α` which has a `Fintype` instance (i.e., `α` is a finite type), a `Finset` `s` of type `α` is equal to the universal `Finset` (finset of all elements of type `α`) if and only if every element of type `α` is contained in `s`. This theorem essentially captures the concept of a full or universal set in the context of finite sets.

For a finite type `α`, a `Finset` `s` of `α` is equal to the universal `Finset` on `α` if and only if every element of `α` is in `s`.


theorem ContinuousLinearMap.coe_injective :
    ∀ {R₁ : Type u_1} {R₂ : Type u_2} [inst : Semiring R₁] [inst_1 : Semiring R₂] {σ₁₂ : R₁ →+* R₂} {M₁ : Type u_4}
      [inst_2 : TopologicalSpace M₁] [inst_3 : AddCommMonoid M₁] {M₂ : Type u_6} [inst_4 : TopologicalSpace M₂]
      [inst_5 : AddCommMonoid M₂] [inst_6 : Module R₁ M₁] [inst_7 : Module R₂ M₂],
      Function.Injective ContinuousLinearMap.toLinearMap :=
  by sorry

The theorem `ContinuousLinearMap.coe_injective` states that for any two semirings `R₁` and `R₂`, a ring homomorphism `σ₁₂ : R₁ →+* R₂`, two types `M₁` and `M₂` with topological spaces and additive commutative monoid structures, and module structures over `R₁` and `R₂` respectively, the function `ContinuousLinearMap.toLinearMap`, which converts a continuous linear map to a linear map, is injective. In other words, if two continuous linear maps are mapped to the same linear map by `ContinuousLinearMap.toLinearMap`, those two continuous linear maps must have been the same to start with.

Given semirings `R₁` and `R₂`, ring homomorphisms `σ₁₂ : R₁ →+* R₂`, and topological vector spaces `M₁` and `M₂` with additive commutative monoid structures and module structures over `R₁` and `R₂` respectively, the function `ContinuousLinearMap.toLinearMap` mapping continuous linear maps from `M₁` to `M₂` to their underlying linear maps is injective.


theorem le_iInf_iff :
    ∀ {α : Type u_1} {ι : Sort u_5} [inst : CompleteLattice α] {f : ι → α} {a : α}, a ≤ iInf f ↔ ∀ (i : ι), a ≤ f i :=
  by sorry

This theorem states that for any type `α` that forms a complete lattice, any function `f` from an arbitrary type `ι` to `α`, and any value `a` of type `α`, the value `a` is less than or equal to the infimum of the value set produced by `f` if and only if `a` is less than or equal to the value produced by `f` for every possible input `i` of type `ι`. In other words, `a` is smaller or equal to the smallest value in the image of `f` if and only if `a` is smaller or equal to every value in the image of `f`.

For any complete lattice `α`, function `f` from type `ι` to `α`, and value `a` in `α`, `a ≤ inf (map f) a ↔ ∀ i, a ≤ (f i)`.


theorem Mathlib.Order.MinMax._auxLemma.5 :
    ∀ {α : Type u} [inst : LinearOrder α] {a b c : α}, (a < min b c) = (a < b ∧ a < c) := by sorry

This theorem states that for any type `α` that has a linear order, and for any three instances `a`, `b`, and `c` of this type, the statement `a` is less than the minimum of `b` and `c` is equivalent to the conjunction of the statements `a` is less than `b` and `a` is less than `c`. In other words, in a linear order, a value is less than the minimum of two other values if and only if it is less than each of those values.

For any linear order type `α`, and elements `a`, `b`, `c` of type `α`, `a` is less than the minimum of `b` and `c` if and only if `a` is less than both `b` and `c`.


/-- Definition of `IsBigO` in terms of `IsBigOWith`. We record it in a lemma as `IsBigO` is
irreducible.  -/
theorem Asymptotics.isBigO_iff_isBigOWith :
    ∀ {α : Type u_1} {E : Type u_3} {F : Type u_4} [inst : Norm E] [inst_1 : Norm F] {f : α → E} {g : α → F}
      {l : Filter α}, f =O[l] g ↔ ∃ c, Asymptotics.IsBigOWith c l f g :=
  by sorry

The theorem `Asymptotics.isBigO_iff_isBigOWith` states that, given two functions `f` and `g` mapping from a type `α` to normed types `E` and `F` respectively, and a filter `l` on `α`, `f` is of the same order of magnitude as `g` with respect to the filter `l` (denoted as `f =O[l] g`) if and only if there exists a real number `c` such that `f` is big O of `g` with a constant `c` concerning the filter `l`. In other words, the norm of `f` is eventually (at points in the filter `l`) bounded by `c` times the norm of `g`.

For functions `f : α -> E` and `g : α -> F` mapping from a type `α` to normed types `E` and `F` respectively, and a filter `l` on `α`, `f` is of the same order of magnitude as `g` with respect to `l` if and only if there exists a constant `c` such that the norm of `f` is bounded by `c` times the norm of `g` at points in the filter `l`.


/-- If `S` is a sub-`R`-algebra of `A` and `S` is finitely-generated as an `R`-module,
then all elements of `S` are integral over `R`.  -/
theorem IsIntegral.of_mem_of_fg :
    ∀ {R : Type u_1} [inst : CommRing R] {A : Type u_5} [inst_1 : Ring A] [inst_2 : Algebra R A] (S : Subalgebra R A),
      Submodule.FG (Subalgebra.toSubmodule S) → ∀ x ∈ S, IsIntegral R x :=
  by sorry

The theorem `IsIntegral.of_mem_of_fg` states that if `S` is a sub-algebra of an algebra `A` over a commutative ring `R`, and `S` is finitely generated as an `R`-module, then every element `x` of `S` is an integral element over `R`. In other words, for any `x` in `S`, there exists a monic polynomial `p` in `R[X]` such that `x` is a root of `p`. This is equivalent to saying that each element `x` in `S` is integral with respect to the induced `algebraMap` from `R` to `A`.

If `S` is a finitely generated sub-algebra of a commutative ring `R` and an `R`-algebra `A`, then every element in `S` is integral over `R`.


theorem Set.image_univ_of_surjective :
    ∀ {β : Type u_2} {ι : Type u_6} {f : ι → β}, Function.Surjective f → f '' Set.univ = Set.univ := by sorry

The theorem `Set.image_univ_of_surjective` states that for all types `β` and `ι`, and for any function `f` from `ι` to `β`, if `f` is surjective (i.e., each element `b` in `β` is the image of at least one element `a` in `ι` under the function `f`), then the image of the universal set of `ι` under `f` is the universal set of `β`. In other words, applying a surjective function to every element in the universal set of the domain results in the universal set of the codomain. This captures the idea that a surjective function "covers" every element of its target space.

If `f : ι → β` is a surjective function, then `image f (univ ι) = univ β`.


theorem Mathlib.Combinatorics.SimpleGraph.Basic._auxLemma.37 :
    ∀ {V : Type u} {v w : V} (s : Set (Sym2 V)), (SimpleGraph.fromEdgeSet s).Adj v w = (s(v, w) ∈ s ∧ v ≠ w) := by sorry

The theorem, named `Mathlib.Combinatorics.SimpleGraph.Basic._auxLemma.37`, states that for any type `V`, any two elements `v` and `w` of type `V`, and any set `s` of unordered pairs from `V`, the adjacency relation in the `SimpleGraph` constructed from the edge set `s` between `v` and `w` is equivalent to the condition that the unordered pair consisting of `v` and `w` is an element of the set `s` and `v` is not equal to `w`. In other words, two vertices `v` and `w` are adjacent in the simple graph derived from the edge set `s` if and only if they form an edge in `s` and they are distinct.

In a simple graph with vertex set V and edge set S, vertices v and w are adjacent if and only if {v, w} ∈ S and v ≠ w.


theorem Matrix.SpecialLinearGroup.det_coe :
    ∀ {n : Type u} [inst : DecidableEq n] [inst_1 : Fintype n] {R : Type v} [inst_2 : CommRing R]
      (A : Matrix.SpecialLinearGroup n R), Matrix.det ↑A = 1 :=
  by sorry

The theorem `Matrix.SpecialLinearGroup.det_coe` states that for any type `n` with decidable equality and finite number of elements, and any `R` which forms a commutative ring, a matrix `A` from the special linear group of `n by n` matrices with entries from `R` will always have a determinant equal to 1, i.e., if we take the determinant of the underlying matrix of `A` (obtained by the coercion `↑A`), it will always equal 1. This is in accordance with the definition of the special linear group, which is the group of `n by n` matrices with determinant 1.

For any commutative ring R and finite type n with decidable equality, the determinant of every special linear group element (n by n matrix with entries from R and determinant 1) is equal to 1.


theorem Measurable.const_add :
    ∀ {M : Type u_2} {α : Type u_3} [inst : MeasurableSpace M] [inst_1 : Add M] {m : MeasurableSpace α} {f : α → M}
      [inst_2 : MeasurableAdd M], Measurable f → ∀ (c : M), Measurable fun x => c + f x :=
  by sorry

The theorem `Measurable.const_add` states that for any type `M` with a `MeasurableSpace` structure and an `Add` operation, and any type `α` with a `MeasurableSpace` structure, if we have a function `f` from `α` to `M` that is measurable, and `M` has a `MeasurableAdd` structure, then for every constant `c` from `M`, the function that adds `c` to `f(x)` for every `x` in `α` is also measurable. In terms of measure theory, this means that the function obtained by adding a fixed constant to a measurable function is itself measurable.

If `f` is a measurable function from a measurable space `(α, Σα)` to a measurable space `(M, ΣM)` with additive structure and `c` is a constant in `M`, then the function `x ↦ f(x) + c` is measurable.


theorem MvPolynomial.coeff_C :
    ∀ {R : Type u} {σ : Type u_1} [inst : CommSemiring R] [inst_1 : DecidableEq σ] (m : σ →₀ ℕ) (a : R),
      MvPolynomial.coeff m (MvPolynomial.C a) = if 0 = m then a else 0 :=
  by sorry

The theorem `MvPolynomial.coeff_C` states that for any commutative semiring `R`, any type `σ` with decidable equality, any multivariate monomial `m` in `σ`, and any element `a` of `R`, the coefficient of the monomial `m` in the constant multivariate polynomial `C a` is `a` if `m` is zero, and `0` otherwise. In other words, the constant multivariate polynomial `C a` has coefficient `a` for the zero monomial and coefficient `0` for all other monomials.

For any commutative semiring R, multivariate monomial m, and element a in R, the constant multivariate polynomial C a has coefficient a for the zero monomial m and coefficient 0 for all other monomials.


theorem Complex.abs_cpow_eq_rpow_re_of_pos : ∀ {x : ℝ}, 0 < x → ∀ (y : ℂ), Complex.abs (↑x ^ y) = x ^ y.re := by sorry

This theorem states that for a given real number `x` that is greater than zero, and for any complex number `y`, the absolute value of `x` raised to the power of `y` in the complex number system (i.e., `x` as a complex number) is equal to `x` raised to the real part of `y` in the standard real number calculus. This theorem establishes a connection between complex exponentiation and real exponentiation when the base is a positive real number.

For any complex number `y` and positive real number `x`, |x^(Re(y))| = |x|^(Re(y)), where |.| denotes the absolute value in the complex number system.


theorem Polynomial.comp_assoc :
    ∀ {R : Type u_1} [inst : CommSemiring R] (φ ψ χ : Polynomial R),
      Polynomial.comp (Polynomial.comp φ ψ) χ = Polynomial.comp φ (Polynomial.comp ψ χ) :=
  by sorry

The theorem `Polynomial.comp_assoc` states that for any commutative semiring `R` and any three polynomials `φ`, `ψ`, and `χ` over `R`, the composition of the polynomials is associative. That is, composing `φ` with the result of composing `ψ` and `χ` is the same as composing the result of composing `φ` and `ψ` with `χ`. This is symbolically represented as `(φ ∘ ψ) ∘ χ = φ ∘ (ψ ∘ χ)`, where `∘` denotes the composition of polynomials.

For any commutative semiring R and polynomials φ, ψ, and χ over R, the association of polynomial compositions holds: (φ ∘ (ψ ∘ χ)) = (ϕ ∘ ψ) ∘ χ.


theorem UniqueFactorizationMonoid.exists_prime_factors :
    ∀ {α : Type u_1} [inst : CancelCommMonoidWithZero α] [inst_1 : UniqueFactorizationMonoid α] (a : α),
      a ≠ 0 → ∃ f, (∀ b ∈ f, Prime b) ∧ Associated (Multiset.prod f) a :=
  by sorry

This theorem states that for any non-zero element `a` in a `CancelCommMonoidWithZero` α that also has a `UniqueFactorizationMonoid` structure, there exists a multiset `f` such that every element `b` in `f` is prime, and the product of all elements in `f` is associated with `a`. In other words, any non-zero element in a unique factorization domain can be factored into a product of prime elements.

In a CancelCommMonoidWithZero α equipped with a UniqueFactorizationMonoid structure, any non-zero element can be expressed as the product of a multiset of prime elements.


theorem Mathlib.Data.Set.Prod._auxLemma.46 :
    ∀ {α : Type u_1} {s : Set α}, Set.Nonempty (Set.offDiag s) = Set.Nontrivial s := by sorry

This theorem states that for any type `α` and a set `s` of type `α`, the property that the off-diagonal of set `s` is nonempty is equivalent to the property that the set `s` is nontrivial. In mathematical terms, a set is nonempty if it contains at least one element, and it is nontrivial if it contains at least two distinct elements. The "off-diagonal" of a set refers to the set of all pairs `(a, b)` where `a` and `b` are elements of the set and `a` is not equal to `b`. Therefore, the theorem is saying that the set `s` has at least two distinct elements if and only if there exist two elements in `s` that are not equal to each other.

A set is nonempty and has at least two distinct elements if and only if its off-diagonal is nonempty.


SimpleGraph.ConnectedComponent.ind

theorem SimpleGraph.ConnectedComponent.ind :
    ∀ {V : Type u} {G : SimpleGraph V} {β : SimpleGraph.ConnectedComponent G → Prop},
      (∀ (v : V), β (SimpleGraph.connectedComponentMk G v)) → ∀ (c : SimpleGraph.ConnectedComponent G), β c :=
  by sorry

The theorem `SimpleGraph.ConnectedComponent.ind` states that for any type `V`, any simple graph `G` of this type, and any property `β` that applies to the connected components of `G`, if every vertex `v` in the graph `G` satisfies the property `β` when we consider its connected component (obtained via `SimpleGraph.connectedComponentMk G v`), then this property `β` holds for every connected component `c` of the graph `G`. In other words, this theorem is a form of induction principle for connected components of a graph, stating that if a property holds for every connected component containing a single vertex, then it holds for all connected components.

If every vertex in a simple graph's connected component has property β, then every connected component of the graph has property β.


theorem MeasureTheory.OuterMeasure.le_ofFunction :
    ∀ {α : Type u_1} {m : Set α → ENNReal} {m_empty : m ∅ = 0} {μ : MeasureTheory.OuterMeasure α},
      μ ≤ MeasureTheory.OuterMeasure.ofFunction m m_empty ↔ ∀ (s : Set α), ↑μ s ≤ m s :=
  by sorry

The theorem `MeasureTheory.OuterMeasure.le_ofFunction` states that for any type `α`, any function `m` that maps sets of `α` to extended nonnegative real numbers (with the condition that `m` of the empty set equals zero), and any outer measure `μ` on `α`, `μ` is less than or equal to the outer measure derived by the function `m` if and only if for all sets of `α`, the value of `μ` on that set is less than or equal to the value of `m` on that set. In other words, it gives a condition for one outer measure to be less than or equal to another.

For any type α, outer measure μ, and function m mapping sets of α to extended nonnegative real numbers with m(∅) = 0, μ ≤ m if and only if μ(A) ≤ m(A) for all sets A of α.


theorem Quotient.ind₂ :
    ∀ {α : Sort uA} {β : Sort uB} {s₁ : Setoid α} {s₂ : Setoid β} {motive : Quotient s₁ → Quotient s₂ → Prop},
      (∀ (a : α) (b : β), motive ⟦a⟧ ⟦b⟧) → ∀ (q₁ : Quotient s₁) (q₂ : Quotient s₂), motive q₁ q₂ :=
  by sorry

The theorem `Quotient.ind₂` states that for any sorts `α` and `β` with setoids `s₁` and `s₂` respectively, and any property `motive` that relates two quotients, if this property holds for the equivalence classes of every pair of elements `(a, b)` from `α` and `β` respectively, then this property holds for every pair of quotients `(q₁, q₂)` from the respective quotient sets. Essentially, it allows you to prove a property about all pairs of elements in quotient sets by proving it for representatives of each equivalence class.

If `motive` holds for the equivalence classes of every pair of elements in the sets `α / s₁` and `β / s₂`, then `motive` holds for the quotients `q₁` and `q₂` in the respective quotient sets.


theorem HomologicalComplex.Hom.comm_assoc :
    ∀ {ι : Type u_1} {V : Type u} [inst : CategoryTheory.Category.{v, u} V]
      [inst_1 : CategoryTheory.Limits.HasZeroMorphisms V] {c : ComplexShape ι} {A B : HomologicalComplex V c}
      (f : HomologicalComplex.Hom A B) (i j : ι) {Z : V} (h : B.X j ⟶ Z),
      CategoryTheory.CategoryStruct.comp (f.f i) (CategoryTheory.CategoryStruct.comp (B.d i j) h) =
        CategoryTheory.CategoryStruct.comp (A.d i j) (CategoryTheory.CategoryStruct.comp (f.f j) h) :=
  by sorry

The theorem `HomologicalComplex.Hom.comm_assoc` states that for any type `ι`, any category `V` that has zero morphisms, any `ComplexShape` `c`, any two `HomologicalComplex` `A` and `B` over `V` and `c`, any `HomologicalComplex.Hom` `f` from `A` to `B`, any two elements `i` and `j` of `ι`, and any morphism `h` from `B.X j` to `Z` in `V`, the composition of `f.f i` with the composition of `B.d i j` and `h` is equal to the composition of `A.d i j` with the composition of `f.f j` and `h`.

In other words, this theorem is stating a form of the associativity of composition for morphisms in a homological complex in the context of category theory.

For any homological complexes A, B over a category V with zero morphisms and any morphism f: A → B, the composition of f with the chain map D (g, h) = g ∘ h between two consecutive complex maps g: B(i) → B(j) and h: B(j) → Z is equal to the chain map D (h, f) = h ∘ f between A(i) and Z: D(f, B.d(i,j) ∘ h) = D(h, f) ∘ A.d(i,j).


theorem le_of_forall_lt : ∀ {α : Type u} [inst : LinearOrder α] {a b : α}, (∀ c < a, c < b) → a ≤ b := by sorry

This theorem states that for any type `α` that has a linear order, given two elements `a` and `b` of type `α`, if it holds true that all elements `c` less than `a` are also less than `b`, then `a` must be less than or equal to `b`. In mathematical terms, this theorem essentially establishes that if all elements smaller than `a` are also smaller than `b`, then `a` cannot be greater than `b`, i.e., `a` is less than or equal to `b`.

If `α` is a type with a linear order and for all `c` in `α` with `c < a`, it follows that `c < b`, then `a <= b`.


theorem MeasureTheory.Measure.toSignedMeasure_apply_measurable :
    ∀ {α : Type u_1} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} [inst : MeasureTheory.IsFiniteMeasure μ]
      {i : Set α}, MeasurableSet i → ↑(MeasureTheory.Measure.toSignedMeasure μ) i = (↑↑μ i).toReal :=
  by sorry

The theorem `MeasureTheory.Measure.toSignedMeasure_apply_measurable` states that for any given measure space `α`, with a measurable set `i` within it and a finite measure `μ`, the value of the signed measure acquired by converting `μ` is equal to the real value of `μ` evaluated at `i`. This holds true if `i` is a measurable set. In other words, if we convert a finite measure into a signed measure, then for any measurable set in the measure space, the value of the signed measure at that set is the same as the real value of the original measure at that set.

For any measurable set `i` in a measure space and finite measure `μ`, the signed measure obtained from `μ` agrees with `μ` on `i`.


theorem PartENat.card_congr : ∀ {α : Type u_3} {β : Type u_4}, α ≃ β → PartENat.card α = PartENat.card β := by sorry

The theorem `PartENat.card_congr` states that for any two types `α` and `β`, if `α` is equivalent to `β` (denoted as `α ≃ β`), then the cardinality of `α` as an extended natural number (given by the function `PartENat.card α`) is equal to the cardinality of `β` as an extended natural number (`PartENat.card β`). In other words, if two types are equivalent, they have the same cardinality when measured as extended natural numbers, where the cardinality of an infinite set is represented by `⊤`.

If two types `α` and `β` are equivalent, then their cardinalities as extended natural numbers `PartENat.card α` and `PartENat.card β` are equal.


theorem Multiset.erase_cons_head :
    ∀ {α : Type u_1} [inst : DecidableEq α] (a : α) (s : Multiset α), Multiset.erase (a ::ₘ s) a = s := by sorry

The theorem `Multiset.erase_cons_head` states that for any type `α` with a decidable equality and any multiset `s` of type `α`, if an element `a` of type `α` is added to the front of the multiset `s` to form a new multiset, then removing `a` from this new multiset will return the original multiset `s`. This means that the `Multiset.erase` function will remove the first occurrence of an element from the multiset.

For any type `α` with decidable equality and any multiset `s` of type `α`, adding an element `a` to `s` and then erasing `a` results in `s`.


/-- The Radon-Nikodym derivative of `f ν` with respect to `ν` is `f`.  -/
theorem MeasureTheory.Measure.rnDeriv_withDensity :
    ∀ {α : Type u_1} {m : MeasurableSpace α} (ν : MeasureTheory.Measure α) [inst : MeasureTheory.SigmaFinite ν]
      {f : α → ENNReal}, Measurable f → (ν.withDensity f).rnDeriv ν =ᶠ[MeasureTheory.Measure.ae ν] f :=
  by sorry

The theorem `MeasureTheory.Measure.rnDeriv_withDensity` states that for any measurable space `α`, given a sigma-finite measure `ν` on `α` and a measurable function `f` from `α` to the extended nonnegative real numbers (ENNReal, which includes all nonnegative real numbers plus ∞), the Radon-Nikodym derivative of `f ν` (the measure obtained by applying `f` to `ν`) with respect to `ν` is almost everywhere equal to `f`. In other words, except on a set of measure zero, the derivative of the measure `f ν` with respect to the measure `ν` is the function `f` itself.

For any measurable space `α`, sigma-finite measure `ν` on `α`, and measurable function `f` from `α` to the extended nonnegative real numbers, the Radon-Nikodym derivative of `f ν` with respect to `ν` equals `f` almost everywhere.


/-- Taking a product over `s : Finset α` is the same as multiplying the value on a single element
`f a` by the product of `s.erase a`.

See `Multiset.prod_map_erase` for the `Multiset` version.  -/
theorem Finset.mul_prod_erase :
    ∀ {α : Type u_3} {β : Type u_4} [inst : CommMonoid β] [inst_1 : DecidableEq α] (s : Finset α) (f : α → β) {a : α},
      a ∈ s → (f a * Finset.prod (Finset.erase s a) fun x => f x) = Finset.prod s fun x => f x :=
  by sorry

This theorem states that in a commutative monoid `β`, for any finite set `s` of type `α` with decidable equality and any function `f` mapping `α` to `β`, and for any element `a` of `α` that is in `s`, the product of the function `f` over the entire set `s` is equal to the product of the function `f` on `a` multiplied by the product over the set `s` with `a` removed. In other words, multiplying an element of a set by the product of the rest of the elements in the set is equivalent to taking the product over the entire set. This is the finite set version of a similar property in multisets.

For any commutative monoid `β`, function `f` from a finite decidably equal set `s` of type `α` to `β`, and element `a` in `s`, we have `f (∑ i in s, a\_i) = f a * ∑ i in s, if i != a then f a\_i`.


theorem Mathlib.Topology.Basic._auxLemma.4 :
    ∀ {X : Type u} {s : Set X} [inst : TopologicalSpace X], IsOpen sᶜ = IsClosed s := by sorry

This theorem states that for any type `X` and a set `s` of this type, given that `X` has a topological space structure, the complement of `s` is open if and only if `s` is closed in this topological space. In mathematical terms, given a set `s` in a topological space `X`, the complement of `s` (denoted as `sᶜ`) is an open set if and only if the set `s` is a closed set in the topological space `X`.

In a topological space, a set and its complement are open if and only if each other is closed.


Trunc.eq

theorem Trunc.eq : ∀ {α : Sort u_1} (a b : Trunc α), a = b := by sorry

This theorem states that for any type `α`, and any two elements `a` and `b` of the type `Trunc α`, `a` is equal to `b`. Here, `Trunc α` is the quotient of `α` by the always-true relation, which effectively means that all elements in `Trunc α` are considered equal.

For any type `α`, all elements in the quotient `Trunc α` defined as the type of equivalence classes under the relation `r := ∀ (x y : α), true` are equal.


theorem le_compl_iff_disjoint_left : ∀ {α : Type u_2} [inst : HeytingAlgebra α] {a b : α}, a ≤ bᶜ ↔ Disjoint b a := by
  sorry

This theorem states that for any Heyting algebra `α` and any elements `a` and `b` of `α`, `a` is less than or equal to the complement of `b` if and only if `b` and `a` are disjoint. Here, two elements are said to be disjoint if, for any element `x` that is less than or equal to both `a` and `b`, `x` is also less than or equal to the bottom element of the order. The Heyting algebra is a type of lattice that is equipped with an additional operation called relative pseudocomplement, denoted as `ᶜ`.

For any Heyting algebra `α` and elements `a` and `b` of `α`, `a ≤ ᶜb` if and only if `a` and `b` are disjoint.


/-- **Uniqueness of left-invariant measures**: In a second-countable locally compact additive group,
any σ-finite left-invariant measure is a scalar multiple of the additive Haar measure.
This is slightly weaker than assuming that `μ` is a additive Haar measure (in particular we don't
require `μ ≠ 0`).
See also `isAddHaarMeasure_eq_smul_of_regular` for a statement not assuming second-countability. -/
theorem MeasureTheory.Measure.addHaarMeasure_unique :
    ∀ {G : Type u_1} [inst : AddGroup G] [inst_1 : TopologicalSpace G] [inst_2 : TopologicalAddGroup G]
      [inst_3 : MeasurableSpace G] [inst_4 : BorelSpace G] [inst_5 : SecondCountableTopology G]
      (μ : MeasureTheory.Measure G) [inst_6 : MeasureTheory.SigmaFinite μ]
      [inst_7 : MeasureTheory.Measure.IsAddLeftInvariant μ] (K₀ : TopologicalSpace.PositiveCompacts G),
      μ = ↑↑μ ↑K₀ • MeasureTheory.Measure.addHaarMeasure K₀ :=
  by sorry

This theorem, known as the "Uniqueness of Left-Invariant Measures," states that in a second-countable, locally compact additive group, any σ-finite left-invariant measure is a scalar multiple of the additive Haar measure. The theorem does not require the measure to be non-zero, making it slightly weaker than if we assume the measure to be an additive Haar measure. For a version of this theorem without the second-countability assumption, refer to `isAddHaarMeasure_eq_smul_of_regular`.

In a second-countable, locally compact additive group, any σ-finite left-invariant measure is equal to a scalar multiple of the additive Haar measure.


GroupCat.ext

theorem GroupCat.ext : ∀ {X Y : GroupCat} {f g : X ⟶ Y}, (∀ (x : ↑X), f x = g x) → f = g := by sorry

This theorem states that for any two group objects `X` and `Y` in the category of groups (denoted as `GroupCat`), and any two morphisms `f` and `g` from `X` to `Y`, if for every element `x` in `X` the morphisms `f` and `g` map `x` to the same element in `Y` (denoted by `f x = g x`), then the morphisms `f` and `g` are the same (denoted by `f = g`). In other words, two morphisms between the same two groups in the category of groups are equal if they agree on all elements of the domain group.

In the category of groups, two morphisms between the same groups are equal if and only if they map every element in their domain to the same element in the target group.


theorem Polynomial.degree_X :
    ∀ {R : Type u} [inst : Semiring R] [inst_1 : Nontrivial R], Polynomial.degree Polynomial.X = 1 := by sorry

The theorem `Polynomial.degree_X` states that for any instance of a semiring `R` that is nontrivial, the degree of the polynomial `Polynomial.X` is `1`. In this context, `Polynomial.X` is a polynomial variable and the degree of a polynomial is the highest power of the variable that appears in the polynomial. Thus, this theorem is essentially saying that the degree of the polynomial variable itself is `1`, which is consistent with the notion that `Polynomial.X` represents a polynomial of the form `x^1`.

For any nontrivial semiring R, the degree of the polynomial variable Polynomial.X is 1.


theorem Metric.comap_dist_right_atTop :
    ∀ {α : Type u} [inst : PseudoMetricSpace α] (c : α),
      Filter.comap (fun x => dist x c) Filter.atTop = Bornology.cobounded α :=
  by sorry

This theorem states that for any type `α` that is a pseudometric space, and for any element `c` of type `α`, the filter obtained by the function `comap` applied to the distance function from `c` (i.e., the function that takes `x` to the distance from `x` to `c`) and the filter representing the limit towards infinity (i.e., `Filter.atTop`), is equal to the filter of cobounded sets in the bornology of `α`. In other words, mapping the distance from a fixed point `c` to each point in the space `α` under the filter going to infinity results in the filter of all sets that are bounded away from `α`.

For any pseudometric space `α` and element `c` in `α`, the filter obtained by applying `comap` to the distance function from `c` and the filter at infinity is equal to the filter of cobounded sets in the bornology of `α`.


IsClosedMap.id

theorem IsClosedMap.id : ∀ {X : Type u_1} [inst : TopologicalSpace X], IsClosedMap id := by sorry

This theorem states that for any type `X` which has a topology `inst`, the identity function `id` is a closed map. In other words, if we consider any type `X` endowed with a topological structure, the identity function, which maps each element of `X` to itself, has the property that the image of any closed set under this function is also a closed set in `X`.

For any topological space (type `X` with topology `inst`), the identity function is a continuous map and thus preserves closed sets.


theorem Cardinal.inductionOn₂ :
    ∀ {p : Cardinal.{u_1} → Cardinal.{u_2} → Prop} (c₁ : Cardinal.{u_1}) (c₂ : Cardinal.{u_2}),
      (∀ (α : Type u_1) (β : Type u_2), p (Cardinal.mk α) (Cardinal.mk β)) → p c₁ c₂ :=
  by sorry

The theorem `Cardinal.inductionOn₂` is a principle of mathematical induction for two cardinal numbers. It states that for all properties `p`, defined on two cardinal numbers `c₁` and `c₂` in different type universes `u_1` and `u_2`, if the property `p` holds for all pairs of types `α` and `β` (where type `α` is in universe `u_1` and type `β` is in universe `u_2`, and the cardinal numbers of these types are `Cardinal.mk α` and `Cardinal.mk β` respectively), then the property `p` also holds for the cardinal numbers `c₁` and `c₂`.

If `p` is a property of cardinal numbers `Cardinal.mk α` and `Cardinal.mk β`, and `p` holds for all pairs of types `α` and `β` with cardinalities `α` and `β`, then `p` holds for the cardinal numbers `c₁` and `c₂` where `c₁ = Cardinal.mk α` and `c₂ = Cardinal.mk β`.


theorem Mathlib.Order.Filter.Basic._auxLemma.30 :
    ∀ {α : Type u} {ι : Sort x} {x : Set α} {f : ι → Filter α}, (x ∈ iSup f) = ∀ (i : ι), x ∈ f i := by sorry

This theorem establishes a property of the indexed supremum of a collection of filters. Specifically, it states that for any type `α`, any indexing set `ι`, any set `x` of type `α`, and any function `f` from `ι` to `Filter α`, the set `x` is in the indexed supremum of the collection `f` if and only if `x` is in every filter of that collection. In other words, the set `x` belongs to the supremum of the filters indexed by `ι` (i.e., `iSup f`) exactly when for each index `i` in `ι`, `x` is an element of the filter `f(i)`.

For any type `α`, indexing set `ι`, set `x` of type `α`, and function `f` from `ι` to `Filter α`, `x` belongs to the indexed supremum `iSup f` if and only if it is an element of every filter `f(i)` in the collection.


theorem Cardinal.toNat_mul : ∀ (x y : Cardinal.{u_1}), Cardinal.toNat (x * y) = Cardinal.toNat x * Cardinal.toNat y :=
  by sorry

This theorem states that for any two cardinal numbers, `x` and `y`, the cardinal-to-natural function applied to the product of `x` and `y` is equal to the product of the cardinal-to-natural function applied to `x` and the same function applied to `y`. In other words, the function `Cardinal.toNat` preserves multiplication between cardinal numbers. This matches the property of homomorphisms in algebra, where applying the operation (in this case, multiplication) after the function is the same as applying the function first and then the operation.

For any cardinal numbers `x` and `y`, `Cardinal.toNat (x * y) = Cardinal.toNat x * Cardinal.toNat y`.


theorem Subgroup.inv_mem_iff : ∀ {G : Type u_1} [inst : Group G] (H : Subgroup G) {x : G}, x⁻¹ ∈ H ↔ x ∈ H := by sorry

This theorem states that for any group `G` and a subgroup `H` of `G`, an element `x` of `G` is in `H` if and only if the inverse of `x` is in `H`. In other words, a subgroup of a group contains an element `x` if it also contains the inverse of that element `x⁻¹`, and vice versa. This is a property unique to subgroups in the field of group theory in mathematics.

For any group `G` and subgroup `H`, an element `x` belongs to `H` if and only if its inverse `x⁻¹` belongs to `H`.


theorem Set.disjoint_sdiff_right : ∀ {α : Type u} {s t : Set α}, Disjoint s (t \ s) := by sorry

This theorem states that for any type `α`, and any two sets `s` and `t` of this type, the set `s` and the difference set `t \ s` (i.e., the set of elements in `t` but not in `s`) are disjoint. "Disjoint" here is defined in the more general sense of lattice theory, which means that any element `x` that is less than or equal to both `s` and `t \ s` is also less than or equal to the bottom element of the lattice.

For any type `α` and sets `s` and `t` of this type, `s ∩ (t \ s) = ⊥`, where `∥` denotes the bottom element of the lattice.


theorem List.reverse_map :
    ∀ {α : Type u_1} {β : Type u_2} (f : α → β) (l : List α),
      List.reverse (List.map f l) = List.map f (List.reverse l) :=
  by sorry

The theorem `List.reverse_map` states that for all types `α` and `β`, and for any function `f` from `α` to `β`, and any list `l` of elements of type `α`, the reverse of the list obtained by mapping `f` over `l` is equal to the list obtained by first reversing `l` and then mapping `f` over the result. In other words, reversing a list after applying a function to its elements is the same as applying the function to the elements of the reversed list. This property can be described in mathematical notation as: for any function `f: α → β` and any list `l: List α`, we have `reverse(map(f, l)) = map(f, reverse(l))`.

For all types `α` and `β`, and for any function `f` from `α` to `β`, the application of `reverse` to the list obtained by mapping `f` over a list `l` is equal to the list obtained by reversing `l` and then mapping `f` over its elements. In mathematical notation: `reverse(map(f, l)) = map(f, reverse(l))`.


theorem Squarefree.ne_zero :
    ∀ {R : Type u_1} [inst : MonoidWithZero R] [inst_1 : Nontrivial R] {m : R}, Squarefree m → m ≠ 0 := by sorry

The theorem `Squarefree.ne_zero` states that for any type `R` which has instances of `MonoidWithZero` and `Nontrivial` (i.e. it is a monoid with a distinguished zero element and there exists at least one element that is not equal to zero), and any element `m` of `R`, if `m` is squarefree (which means that the only squares that can divide it are the squares of unit elements), then `m` cannot be equal to zero.

If `m` is a squarefree element in a monoid `R` with zero and at least one non-zero element, then `m` is distinct from zero.


theorem Fin.append_left :
    ∀ {m n : ℕ} {α : Type u_1} (u : Fin m → α) (v : Fin n → α) (i : Fin m), Fin.append u v (Fin.castAdd n i) = u i := by
  sorry

The theorem `Fin.append_left` states that for all natural numbers `m` and `n`, and for any type `α`, if you have two functions `u : Fin m → α` and `v : Fin n → α`, and an element `i` of `Fin m`, when you append `u` and `v` and apply it to the result of casting `i` with addition by `n` (i.e., `Fin.append u v (Fin.castAdd n i)`), the result is the same as directly applying `u` to `i` (i.e., `u i`). Essentially, it says that when you extend the domain of `u` and `v` to `Fin (m + n)`, the values of the extended function on the original domain of `u` are unchanged.

For all natural numbers m and n, and for any type α, the appended functions u : Fin m → α and v : Fin n → α satisfy u (Fin.castAdd n i) = Fin.append u v i for all i in Fin m.


theorem ContDiffWithinAt.mono_of_mem :
    ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {E : Type uE} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {F : Type uF} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {s : Set E}
      {f : E → F} {x : E} {n : ℕ∞},
      ContDiffWithinAt 𝕜 n f s x → ∀ {t : Set E}, s ∈ nhdsWithin x t → ContDiffWithinAt 𝕜 n f t x :=
  by sorry

This theorem states that for a non-trivially normed field '𝕜', two normed vector spaces E and F over '𝕜', a function 'f' from E to F, a set 's' of elements from E, a point 'x' in E, and a natural number or infinity 'n', if the function 'f' is continuously differentiable 'n' times within the set 's' at the point 'x', then for any other set 't' such that 's' is in the neighborhood of 'x' within 't', the function 'f' is also continuously differentiable 'n' times within the set 't' at the point 'x'. Essentially, if 'f' is continuously differentiable in a neighborhood of 'x', it remains continuously differentiable when the neighborhood is expanded, provided the original set is still close to 'x'.

If a continuously differentiable 'n' times function 'f' from one normed vector space to another over a non-trivially normed field has a neighborhood 's' of point 'x' where it is continuously differentiable 'n' times, then 'f' is continuously differentiable 'n' times at 'x' in any larger neighborhood 't' containing 's'.


theorem edist_eq_coe_nnnorm_sub : ∀ {E : Type u_6} [inst : SeminormedAddGroup E] (a b : E), edist a b = ↑‖a - b‖₊ := by
  sorry

This theorem states that for any seminormed add group `E` and any elements `a` and `b` of `E`, the extended distance between `a` and `b` is equal to the non-negative real number obtained by casting the non-negative norm of the difference between `a` and `b`. In the context of mathematics, this is stating that in any seminormed add group, the "distance" between two elements is precisely the norm of their difference.

In a seminormed add group, the distance between two elements is equal to the norm of their difference.


theorem Polynomial.degree_map_eq_of_leadingCoeff_ne_zero :
    ∀ {R : Type u} {S : Type v} [inst : Semiring R] {p : Polynomial R} [inst_1 : Semiring S] (f : R →+* S),
      f (Polynomial.leadingCoeff p) ≠ 0 → Polynomial.degree (Polynomial.map f p) = Polynomial.degree p :=
  by sorry

The theorem `Polynomial.degree_map_eq_of_leadingCoeff_ne_zero` states that for any semirings `R` and `S`, a polynomial `p` over `R`, and a ring homomorphism `f` from `R` to `S`, if the leading coefficient of `p` is not mapped to zero under `f`, then the degree of the polynomial obtained by mapping all coefficients of `p` through `f` (`Polynomial.map f p`) is equal to the degree of the original polynomial `p`. In simple terms, if the highest coefficient of a polynomial is not zeroed out when a function is applied to all the coefficients, then the degree of the polynomial remains the same.

If `f : R → S` is a ring homomorphism and the leading coefficient of polynomial `p` over semiring `R` is not mapped to zero under `f`, then the degree of `Polynomial.map f p` equals the degree of `p`.


theorem Int.ofNat_ediv : ∀ (m n : ℕ), ↑(m / n) = ↑m / ↑n := by sorry

This theorem states that for any two natural numbers `m` and `n`, the integer representation of the division of `m` by `n` (`↑(m / n)`) equals to the division of the integer representation of `m` and `n` (`↑m / ↑n`). In other words, converting the result of the division of two natural numbers to an integer gives the same result as individually converting these two natural numbers to integers and then performing the division.

For all natural numbers m and n, ⌊(m : ℕ) / n : ℕ⌋ = ⌊m:ℤ/⌈n:ℤ⌉⌋, where ℕ is the natural numbers, ℤ is the integers, and ⌋ and ⌈ denote the greatest integer function and the least integer function, respectively.


theorem List.nodup_iff_count_le_one :
    ∀ {α : Type u} [inst : DecidableEq α] {l : List α}, List.Nodup l ↔ ∀ (a : α), List.count a l ≤ 1 := by sorry

The theorem `List.nodup_iff_count_le_one` states that for any type `α` with a decidable equality and for any list `l` of type `α`, the property that the list `l` has no duplicates (signified by `List.Nodup l`) is equivalent to the condition that for every element `a` of type `α`, the count of `a` in the list `l` is less than or equal to one. This means that an element can appear at most once in the list if the list has no duplicates.

For any type `α` with decidable equality and any list `l` of type `α`, `List.Nodup l` if and only if for all `a` in `α`, the count of `a` in `l` is less than or equal to one.


theorem Real.sign_of_neg : ∀ {r : ℝ}, r < 0 → Real.sign r = -1 := by sorry

The theorem `Real.sign_of_neg` states that for all real numbers `r`, if `r` is less than zero, then the sign function of `r` is -1. In other words, this theorem shows that the sign function defined on the set of real numbers correctly assigns -1 to every negative real number.

For all real numbers `r`, if `r` is negative then `Real.sign r = -1`.


theorem CategoryTheory.Limits.zero_of_source_iso_zero :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroObject C]
      [inst_2 : CategoryTheory.Limits.HasZeroMorphisms C] {X Y : C} (f : X ⟶ Y), (X ≅ 0) → f = 0 :=
  by sorry

This theorem states that in any category `C` which has a zero object and zero morphisms, for any morphism `f` from object `X` to `Y`, if `X` is isomorphic to the zero object, then `f` is the zero morphism. In other words, any morphism whose source object is isomorphic to the zero object must itself be the zero morphism.

In any category with a zero object and zero morphisms, a morphism equals the zero morphism if and only if its source is isomorphic to the zero object.


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

This theorem states that for any type `α` and any two sets `s` and `t` of type `α`, the union of the difference of `s` and `t` and the intersection of `s` and `t` is equal to `s`. In other words, if we remove elements in `t` from `s` and add back elements that `s` and `t` have in common, we end up with the original set `s` itself. In mathematical terms, for any sets `s` and `t`, we have $s \setminus t \cup (s \cap t) = s$.

The theorem asserts that for any sets `s` and `t`, their intersection added to the difference of `s` and `t` equals `s`, that is, $s \setminus t \cup s \cap t = s$.


theorem Metric.tendsto_nhds :
    ∀ {α : Type u} {β : Type v} [inst : PseudoMetricSpace α] {f : Filter β} {u : β → α} {a : α},
      Filter.Tendsto u f (nhds a) ↔ ∀ ε > 0, ∀ᶠ (x : β) in f, dist (u x) a < ε :=
  by sorry

The theorem `Metric.tendsto_nhds` states that for any pseudometric space `α`, any filter `f` of type `β`, any function `u` from `β` to `α`, and any point `a` in `α`, the function `u` tends to the neighborhood filter of `a` (i.e. `u` approaches `a`) if and only if for all `ε > 0`, eventually (for all `x` in `f` beyond a certain point), the distance between `u(x)` and `a` is less than `ε`. In other words, `u(x)` gets arbitrarily close to `a` as `x` ranges over the elements of the filter `f`.

For any pseudometric space, filter, function, and point, a function tends to the neighborhood filter of a point if and only if the function values get arbitrarily close to that point for all filter elements beyond some point.


theorem Nat.coprime_list_prod_right_iff :
    ∀ {k : ℕ} {l : List ℕ}, Nat.Coprime k (List.prod l) ↔ ∀ n ∈ l, Nat.Coprime k n := by sorry

The theorem states that for any natural number 'k' and any list of natural numbers 'l', 'k' is coprime with the product of all the numbers in 'l' if and only if 'k' is coprime with every individual number 'n' in the list 'l'. In other words, 'k' shares no common divisors other than 1 with the product of the numbers in 'l' precisely when 'k' shares no common divisors other than 1 with each number in 'l'.

A natural number 'k' is coprime with the product of a list of natural numbers 'l' if and only if it is coprime with every number in the list.


theorem cfc_comp' :
    ∀ {R : Type u_1} {A : Type u_2} {p : A → Prop} [inst : CommSemiring R] [inst_1 : StarRing R]
      [inst_2 : MetricSpace R] [inst_3 : TopologicalSemiring R] [inst_4 : ContinuousStar R]
      [inst_5 : TopologicalSpace A] [inst_6 : Ring A] [inst_7 : StarRing A] [inst_8 : Algebra R A]
      [inst_9 : ContinuousFunctionalCalculus R p] [inst_10 : UniqueContinuousFunctionalCalculus R A] (g f : R → R)
      (a : A),
      autoParam (ContinuousOn g (f '' spectrum R a)) _auto✝ →
        autoParam (ContinuousOn f (spectrum R a)) _auto✝¹ →
          autoParam (p a) _auto✝² → cfc (fun x => g (f x)) a = cfc g (cfc f a) :=
  by sorry

This theorem states that for any given commutative semiring `R`, any `A` that is a `R`-algebra, and a predicate `p` on `A`, under certain conditions, the continuous functional calculus of the composition of two functions `g` and `f` at a point `a` is equal to the continuous functional calculus of `g` at the continuous functional calculus of `f` at `a`. The conditions required are that the function `g` is continuous on the image of the spectrum of `a` under `f`, the function `f` is continuous on the spectrum of `a`, and the predicate `p` holds true for `a`. This theorem encapsulates a property of the continuous functional calculus in the context of topological semirings and star rings.

For any commutative semiring `R`, `R-algebra `A`, function `f: A -> A` and `g: A -> A` with `g` continuous on the image of the spectrum of `a` under `f`, `f` continuous on the spectrum of `a`, and `p(a)` true, the functional calculus of `g(f(x))` is equal to `g(functional calculus of f(x) at a)` for all `x` satisfying `p(x)`.


theorem Option.mem_def : ∀ {α : Type u_1} {a : α} {b : Option α}, a ∈ b ↔ b = some a := by sorry

This theorem states that for any type `α` and any elements `a` of `α` and `b` of `Option α`, `a` is an element of `b` if and only if `b` is equal to `some a`. In other words, a value is contained in an Option value if and only if the Option value is `some` of that value. This is a fundamental property in Lean 4 pertaining to the concept of Option types, which are used to handle possible absence of a value.

For any type `α` and `a ∈ α`, `Option.some a = b` if and only if `a ∈ b` for `b : Option α`.


theorem List.singleton_append : ∀ {α : Type u_1} {x : α} {l : List α}, [x] ++ l = x :: l := by sorry

This theorem, `List.singleton_append`, states that for any type of object `α`, any object `x` of type `α`, and any list `l` of objects of type `α`, appending the list `l` to the singleton list that contains `x` (`[x] ++ l`) is equal to the list obtained by prepending `x` to `l` (`x :: l`). In other words, joining a list to a single-item list is the same as adding that item to the front of the list.

For any type `α` and objects `x` of type `α` and `l` of type `list α`, the singleton list `[x]` appended to list `l` is equal to the cons list `x :: l`.


theorem Polynomial.smul_eq_C_mul :
    ∀ {R : Type u} [inst : Semiring R] {p : Polynomial R} (a : R), a • p = Polynomial.C a * p := by sorry

This theorem states that for any semiring `R`, and for any polynomial `p` and element `a` from `R`, multiplying the polynomial `p` by the scalar `a` (denoted as `a • p`) is equivalent to multiplying the polynomial `p` by the constant polynomial created from `a` (denoted as `Polynomial.C a * p`). In other words, scalar multiplication on a polynomial is the same as the multiplication by the constant polynomial of the same scalar.

For any semiring `R`, and for all polynomials `p` in `R` and scalar `a` in `R`, the multiplication of `a` by polynomial `p` (denoted as `a • p`) is equal to the polynomial product of `p` and the constant polynomial `Polynomial.C a` (denoted as `Polynomial.C a * p`).


theorem ENNReal.rpow_nat_cast : ∀ (x : ENNReal) (n : ℕ), x ^ ↑n = x ^ n := by sorry

This theorem states that for every extended nonnegative real number `x` and for every natural number `n`, the power of `x` raised to the natural number `n` casted into an extended nonnegative real number is the same as `x` raised to the power of `n`. In mathematical terms, given `x` in the extended nonnegative real numbers (which we denote [0, ∞]) and `n` in the natural numbers, we have that x to the power of n casted into [0, ∞] is equal to x to the power of n.

For all extended nonnegative real numbers x and natural numbers n, x^n = (x^(n : real)) (where (x^(n : real)) denotes casting x^n into the extended nonnegative real numbers).


MeasureTheory.StronglyMeasurable.sub

theorem MeasureTheory.StronglyMeasurable.sub :
    ∀ {α : Type u_1} {β : Type u_2} {f g : α → β} {mα : MeasurableSpace α} [inst : TopologicalSpace β] [inst_1 : Sub β]
      [inst_2 : ContinuousSub β],
      MeasureTheory.StronglyMeasurable f →
        MeasureTheory.StronglyMeasurable g → MeasureTheory.StronglyMeasurable (f - g) :=
  by sorry

The theorem `MeasureTheory.StronglyMeasurable.sub` states that for any two functions `f` and `g` from a measurable space `α` to a topological space `β` that supports subtraction and has continuous subtraction, if both `f` and `g` are strongly measurable (i.e., each is a limit of simple functions), then their difference `f - g` is also strongly measurable.

If two functions from a measurable space to a topological space with continuous subtraction are strongly measurable, then their difference is also strongly measurable.


theorem Real.Gamma_pos_of_pos : ∀ {s : ℝ}, 0 < s → 0 < Real.Gamma s := by sorry

This theorem states that for all real numbers `s`, if `s` is greater than 0, then the real Gamma function of `s` is also greater than 0. Specifically, the Gamma function, denoted as `Real.Gamma`, is a function mapping from the set of real numbers to the set of real numbers and is defined as the real part of the Complex Gamma function evaluated at `s`.

For all real numbers `s` greater than 0, the real Gamma function `Real.Gamma s` is positive.


AffineEquiv.injective

theorem AffineEquiv.injective :
    ∀ {k : Type u_1} {P₁ : Type u_2} {P₂ : Type u_3} {V₁ : Type u_6} {V₂ : Type u_7} [inst : Ring k]
      [inst_1 : AddCommGroup V₁] [inst_2 : Module k V₁] [inst_3 : AddTorsor V₁ P₁] [inst_4 : AddCommGroup V₂]
      [inst_5 : Module k V₂] [inst_6 : AddTorsor V₂ P₂] (e : P₁ ≃ᵃ[k] P₂), Function.Injective ⇑e :=
  by sorry

The theorem `AffineEquiv.injective` states that for any ring `k`, types `P₁`, `P₂`, `V₁`, and `V₂`, given that `V₁` is an additive commutative group, `V₁` is a module over `k`, `P₁` is an additive torsor over `V₁`, `V₂` is an additive commutative group, `V₂` is a module over `k`, and `P₂` is an additive torsor over `V₂`, and given an affine equivalence `e` from `P₁` to `P₂`, the function `e` is injective. In other words, for any two elements `x` and `y` in `P₁`, if `e(x)` is equal to `e(y)`, then `x` is equal to `y`.

Given rings `k`, additive commutative groups `V₁` and `V₂`, modules over `k` `P₁` and `P₂`, additive torsors over `V₁` and `V₂` `P₁` and `P₂`, and an affine equivalence `e` from `P₁` to `P₂`, `e` is injective.


theorem Ordinal.add_sub_cancel : ∀ (a b : Ordinal.{u_4}), a + b - a = b := by sorry

In natural language, the theorem `Ordinal.add_sub_cancel` can be described as follows:

For any two ordinals `a` and `b`, the theorem states that if you add `a` and `b` together, and then subtract `a` from the result, you will be left with `b`. In other words, the operation of adding `a` to `b` and then subtracting `a` from the sum results in a no-op for `a`, essentially "cancelling" it out and leaving `b` unchanged. This property holds for all ordinals and is a fundamental property related to ordinal arithmetic.

For all ordinals `a` and `b`, `a + b = b + a`.


theorem SubMulAction.smul_mem :
    ∀ {R : Type u} {M : Type v} [inst : SMul R M] (p : SubMulAction R M) {x : M} (r : R), x ∈ p → r • x ∈ p := by sorry

This theorem states that for any scalar `r` of type `R` and any element `x` of type `M`, if `x` is an element of the SubMultiplicative Action `p`, then the result of scalar multiplication of `r` and `x` (notated as `r • x`) also belongs to `p`. In other words, if a scalar multiple of `x` is formed, it remains within the submultiplicative action `p`. Here, `R` and `M` are any types that support a scalar multiplication (`SMul R M`).

For any scalar `r` in `R` and any element `x` in the submultiplicative action `p` over `M`, the scalar multiplication `r • x` belongs to `p`.


Equiv.Perm.Disjoint.cycleType

theorem Equiv.Perm.Disjoint.cycleType :
    ∀ {α : Type u_1} [inst : Fintype α] [inst_1 : DecidableEq α] {σ τ : Equiv.Perm α},
      Equiv.Perm.Disjoint σ τ → Equiv.Perm.cycleType (σ * τ) = Equiv.Perm.cycleType σ + Equiv.Perm.cycleType τ :=
  by sorry

The theorem `Equiv.Perm.Disjoint.cycleType` states that for any finite type `α` equipped with a decidable equality and any two disjoint permutations `σ` and `τ` over `α`, the cycle type of the product of `σ` and `τ` is the sum of the cycle types of `σ` and `τ`. In other words, if `σ` and `τ` are permutations on `α` such that every element is fixed by either `σ` or `τ` but not both (i.e., they are disjoint), then the structure of cycles (as given by their lengths) in the permutation resulting from their composition (the action of `τ` followed by `σ`) is the same as the combined structures of the cycles in `σ` and `τ`.

For any finite type equipped with decidable equality, the cycle types of two disjoint permutations sum to the cycle type of their composition.


theorem ContinuousMap.coe_zsmul :
    ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] [inst_2 : AddGroup β]
      [inst_3 : TopologicalAddGroup β] (f : C(α, β)) (z : ℤ), ⇑(z • f) = z • ⇑f :=
  by sorry

This theorem states that for any two types `α` and `β`, where `α` is a topological space and `β` is both a topological space and an add group, then given a continuous map `f` from `α` to `β` and an integer `z`, the application of the `z`-multiple of the map `f` to any input is equal to `z` times the application of the `f` to that same input. This property holds if `β` also forms a topological add group.

Given a continuous map from a topological space to a topological add group, the map's multiplication by an integer preserves the operation, i.e., `(z * f)(x) = z * (f(x))` for all `x` in the topological space.


theorem Set.centralizer_eq_top_iff_subset :
    ∀ {M : Type u_1} {s : Set M} [inst : Semigroup M], Set.centralizer s = Set.univ ↔ s ⊆ Set.center M := by sorry

This theorem states that for any type `M`, any set `s` of type `M`, and any semigroup structure on `M`, the centralizer of `s` is equal to the universal set if and only if `s` is a subset of the center of `M`. Here, "centralizer" refers to the set of all elements in `M` that commute with every element in `s`, "universal set" refers to the set of all elements in `M`, and "center" refers to the set of all elements in `M` that commute with every other element in `M`. Essentially, the theorem states that all elements of `s` commute with all elements of `M` if and only if all elements of `s` are in the center of `M`.

The centralizer of a subset `s` of type `M` equals the universal set if and only if `s` is contained in the center of `M`.


theorem fderivWithin_zero_of_not_differentiableWithinAt :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {f : E → F}
      {x : E} {s : Set E}, ¬DifferentiableWithinAt 𝕜 f s x → fderivWithin 𝕜 f s x = 0 :=
  by sorry

This theorem states that if a function `f` is not differentiable at a point `x` within a set `s`, then the derivative of `f` within `s` at `x` is zero. Here, `𝕜` is a normed field, `E` and `F` are normed spaces over `𝕜`, and `f` is a function from `E` to `F`. Essentially, if we can't find a derivative for `f` at a certain point within a specific set, we assign the derivative at that point to be zero for convenience and mathematical consistency.

If a function `f` : `E` → `F` is not differentiable at a point `x` in a set `s` in the normed fields `𝕜` and `E`, then the derivative of `f` at `x` within `s` is the zero map from `E` to `F`.


theorem Polynomial.eval₂_zero :
    ∀ {R : Type u} {S : Type v} [inst : Semiring R] [inst_1 : Semiring S] (f : R →+* S) (x : S),
      Polynomial.eval₂ f x 0 = 0 :=
  by sorry

This theorem states that for any two types `R` and `S`, both equipped with a semiring structure, and a ring homomorphism `f` from `R` to `S`, and any value `x` of type `S`, evaluating the zero polynomial at `x` using ring homomorphism `f` results in zero in `S`. In other words, the evaluation of the zero polynomial under any ring homomorphism at any point is always zero.

For any semirings R and S, ring homomorphism f from R to S, and value x in S, the evaluation of the zero polynomial through f on x equals zero in S.


theorem Primrec.comp₂ :
    ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {σ : Type u_5} [inst : Primcodable α] [inst_1 : Primcodable β]
      [inst_2 : Primcodable γ] [inst_3 : Primcodable σ] {f : γ → σ} {g : α → β → γ},
      Primrec f → Primrec₂ g → Primrec₂ fun a b => f (g a b) :=
  by sorry

The theorem `Primrec.comp₂` states that for any types `α`, `β`, `γ`, and `σ` which are primcodable, if a function `f` from `γ` to `σ` is primitive recursive and a binary function `g` from `α` and `β` to `γ` is also primitive recursive, then the binary function that first applies `g` to its inputs and then `f` to the result is also primitive recursive. In mathematical terms, the composition of two primitive recursive functions is still a primitive recursive function.

If `f:` `γ` -> `σ` is primitive recursive and `g:` `α` x `β` -> `γ` is primitive recursive, then the composition `g` then `f:` `α` x `β` -> `σ` is primitive recursive.


theorem SetTheory.PGame.birthday_add :
    ∀ (x y : SetTheory.PGame),
      SetTheory.PGame.birthday (x + y) = Ordinal.nadd (SetTheory.PGame.birthday x) (SetTheory.PGame.birthday y) :=
  by sorry

This theorem states that for any two pre-games `x` and `y`, the "birthday" of their sum (`x + y`) is equal to the Hessenberg sum (or natural addition) of their individual birthdays. The birthday of a pre-game is conceptually the "step" in which the game is constructed, while the Hessenberg sum is a form of ordinal addition that is commutative and based on adding up corresponding coefficients in the Cantor normal forms of the ordinals.

For any pre-games x and y, the birthday of their sum (x + y) equals the Hessenberg sum of their individual birthdays.


theorem Mathlib.Data.Nat.Defs._auxLemma.6 : ∀ (n : ℕ), (1 < Nat.succ (Nat.succ n)) = True := by sorry

This theorem, from the Mathlib library in Lean 4, states that for any natural number `n`, adding 2 to `n` (i.e., `Nat.succ (Nat.succ n)`) results in a number that is greater than 1. In other words, for any natural number, its successor's successor is always greater than 1. The theorem is always true, regardless of the value of `n`.

For any natural number `n`, `Nat.succ (Nat.succ n)` is greater than 1.


theorem Mathlib.Data.Nat.Defs._auxLemma.1 : ∀ (n : ℕ), (n < 0) = False := by sorry

This theorem, `Mathlib.Data.Nat.Defs._auxLemma.1`, states that for any natural number `n`, the condition that `n` is less than zero is always `False`. In other words, it's asserting that no natural number can be less than zero. This aligns with the definition of natural numbers in mathematics, which includes all whole numbers from zero upwards.

For any natural number `n`, `n` is not less than zero.


theorem Real.closedBall_eq_Icc : ∀ {x r : ℝ}, Metric.closedBall x r = Set.Icc (x - r) (x + r) := by sorry

The theorem `Real.closedBall_eq_Icc` states that for any real numbers `x` and `r`, the closed ball centered at `x` with radius `r` in the real numbers, which is the set of all points `y` such that the distance between `y` and `x` is less than or equal to `r`, is equal to the closed interval from `x - r` to `x + r`. In mathematical terms, it asserts that for all real numbers `x` and `r`, we have `Metric.closedBall x r = [x - r, x + r]`.

The theorem `Real.closedBall_eq_Icc` asserts that for all real numbers `x` and `r`, the closed ball centered at `x` with radius `r` equals the closed interval `[x-r, x+r]` in the real numbers.


theorem Order.succ_le_iff_of_not_isMax :
    ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : SuccOrder α] {a b : α}, ¬IsMax a → (Order.succ a ≤ b ↔ a < b) := by
  sorry

The theorem `Order.succ_le_iff_of_not_isMax` states that for any preordered set `α` with a successor order, and any elements `a` and `b` in that set, if `a` is not a maximal element, then `Order.succ a ≤ b` if and only if `a < b`. In other words, the successor of `a` is less than or equal to `b` if and only if `a` itself is strictly less than `b`, given that `a` is not a maximal element in the set.

For any preordered set with a successor order and elements `a` and `b`, `Order.succ a ≤ b` if and only if `a < b` when `a` is not maximal.


theorem Filter.comap_bot : ∀ {α : Type u} {β : Type v} {m : α → β}, Filter.comap m ⊥ = ⊥ := by sorry

This theorem states that for any types `α` and `β`, and any function `m` mapping from `α` to `β`, the preimage filter of the bottom filter (the filter containing only the empty set) under the function `m` is also the bottom filter. In other words, when you take the preimage of the empty set through any function, you always get the empty set.

For any function `m` between types `α` and `β`, the preimage of the bottom filter under `m` is the bottom filter.


theorem map_ratCast :
    ∀ {F : Type u_1} {α : Type u_3} {β : Type u_4} [inst : FunLike F α β] [inst_1 : DivisionRing α]
      [inst_2 : DivisionRing β] [inst_3 : RingHomClass F α β] (f : F) (q : ℚ), f ↑q = ↑q :=
  by sorry

The theorem `map_ratCast` states that for any types `F`, `α`, and `β`, given an instance of `FunLike` from `α` to `β`, two instances of `DivisionRing` for `α` and `β`, and an instance of `RingHomClass` for `F` from `α` to `β`, for any function `f : F` and any rational number `q : ℚ`, the application of `f` to the cast of `q` to type `α` (denoted by `f ↑q`) is equal to the cast of `q` to type `β` (denoted by `↑q`). In other words, casting a rational number and then applying a function from a ring homomorphism class behaves the same as directly casting the rational to the target type.

For any types `α`, `β`, a `FunLike` map `F` from `α` to `β`, and instances of `DivisionRing` for `α` and `β` and `RingHomClass` for `F` from `α` to `β`, the application of `F` to the cast of a rational number `q` to type `α` is equal to the cast of `q` to type `β`, i.e., `F ↑q = ↑q`.


theorem CategoryTheory.BraidedCategory.braiding_naturality :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.MonoidalCategory C]
      [inst_2 : CategoryTheory.BraidedCategory C] {X X' Y Y' : C} (f : X ⟶ Y) (g : X' ⟶ Y'),
      CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategory.tensorHom f g) (β_ Y Y').hom =
        CategoryTheory.CategoryStruct.comp (β_ X X').hom (CategoryTheory.MonoidalCategory.tensorHom g f) :=
  by sorry

This theorem, `CategoryTheory.BraidedCategory.braiding_naturality`, states that in a braided category, the braiding (symbolized by `β`) behaves naturally with respect to morphisms. Specifically, given any category `C` which is also a monoidal and braided category and objects `X, X', Y, Y'` in `C`, for any morphisms `f: X ⟶ Y` and `g: X' ⟶ Y'`, the composition of morphisms denoted by `CategoryTheory.CategoryStruct.comp`, the tensor product of `f` and `g` followed by the braiding on `Y` and `Y'` is equal to the braiding on `X` and `X'` followed by the tensor product of `g` and `f`. The symbol `β_ Y Y'.hom` represents the braiding of `Y` and `Y'` while `β_ X X'.hom` represents the braiding of `X` and `X'`. The tensor product of morphisms is indicated by `CategoryTheory.MonoidalCategory.tensorHom`. This theorem captures one of the core properties of braiding in braided monoidal categories.

In a braided monoidal category, the braiding is natural with respect to morphisms, that is, for objects X, X', Y, Y' and morphisms f : X ⟶ Y and g : X' ⟶ Y', the composition of g ⊗ f and β\_Y Y'.hom is equal to β\_X X'.hom ⊗ f g.


theorem Nat.gcd_zero_left : ∀ (y : ℕ), Nat.gcd 0 y = y := by sorry

The theorem `Nat.gcd_zero_left` states that for any natural number `y`, the greatest common divisor of 0 and `y` is `y` itself. In other words, it formalizes the mathematical property $\gcd(0,y) = y$ for all natural numbers `y`.

The greatest common divisor of 0 and any natural number `y` equals `y`.


/-- A function is almost everywhere strongly measurable if and only if it is almost everywhere
measurable, and up to a zero measure set its range is contained in a separable set.  -/
theorem aestronglyMeasurable_iff_aemeasurable_separable :
    ∀ {α : Type u_1} {β : Type u_2} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} [inst : TopologicalSpace β]
      {f : α → β} [inst_1 : TopologicalSpace.PseudoMetrizableSpace β] [inst_2 : MeasurableSpace β]
      [inst_3 : BorelSpace β],
      MeasureTheory.AEStronglyMeasurable f μ ↔
        AEMeasurable f μ ∧ ∃ t, TopologicalSpace.IsSeparable t ∧ ∀ᵐ (x : α) ∂μ, f x ∈ t :=
  by sorry

The theorem `aestronglyMeasurable_iff_aemeasurable_separable` states that, for any function `f` from a measurable space `α` to a topological space `β` with respect to measure `μ`, the function is almost everywhere strongly measurable if and only if it is almost everywhere measurable and there exists a set `t` such that `t` is a separable set (i.e., it can be approximated by a countable set) and, except possibly on a set of measure zero, the range of the function `f` is contained in `t`. This theorem holds under the conditions that `β` is a pseudometrizable space, a measurable space, and a Borel space.

A measurable function from a measurable space to a separable, pseudometrizable, Borel space is almost everywhere strongly measurable if and only if it is almost everywhere measurable and has range contained in a separable subset, up to a set of measure zero.


theorem norm_algebraMap' :
    ∀ {𝕜 : Type u_1} (𝕜' : Type u_2) [inst : NormedField 𝕜] [inst_1 : SeminormedRing 𝕜'] [inst_2 : NormedAlgebra 𝕜 𝕜']
      [inst_3 : NormOneClass 𝕜'] (x : 𝕜), ‖(algebraMap 𝕜 𝕜') x‖ = ‖x‖ :=
  by sorry

The theorem `norm_algebraMap'` states that for any types `𝕜` and `𝕜'`, where `𝕜` is a normed field, `𝕜'` is a seminormed ring, and `𝕜'` is a normed algebra over `𝕜` that also has a norm of one, the norm of any element `x` of type `𝕜` when mapped into `𝕜'` using the algebra map is equal to the norm of `x` in `𝕜`. This essentially says that the algebra map preserves the norm from `𝕜` to `𝕜'`.

For any normed field 𝕜, seminormed ring 𝕜' making it a normed algebra over 𝕜 with norm one, the norm map of the algebra homomorphism from 𝕜 to 𝕜' is the identity function.


theorem Real.coe_sqrt : ∀ {x : NNReal}, ↑(NNReal.sqrt x) = Real.sqrt ↑x := by sorry

This theorem states that for every nonnegative real number `x`, the square root of `x` in the nonnegative real numbers (denoted as `NNReal.sqrt x`) when converted to a real number (through the operation `↑`) is equal to the square root of `x` in the real numbers (denoted as `Real.sqrt ↑x`). In mathematical language, this means that for every `x` in the set of nonnegative real numbers, `sqrt(x)` in the nonnegative real numbers and `sqrt(x)` in the real numbers are equivalent.

For every non-negative real number `x`, `NNReal.sqrt x = Real.sqrt (↑x)`.


theorem multiplicity.finite_iff_dom :
    ∀ {α : Type u_1} [inst : Monoid α] [inst_1 : DecidableRel fun x x_1 => x ∣ x_1] {a b : α},
      multiplicity.Finite a b ↔ (multiplicity a b).Dom :=
  by sorry

The theorem `multiplicity.finite_iff_dom` states that for any type `α` which forms a Monoid and has a decidable relation for divisibility, given two elements `a` and `b` of type `α`, the multiplicity of `a` in `b` is finite if and only if the multiplicity of `a` in `b` is defined. In this context, the multiplicity of `a` in `b` being finite means there exists a natural number `n` such that `a` to the power of `n + 1` does not divide `b`, and the multiplicity of `a` in `b` being defined refers to the largest natural number `n` such that `a` to the power `n` divides `b`.

For a monoid type `α` with decidable divisibility relation, the multiplicity of `a` in `b` is finite if and only if it is defined, meaning there exists a natural number `n` such that `a^(n + 1)` does not divide `b`, and `a^n` is the largest power of `a` that divides `b`.


theorem sum_le_tsum :
    ∀ {ι : Type u_1} {α : Type u_3} [inst : OrderedAddCommMonoid α] [inst_1 : TopologicalSpace α]
      [inst_2 : OrderClosedTopology α] {f : ι → α} (s : Finset ι),
      (∀ i ∉ s, 0 ≤ f i) → Summable f → (Finset.sum s fun i => f i) ≤ ∑' (i : ι), f i :=
  by sorry

This theorem states that for any type `ι`, any ordered additive commutative monoid `α` with a topological space structure and an order-closed topology, any function `f` from `ι` to `α`, and any finite set `s` of `ι`, if every element `i` not in `s` maps to a non-negative value under `f`, and if `f` is summable (i.e., the infinite sum of `f` over all elements of `ι` exists), then the finite sum of `f` over the elements in `s` is less than or equal to the infinite sum of `f` over all elements of `ι`. In mathematical notation, this can be written as: if `$\forall i \notin s, 0 \leq f(i)$` and the sum `$\sum_{i\in \ι} f(i)$` exists, then `$\sum_{i\in s} f(i) \leq \sum_{i\in \ι} f(i)$`.

Given an ordered additive commutative monoid `α` with a topological space structure and an order-closed topology, for any type `ι`, function `f` from `ι` to `α`, and finite set `s` of `ι`, if every `i` not in `s` maps to a non-negative value under `f` and the infinite sum of `f` over all elements of `ι` exists, then the finite sum of `f` over the elements in `s` is less than or equal to the infinite sum of `f` over all elements of `ι`. In other words, if `$\forall i \notin s, 0 \leq f(i)$` and `$\sum_{i\in \ι} f(i)$` exists, then `$\sum_{i\in s} f(i) \leq \sum_{i\in \ι} f(i)$`.


/-- **Alias** of the reverse direction of `Finset.sup'_le_iff`. -/
theorem Finset.sup'_le :
    ∀ {α : Type u_2} {β : Type u_3} [inst : SemilatticeSup α] {s : Finset β} (H : s.Nonempty) (f : β → α) {a : α},
      (∀ b ∈ s, f b ≤ a) → Finset.sup' s H f ≤ a :=
  by sorry

The theorem `Finset.sup'_le` is an alias of the reverse direction of `Finset.sup'_le_iff`. It states that for any types `α` and `β` where `α` forms a join-semilattice, if we are given a nonempty finite set `s` of type `β`, a function `f` from `β` to `α`, and an element `a` of type `α`, if every element `b` in the finite set `s` satisfies the condition that `f(b)` is less than or equal to `a`, then the supremum of the image of `s` under `f` is less than or equal to `a`. This supremum is computed by the function `Finset.sup'` and it represents the greatest lower bound of the set `{f(b) | b ∈ s}`.

If `α` is a join-semilattice, `s` is a nonempty finite set of type `β`, `f` is a function from `β` to `α`, and `a` is an element of `α` such that `f(b) ≤ a` for all `b` in `s`, then `Finset.sup' s f ≤ a`.


theorem compl_le_compl : ∀ {α : Type u_2} [inst : HeytingAlgebra α] {a b : α}, a ≤ b → bᶜ ≤ aᶜ := by sorry

This theorem states that for any given type `α` that is a Heyting algebra, and any two elements `a` and `b` of this type, if `a` is less than or equal to `b`, then the pseudocomplement of `b` is less than or equal to the pseudocomplement of `a`. In other words, the order is reversed when taking pseudocomplements in a Heyting algebra.

In a Heyting algebra, for all elements `a` and `b`, if `a ≤ b` then the pseudocomplement of `b` is less than or equal to the pseudocomplement of `a` (denoted as `⊥b ≤ ⊥a`).


theorem convex_singleton :
    ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : OrderedSemiring 𝕜] [inst_1 : AddCommMonoid E] [inst_2 : Module 𝕜 E] (c : E),
      Convex 𝕜 {c} :=
  by sorry

This theorem, named `convex_singleton`, states that for any type `𝕜` which has a structure of `OrderedSemiring`, and any type `E` which has a `AddCommMonoid` and `Module 𝕜 E` structure (meaning that `E` is a module over `𝕜`), any singleton set `{c}` in `E` is a convex set.

In simpler terms, for any scalar field `𝕜` and vector space `E` under operations of `𝕜`, a set containing only one point `c` in `E` is convex. This is because a convex set is defined as a set where, for any two points in the set, the entire line segment that joins them is also in the set. Since there is only one point in a singleton set, the condition is trivially satisfied, and thus a singleton set is convex.

A singleton set in an ordered semiring-valued module is convex.