theorem CategoryTheory.OverPresheafAux.OverArrows.yonedaCollectionPresheafToA_val_fst :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {A : CategoryTheory.Functor Cᵒᵖ (Type v)}
      {F : CategoryTheory.Functor (CategoryTheory.CostructuredArrow CategoryTheory.yoneda A)ᵒᵖ (Type v)} {X : C}
      (s : CategoryTheory.yoneda.obj X ⟶ A)
      (p : CategoryTheory.OverPresheafAux.OverArrows (CategoryTheory.OverPresheafAux.yonedaCollectionPresheafToA F) s),
      CategoryTheory.OverPresheafAux.YonedaCollection.fst (CategoryTheory.OverPresheafAux.OverArrows.val p) = s :=
  by sorry

The theorem `CategoryTheory.OverPresheafAux.OverArrows.yonedaCollectionPresheafToA_val_fst` states that for any category `C`, functor `A` from the opposite of `C` to the type `v`, functor `F` from the opposite of the category of costructured arrows from `yoneda A` to `A` to type `v`, and object `X` in `C`, the first component of the value of any element `p` in the OverArrows of the natural transformation from `yonedaCollectionPresheaf A F` to `A` applied to a morphism `s` from `yoneda.obj X` to `A`, is equal to `s`. This theorem is using the Yoneda lemma to establish a relationship between the components of elements in a Yoneda collection and the morphisms in the category.

For any category C, functor A, functor F, object X in C, and element p in the OverArrows of the natural transformation from yonedaCollectionPresheaf A F to A at the morphism s from yoneda.obj X to A, the first component of p equals s.


theorem suffixLevenshtein.proof_1 : ∀ {δ : Type u_1} (r : List δ), 0 < Nat.succ (List.length r) := by sorry

The theorem `suffixLevenshtein.proof_1` states that for any list `r` of elements of an arbitrary type `δ`, the successor of the length of the list (`List.length r`) is greater than 0. In other words, adding 1 to the length of any list will always result in a number that is greater than zero. This is true in any case because the length of a list is non-negative (0 or a positive integer) and adding 1 to a non-negative number results in a positive number.

For any list `r` of elements, the length of `r` plus one is a positive integer.


theorem tendsto_list_sum :
    ∀ {ι : Type u_1} {α : Type u_2} {M : Type u_3} [inst : TopologicalSpace M] [inst_1 : AddMonoid M]
      [inst_2 : ContinuousAdd M] {f : ι → α → M} {x : Filter α} {a : ι → M} (l : List ι),
      (∀ i ∈ l, Filter.Tendsto (f i) x (nhds (a i))) →
        Filter.Tendsto (fun b => List.sum (List.map (fun c => f c b) l)) x (nhds (List.sum (List.map a l))) :=
  by sorry

The theorem `tendsto_list_sum` states that for any list `l` of elements of type `ι`, if for each element `i` in `l`, the function `f` applied to `i` tends towards a neighborhood of `a i` as a filter `x` evolves, then the function which maps `b` to the sum of `f` applied to each element of `l` (i.e., `List.sum (List.map (fun c => f c b) l)`) also tends towards a neighborhood of the sum of `a` applied to each element of `l` (i.e., `List.sum (List.map a l)`) as the same filter `x` evolves. Here, `M` is a type equipped with a topological space structure and an addition operation that is continuous. In simpler terms, this theorem establishes the continuity of the sum of a list of continuous functions in a topological monoid.

If each function in a list maps a filter to a neighborhood of a sequence, then the sum function of the list of functions maps the same filter to a neighborhood of the sum of the corresponding sequence values.


theorem Nat.add_lt_of_lt_sub' : ∀ {a b c : ℕ}, b < c - a → a + b < c := by sorry

This theorem states that for all natural numbers `a`, `b`, and `c`, if `b` is less than the difference of `c` and `a`, then the sum of `a` and `b` is less than `c`. Essentially, this means that if you subtract `a` from `c` and the result is greater than `b`, then when you add `a` and `b` together, the result will be less than `c`. This theorem captures a specific relationship between the operations of addition and subtraction in the context of natural numbers.

For all natural numbers `a`, `b`, and `c`, if `b` < `c` - `a`, then `a` + `b` < `c`.


CategoryTheory.IsDetecting.isSeparating

theorem CategoryTheory.IsDetecting.isSeparating :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.Limits.HasEqualizers C]
      {𝒢 : Set C}, CategoryTheory.IsDetecting 𝒢 → CategoryTheory.IsSeparating 𝒢 :=
  by sorry

The theorem `CategoryTheory.IsDetecting.isSeparating` states that for any category `C` with equalizers, if a set `𝒢` of objects in `C` is a detecting set, then it is also a separating set. In other words, if for any morphisms `f` from `X` to `Y` in `C`, the functors `C(G, -)` for `G ∈ 𝒢` collectively reflect isomorphisms (i.e., if any `h` with domain in `𝒢` uniquely factors through `f`, then `f` is an isomorphism), then the functors `C(G, -)` for `G ∈ 𝒢` are collectively faithful (i.e., if `h ≫ f = h ≫ g` for all `h` with domain in `𝒢`, then `f = g`).

If a set of objects in a category with equalizers is detecting, then it is separating. That is, if the functors given by evaluation at each object in the set collectively reflect isomorphisms, then they also collectively preserve compositions of morphisms.


theorem Finset.prod_update_of_mem :
    ∀ {α : Type u_3} {β : Type u_4} [inst : CommMonoid β] [inst_1 : DecidableEq α] {s : Finset α} {i : α},
      i ∈ s →
        ∀ (f : α → β) (b : β),
          (Finset.prod s fun x => Function.update f i b x) = b * Finset.prod (s \ {i}) fun x => f x :=
  by sorry

The theorem `Finset.prod_update_of_mem` asserts that for any types `α` and `β` (given that `β` forms a commutative monoid and `α` has decidable equality), for any finite set of elements `s` of type `α`, and for any element `i` of type `α` which is a member of `s`, for any function `f` from `α` to `β`, and for any `b` of type `β`, the product of the function values (where the function `f` is updated at point `i` to return `b`) over all elements of `s` is equal to `b` multiplied by the product of the original function values over all elements of `s` excluding `i`. In terms of mathematical notation, this can be expressed as $\prod_{x \in s}f_{updated}(x) = b * \prod_{x \in s \setminus \{i\}}f(x)$ where $f_{updated}(x)$ is $b$ if $x=i$ and $f(x)$ otherwise.

For any finite set `s` of type `α` (where `α` has decidable equality), type `β` forming a commutative monoid, function `f` from `α` to `β`, element `i` of type `α` in `s`, and element `b` of type `β`, the updated function product equals the original function product multiplied by `b`: $\prod\_{x \in s} f\_{updated}(x) = b * \prod\_{x \in s \setminus \{i\}} f(x)$.


theorem MeasureTheory.AEEqFun.integrable_mk :
    ∀ {α : Type u_1} {β : Type u_2} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} [inst : NormedAddCommGroup β]
      {f : α → β} (hf : MeasureTheory.AEStronglyMeasurable f μ),
      MeasureTheory.AEEqFun.Integrable (MeasureTheory.AEEqFun.mk f hf) ↔ MeasureTheory.Integrable f μ :=
  by sorry

The theorem `MeasureTheory.AEEqFun.integrable_mk` states that for any measure space `α`, any normed add commutative group `β`, any measurable space `m` derived from `α`, any measure `μ` on `α`, and any function `f` from `α` to `β` which is almost everywhere strongly measurable with respect to `μ`, the equivalence class `[f]` of the function `f` is integrable if and only if the function `f` itself is integrable. Here, integrability of a function means that it is almost everywhere strongly measurable and its integral (the integral of the absolute value of the function) over the given measure is finite.

For any measure space, normed add commutative group, measurable space, measure, and almost everywhere strongly measurable function between them, the function is integrable if and only if its equivalence class is integrable.


ModuleCat.hasLimitsOfSize

/-- The category of R-modules has all limits.  -/
theorem ModuleCat.hasLimitsOfSize :
    ∀ {R : Type u} [inst : Ring R] [inst_1 : UnivLE.{v, w}],
      CategoryTheory.Limits.HasLimitsOfSize.{t, v, w, max (w + 1) u} (ModuleCat R) :=
  by sorry

This theorem states that for any type `R` that is a Ring, the category of `R`-modules has limits of all sizes. In mathematical terms, given any ring `R`, the category formed by its modules and their morphisms has all possible limits. This is a fundamental property of the category of modules over a ring in category theory, and it asserts the existence of products, equalizers, and more generally limits for any diagram in this category.

For any ring `R`, the category of `R`-modules has all limits.


theorem Polynomial.degree_eq_one_of_irreducible_of_root :
    ∀ {R : Type u} [inst : CommRing R] [inst_1 : IsDomain R] {p : Polynomial R},
      Irreducible p → ∀ {x : R}, Polynomial.IsRoot p x → Polynomial.degree p = 1 :=
  by sorry

This theorem states that for any commutative ring `R`, which is also an integral domain, and for any irreducible polynomial `p` over `R`, if `x` is a root of `p`, then the degree of `p` must be equal to 1. In other words, if a polynomial is irreducible (cannot be factored into polynomials of lower degree) and has a root in the ring, then it must be a linear polynomial.

For any commutative ring that is an integral domain and any irreducible polynomial of degree greater than 1 over it, it has no roots.


theorem Real.arcsin_nonneg : ∀ {x : ℝ}, 0 ≤ Real.arcsin x ↔ 0 ≤ x := by sorry

The theorem `Real.arcsin_nonneg` states that for any real number `x`, the arcsine of `x` is nonnegative if and only if `x` itself is nonnegative. In other words, the arcsine function preserves the nonnegativity of real numbers.

For any real number `x`, `0 ≤ x` if and only if `0 ≤ arcsin x`.


theorem neZero_iff : ∀ {R : Type u_1} [inst : Zero R] {n : R}, NeZero n ↔ n ≠ 0 := by sorry

The theorem `neZero_iff` states that for any type `R` with a zero element, an element `n` of type `R` is non-zero (as defined by the predicate `NeZero`) if and only if `n` is not equal to `0`. This is a universal statement applicable to any type `R` which has a defined zero element.

For any type `R` with a zero element, an element `n` of type `R` is non-zero (as defined in Lean) if and only if `n` is distinct from the zero element of `R`.


theorem Polynomial.toLaurent_C_mul_T :
    ∀ {R : Type u_1} [inst : Semiring R] (n : ℕ) (r : R),
      Polynomial.toLaurent ((Polynomial.monomial n) r) = LaurentPolynomial.C r * LaurentPolynomial.T ↑n :=
  by sorry

The theorem `Polynomial.toLaurent_C_mul_T` states that for any semiring `R`, any natural number `n`, and any element `r` of `R`, the ring homomorphism converting a polynomial with coefficients in `R` to a Laurent polynomial with coefficients in `R` applied to the monomial `r * X^n` is equal to the product of the constant Laurent polynomial of `r` and the `n`th power of the variable of the Laurent polynomial. In other words, it expresses how monomials in the polynomial ring are converted to their counterparts in the Laurent polynomial ring.

For any semiring R, the ring homomorphism from polynomials to Laurent polynomials maps r * X^n to r/1^n * X^n in the Laurent polynomial ring.


theorem Submodule.toAddSubmonoid_injective :
    ∀ {R : Type u} {M : Type v} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M],
      Function.Injective Submodule.toAddSubmonoid :=
  by sorry

The theorem `Submodule.toAddSubmonoid_injective` asserts that for any given semiring `R`, an additive commutative monoid `M`, and any given module of `R` and `M`, the function `Submodule.toAddSubmonoid`, which reinterprets a `Submodule` as an `AddSubmonoid`, is injective. This means that if this function maps two different `Submodule`s to the same `AddSubmonoid`, those `Submodule`s were actually the same to begin with, hence ensuring the uniqueness of `Submodule`s in this context.

The function `Submodule.toAddSubmonoid` mapping submodules of an abelian semigroup to its additive submonoids is an injection.


theorem Mathlib.AlgebraicTopology.SimplicialObject._auxLemma.2 : ∀ {n : ℕ} (a : Fin (n + 1)), (a < 0) = False := by
  sorry

This theorem, `Mathlib.AlgebraicTopology.SimplicialObject._auxLemma.2`, asserts that for any natural number `n` and any value `a` that is a finite number in the range `0` to `n+1`, the condition `(a < 0)` is always false. Essentially, this is stating that a nonnegative finite number can never be less than zero.

For any natural number `n` and any finite value `a` in the range `[0, n+1]`, `a` is not less than zero.


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

This theorem states that for any type `α` that is a LinearOrderedRing and has a FloorRing structure, and for any element `a` of type `α` and natural number `n`, the floor of the difference between `a` and `n` (`⌊a - ↑n⌋`) is equal to the difference between the floor of `a` and `n` (`⌊a⌋ - ↑n`). In other words, subtracting a natural number from a value before taking the floor yields the same result as first taking the floor of the value and then subtracting the natural number.

For any LinearOrderedRing `α` with a FloorRing structure and any `a` in `α` and natural number `n`, `⌊a - ↑n⌋ = ⌊a⌋ - n`.


theorem MvPolynomial.coeff_C_mul :
    ∀ {R : Type u} {σ : Type u_1} [inst : CommSemiring R] (m : σ →₀ ℕ) (a : R) (p : MvPolynomial σ R),
      MvPolynomial.coeff m (MvPolynomial.C a * p) = a * MvPolynomial.coeff m p :=
  by sorry

The theorem `MvPolynomial.coeff_C_mul` states that for any type `R` and `σ`, if `R` is a commutative semiring, then for every multi-variable polynomial `p` of type `MvPolynomial σ R`, any coefficient `a` of type `R`, and any monomial `m` of type `σ →₀ ℕ`, the coefficient of the monomial `m` in the polynomial resulting from multiplying `p` by the constant polynomial with value `a` (`MvPolynomial.C a * p`) is equal to `a` times the coefficient of the monomial `m` in `p` itself. In other words, multiplying a multivariate polynomial by a constant scales the coefficients of all monomials by that constant.

For any commutative semiring `R` and multi-variable polynomial `p` of type `MvPolynomial σ R`, the coefficient of any monomial `m` in the product of `p` and the constant polynomial `C a` is equal to `a` times the coefficient of `m` in `p`.


theorem NonemptyInterval.length_add :
    ∀ {α : Type u_2} [inst : OrderedAddCommGroup α] (s t : NonemptyInterval α),
      NonemptyInterval.length (s + t) = NonemptyInterval.length s + NonemptyInterval.length t :=
  by sorry

This theorem states that for any ordered additive commutative group `α`, and for any two non-empty intervals `s` and `t` within this group, the length of the interval formed by adding `s` and `t` is equal to the sum of the lengths of `s` and `t`. In other words, the length function defined on non-empty intervals behaves distributively over interval addition.

For any ordered additive commutative group `α` and non-empty intervals `s` and `t` within it, the length of `s + t` equals the sum of the lengths of `s` and `t`.


theorem SetTheory.PGame.lf_of_lt : ∀ {x y : SetTheory.PGame}, x < y → SetTheory.PGame.LF x y := by sorry

This theorem states that for any two pre-games `x` and `y` in set theory, if `x` is less than `y` (`x < y`), then the less or fuzzy (`LF`) relation holds between `x` and `y`. In game theory terms, 'less or fuzzy' means that the second player cannot win the game. So, this theorem says that if `x` is a game in which Left has a winning strategy, then it is not true that `y` is a game in which Right has a winning strategy; or in other words, Left can win the game `y` as the first player.

In set theory, if `x` is strictly less than `y`, then `x` does not have a winning strategy for the less or fuzzy relation (i.e., the second player has a winning strategy for game `y`).


theorem MeasureTheory.lintegral_mul_const'' :
    ∀ {α : Type u_1} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} (r : ENNReal) {f : α → ENNReal},
      AEMeasurable f μ → ∫⁻ (a : α), f a * r ∂μ = (∫⁻ (a : α), f a ∂μ) * r :=
  by sorry

The theorem `MeasureTheory.lintegral_mul_const''` states that for any measurable space `α`, any measure `μ` on that space, any extended nonnegative real number `r`, and any function `f` from `α` to the extended nonnegative real numbers that is almost everywhere measurable with respect to `μ`, the Lebesgue integral of the product of `f` and `r` with respect to `μ` is equal to the product of `r` and the Lebesgue integral of `f` with respect to `μ`. In short, it expresses the property that multiplication by a constant can be interchanged with the Lebesgue integral operation.

For any measurable space α, measure μ, extended real number r, and almost everywhere measurable function f: ∫(r * f)(x) dμ(x) = r * ∫f(x) dμ(x).


theorem Complex.arg_mul_coe_angle :
    ∀ {x y : ℂ}, x ≠ 0 → y ≠ 0 → ↑(Complex.arg (x * y)) = ↑(Complex.arg x) + ↑(Complex.arg y) := by sorry

This theorem states that for any two non-zero complex numbers `x` and `y`, the argument of the product of `x` and `y` (denoted as `Complex.arg (x * y)`) is equal to the sum of the arguments of `x` and `y` (denoted as `Complex.arg x` and `Complex.arg y`, respectively). In other words, if `x` and `y` are complex numbers and neither of them is zero, then the argument (the angle in polar representation) of the product of `x` and `y` is equal to the sum of the arguments of `x` and `y`. This matches the property of angles in the multiplication of complex numbers in polar form.

For complex numbers `x` and `y` with `x * y` non-zero, `Complex.arg (x * y) = Complex.arg x + Complex.arg y`.


/-- A reformulation of `IsCyclotomicExtension` that uses `⊤`.  -/
theorem IsCyclotomicExtension.iff_adjoin_eq_top :
    ∀ (S : Set ℕ+) (A : Type u) (B : Type v) [inst : CommRing A] [inst_1 : CommRing B] [inst_2 : Algebra A B],
      IsCyclotomicExtension S A B ↔
        (∀ n ∈ S, ∃ r, IsPrimitiveRoot r ↑n) ∧ Algebra.adjoin A {b | ∃ n ∈ S, b ^ ↑n = 1} = ⊤ :=
  by sorry

The theorem `IsCyclotomicExtension.iff_adjoin_eq_top` states the following: For any set `S` of positive integers and any types `A` and `B` that form commutative rings with an algebraic structure, `A` and `B` form a Cyclotomic extension (denoted as `IsCyclotomicExtension S A B`) if and only if two conditions are met. The first condition is that for every element `n` in `S`, there exists a `r` that is a primitive root of `n`. The second condition is that the algebraic closure formed by adjoining all elements `b` to `A` such that there exists an `n` in `S` where `b` to the power of `n` is `1`, equals the top element of the lattice of subalgebras of `A`. Here, the top element of a lattice represents the most inclusive subalgebra, or in other words, the whole algebra.

A commutative ring algebra pair (A,B) forms a cyclotomic extension if and only if for every positive integer n in S, there exists a primitive root r of n in A, and the algebraic closure of A adjoining all elements b with b^n = 1 is the top element of the lattice of subalgebras of A.


theorem Cycle.nodup_reverse_iff : ∀ {α : Type u_1} {s : Cycle α}, Cycle.Nodup (Cycle.reverse s) ↔ Cycle.Nodup s := by
  sorry

The theorem `Cycle.nodup_reverse_iff` states that for any type `α` and any cycle `s` of type `α`, the cycle `s` has no duplicates if and only if the reverse of `s` also has no duplicates. In other words, reversing a cycle does not change its duplicate-free status. This is true for all cycles, irrespective of their element types.

For any cycle `s` of type `α`, `s` has no duplicates if and only if the reversed cycle of `s` has no duplicates.


theorem Set.indicator_eq_one_iff_mem :
    ∀ {α : Type u_1} (M : Type u_4) [inst : MulZeroOneClass M] [inst_1 : Nontrivial M] {U : Set α} {x : α},
      Set.indicator U 1 x = 1 ↔ x ∈ U :=
  by sorry

The theorem `Set.indicator_eq_one_iff_mem` states that for any type `α` and a multiplicative monoid with zero and one `M` (which is nontrivial), given a set `U` of type `α` and an element `x` of type `α`, the set indicator function of `U` evaluated at `x` with function value `1` is equal to `1` if and only if `x` is an element of the set `U`. In other words, within this mathematical structure, an element `x` belongs to a set `U` precisely when its set indicator with a constant function of `1` returns `1`.

For any set U of type α and multiplicative monoid M with zero and one, the indicator function iU of U evaluated at x equals 1 if and only if x is a member of U.


theorem LinearMap.stdBasis_ne :
    ∀ (R : Type u_1) {ι : Type u_2} [inst : Semiring R] (φ : ι → Type u_3) [inst_1 : (i : ι) → AddCommMonoid (φ i)]
      [inst_2 : (i : ι) → Module R (φ i)] [inst_3 : DecidableEq ι] (i j : ι),
      j ≠ i → ∀ (b : φ i), (LinearMap.stdBasis R φ i) b j = 0 :=
  by sorry

The theorem `LinearMap.stdBasis_ne` states that for any semiring `R`, a type function `φ` mapping from type `ι` to some types `u_3`, and any instances of the additive commutative monoid and `R`-module structures over the types `φ i` for each `i : ι`, given that the equality on type `ι` is decidable, if we take two distinct elements `i` and `j` from `ι`, then for any element `b` of type `φ i`, the value of the standard basis linear map associated to `i`, when applied to `b` and then evaluated at `j`, is zero. This theorem essentially demonstrates that the standard basis linear maps are orthogonal in the sense that different basis maps do not interfere with each other.

For any semiring `R`, given a type function `φ : ι → u_3` with decidable equality on `ι`, and instances of the additive commutative monoid and `R`-module structures over `φ i` for all `i : ι`, the standard basis linear maps associated to distinct elements of `ι` are orthogonal, i.e., their values applied to any basis element and evaluated at another basis element are equal to zero.


theorem MeasureTheory.extend_iUnion_le_tsum_nat' :
    ∀ {α : Type u_1} {P : Set α → Prop} {m : (s : Set α) → P s → ENNReal}
      (PU : ∀ ⦃f : ℕ → Set α⦄, (∀ (i : ℕ), P (f i)) → P (⋃ i, f i)),
      (∀ ⦃f : ℕ → Set α⦄ (hm : ∀ (i : ℕ), P (f i)), m (⋃ i, f i) ⋯ ≤ ∑' (i : ℕ), m (f i) ⋯) →
        ∀ (s : ℕ → Set α), MeasureTheory.extend m (⋃ i, s i) ≤ ∑' (i : ℕ), MeasureTheory.extend m (s i) :=
  by sorry

The theorem `MeasureTheory.extend_iUnion_le_tsum_nat'` states that for any type `α`, any predicate `P` over sets of `α`, and `m` a function from sets satisfying `P` to the extended nonnegative real numbers, if for any sequence of sets (indexed over the natural numbers) that all satisfy `P`, the measure of the union of the sets is less than or equal to the sum of the measures of the individual sets, then this inequality still holds when we extend the function `m` to sets that may not satisfy `P`. In more succinct terms, it says that the measure of a countable union of sets is less than or equal to the sum of the measures of the individual sets, even when we extend the measure function beyond its original domain.

Given a type α, a predicate P over sets of α, and a function m from sets satisfying P to extended nonnegative reals, if the union of any countable sequence of sets satisfying P has measure less than or equal to the sum of the measures of its elements according to m, then this inequality holds for the extended measure function m' that includes sets not satisfying P.


theorem Ordinal.lsub_not_mem_range : ∀ {ι : Type u} (f : ι → Ordinal.{max u v}), Ordinal.lsub f ∉ Set.range f := by
  sorry

This theorem states that for any type `ι` and any function `f` from `ι` to the type of well orders, the least strict upper bound of the family of ordinals defined by `f` does not belong to the range of `f`. In mathematical terms, if we consider `f` as a function that assigns to each element of `ι` an ordinal number, then the least strict upper bound of all these ordinal numbers is not an image of any element in `ι` under the function `f`.

The least strict upper bound of a family of ordinals, each being the image of some element under a given function from a type to the type of ordinals, is not an image under that function.


theorem CategoryTheory.Limits.IsInitial.to_self :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X : C} (t : CategoryTheory.Limits.IsInitial X),
      CategoryTheory.Limits.IsInitial.to t X = CategoryTheory.CategoryStruct.id X :=
  by sorry

This theorem states that for any category `C` and any object `X` in `C`, if `X` is an initial object in the category (denoted by `CategoryTheory.Limits.IsInitial X`), then the morphism from the initial object `X` to itself (`CategoryTheory.Limits.IsInitial.to t X`) is identical to the identity morphism on `X` (`CategoryTheory.CategoryStruct.id X`). In other words, in any category, the morphism from an initial object to itself is always the identity morphism.

In any category, the morphism from an initial object to itself is the identity morphism.


theorem iSup_sup :
    ∀ {α : Type u_1} {ι : Sort u_5} [inst : CompleteLattice α] [inst_1 : Nonempty ι] {f : ι → α} {a : α},
      (⨆ x, f x) ⊔ a = ⨆ x, f x ⊔ a :=
  by sorry

This theorem states that for any type `α` which forms a complete lattice, any nonempty type `ι`, a function `f` from `ι` to `α`, and an element `a` of `α`, the supremum of `f x` for all `x` in `ι` joined with `a` is equal to the supremum of the joined elements `f x` and `a` for all `x` in `ι`. In more mathematical terms, it says that for any function `f: ι → α` and any `a ∈ α`, we have `sup_x (f(x)) ∨ a = sup_x (f(x) ∨ a)`. This is a property of complete lattices and the sup operation.

For any complete lattice `α`, any nonempty type `ι`, and function `f` from `ι` to `α`, the supremum of `f x` for all `x` in `ι` joined with an element `a` of `α` is equal to the supremum of the joined elements `f x` and `a` for all `x` in `ι`. In symbols, `sup_x (f(x) ∨ a) = sup_x (f(x)) ∨ a`.


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

This theorem states that for any integer `n` and any two types `α` and `β` that are instances of the `TopologicalSpace` type class, and `β` is also an instance of the `IntCast` type class, the coercion of `n` to a continuous map is the same as the direct coercion of `n` to `β`. In other words, the process of casting an integer to a certain type in the context of continuous maps is equivalent to directly casting the integer to that type.

For any integer `n` and types `α` and `β` being instances of `TopologicalSpace` with `β` also an instance of `IntCast`, the coercion of `n` to a continuous map from `α` to `β` equals the direct coercion of `n` to `β`.


theorem Nat.leRecOn_trans :
    ∀ {C : ℕ → Sort u_1} {n m k : ℕ} (hnm : n ≤ m) (hmk : m ≤ k) {next : {k : ℕ} → C k → C (k + 1)} (x : C n),
      Nat.leRecOn ⋯ next x = Nat.leRecOn hmk next (Nat.leRecOn hnm next x) :=
  by sorry

This theorem states that for any natural numbers `n`, `m`, and `k` where `n` is less than or equal to `m` and `m` is less than or equal to `k`, and any function `next` that takes a natural number `k` and a value of type `C k` and produces a value of type `C (k + 1)`, and any value `x` of type `C n`, the result of applying the function `Nat.leRecOn` (which recursively applies `next` starting with `x` until it reaches a certain natural number) to `n`, `m`, and `k` with `next` and `x` is equivalent to applying `Nat.leRecOn` to `m` and `k` with `next` and the result of applying `Nat.leRecOn` to `n` and `m` with `next` and `x`.

For any natural numbers `n ≤ m ≤ k` and function `next : ℕ → C → C`, if `Nat.leRecOn n m k next x = y` then `Nat.leRecOn m k next y = Nat.leRecOn n m next x`.


CategoryTheory.FullSubcategory.ext

theorem CategoryTheory.FullSubcategory.ext :
    ∀ {C : Type u₁} {Z : C → Prop} (x y : CategoryTheory.FullSubcategory Z), x.obj = y.obj → x = y := by sorry

This theorem states that for any category `C` and any property `Z` defining a subcategory, if two objects `x` and `y` from the full subcategory defined by `Z` have the same underlying object in `C`, then `x` and `y` are equal in the full subcategory. This means that in the context of full subcategories, two objects are considered the same if and only if their underlying objects in the original category are the same.

In any category and subcategory defined by a property, two objects having the same underlying object in the original category are equal in the subcategory.


theorem MeasureTheory.inter_cylinder :
    ∀ {ι : Type u_1} {α : ι → Type u_2} (s₁ s₂ : Finset ι) (S₁ : Set ((i : { x // x ∈ s₁ }) → α ↑i))
      (S₂ : Set ((i : { x // x ∈ s₂ }) → α ↑i)) [inst : DecidableEq ι],
      MeasureTheory.cylinder s₁ S₁ ∩ MeasureTheory.cylinder s₂ S₂ =
        MeasureTheory.cylinder (s₁ ∪ s₂)
          ((fun f j => f { val := ↑j, property := ⋯ }) ⁻¹' S₁ ∩ (fun f j => f { val := ↑j, property := ⋯ }) ⁻¹' S₂) :=
  by sorry

The theorem `MeasureTheory.inter_cylinder` states that for any two finite sets of indices `s₁` and `s₂` and their respective sets `S₁` and `S₂` with elements of types determined by `s₁` and `s₂`, the intersection of their corresponding cylinders is equal to the cylinder of the union of `s₁` and `s₂`, whose elements are the intersection of the preimages of `S₁` and `S₂` through a function `f`. This theorem holds given that equality is decidable for the type of the indices `ι`. In other words, this theorem describes how the intersection of two cylinders over finite index sets relates to the cylinder over the union of these index sets.

For sets $S\_1$ and $S\_2$ determined by finite index sets $s\_1$ and $s\_2$, respectively, the intersection of their cylinders equals the cylinder of their union, where elements are in the intersection of the preimages of $S\_1$ and $S\_2$ through a function $f$.


/-- For the single implications with fewer assumptions, see `one_div_lt_one_div_of_lt` and
`lt_of_one_div_lt_one_div`  -/
theorem one_div_lt_one_div :
    ∀ {α : Type u_2} [inst : LinearOrderedSemifield α] {a b : α}, 0 < a → 0 < b → (1 / a < 1 / b ↔ b < a) := by sorry

This theorem states that for any type `α` that is a linearly ordered semiring (a mathematical structure having operations of addition and multiplication with ordering properties), given two positive values `a` and `b` of type `α`, the statement "1 divided by `a` is less than 1 divided by `b`" is equivalent to the statement "`b` is less than `a`". This theorem is useful when working with reciprocals in the context of ordered fields.

For any linearly ordered semiring type `α` and positive elements `a` and `b` of `α`, `1 / a < 1 / b` if and only if `a` is less than `b`.


theorem MeasureTheory.ae_lt_top :
    ∀ {α : Type u_1} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} {f : α → ENNReal},
      Measurable f → ∫⁻ (x : α), f x ∂μ ≠ ⊤ → ∀ᵐ (x : α) ∂μ, f x < ⊤ :=
  by sorry

This theorem is in the context of measure theory. It states that for all types `α`, measurable spaces `m` on `α`, measures `μ` on `α`, and functions `f` from `α` to the extended nonnegative real numbers (ENNReal), if `f` is a measurable function and the integral (Lebesgue) of `f` with respect to measure `μ` is not infinity, then almost everywhere (`∀ᵐ` symbol denotes "almost everywhere") with respect to the measure `μ`, the value of `f` is less than infinity. In terms of measure theory, this is expressing that if the integral of a function over all space isn't infinite, the function value itself won't be infinite almost everywhere in the space.

If `f` is a measurable function from a measurable space `(α, m)` to the extended nonnegative real numbers, with finite Lebesgue integral with respect to measure `μ`, then `μ`-almost everywhere, `f` is finite.


theorem OrderHom.map_sInf_subset_fixedPoints_le :
    ∀ {α : Type u} [inst : CompleteLattice α] (f : α →o α), ∀ A ⊆ Function.fixedPoints ⇑f, f (sInf A) ≤ sInf A := by
  sorry

This theorem states that for any type `α` that forms a complete lattice, and any order-preserving function `f : α → α`, if a set `A` is a subset of the fixed points of `f`, then the image of the infimum (`sInf`) of `A` under `f` is less than or equal to the infimum of `A`. In other words, if all elements of `A` are fixed points of `f`, `f` will map the infimum of `A` to a value that is less than or equal to the original infimum.

For any complete lattice `α` and order-preserving function `f` on `α`, if `A ⊆ fixpoints(f)`, then `f(sInf A) ≤ sInf A`.


theorem Set.ordConnected_iff_uIcc_subset_left :
    ∀ {α : Type u_1} [inst : LinearOrder α] {s : Set α} {x : α},
      x ∈ s → (Set.OrdConnected s ↔ ∀ ⦃y : α⦄, y ∈ s → Set.uIcc x y ⊆ s) :=
  by sorry

This theorem states that for any type `α` with a linear order, a set `s` of elements of type `α`, and an element `x` of type `α` that belongs to `s`, the set `s` is order-connected if and only if for any element `y` of type `α` that belongs to `s`, the set of elements between `x` and `y` (inclusive) is a subset of `s`. Here, order-connected means that for any two elements in the set, all the elements that lie between these two elements (inclusive) also belong to the set. The `Set.uIcc x y` function returns the set of elements lying between `x` and `y` (inclusive).

For any linear order type `α`, set `s` of elements from `α`, and `x, y ∈ s`, if `s` is order-connected then `Set.uIcc x y ⊆ s`.


theorem Set.toFinset_singleton : ∀ {α : Type u_1} (a : α) [inst : Fintype ↑{a}], Set.toFinset {a} = {a} := by sorry

This theorem states that for any type `α` and any instance `a` of that type, if we have a `Fintype` instance for the singleton set containing `a`, then the finset obtained by applying the `Set.toFinset` function to this singleton set is equal to the singleton set `{a}` itself. In other words, the `Set.toFinset` operation, when applied to a singleton set, will produce a finset that is identical to the original set.

For any type `α` and any `a : α`, the singleton set `{a}` is equal to the finset obtained by applying `Set.toFinset` to it.


theorem Submonoid.map_le_iff_le_comap :
    ∀ {M : Type u_1} {N : Type u_2} [inst : MulOneClass M] [inst_1 : MulOneClass N] {F : Type u_4}
      [inst_2 : FunLike F M N] [mc : MonoidHomClass F M N] {f : F} {S : Submonoid M} {T : Submonoid N},
      Submonoid.map f S ≤ T ↔ S ≤ Submonoid.comap f T :=
  by sorry

This theorem, `Submonoid.map_le_iff_le_comap`, states that for any given types `M` and `N` that are instances of `MulOneClass`, any type `F` that is a `FunLike` function from `M` to `N` and a `MonoidHomClass`, and any given submonoids `S` of `M` and `T` of `N`, as well as a function `f` of type `F`, the image of `S` under `f` is a submonoid of `T` if and only if `S` is a submonoid of the preimage of `T` under `f`. In other words, the statement is about the relationship between the image and preimage of submonoids under a monoid homomorphism.

For any submonoids S of type M and T of type N, and any monoid homomorphism f : M -> N between types M and N, the image of S under f is a submonoid of T if and only if S is a submonoid of the preimage of T under f.


/-- The image under an `AddMonoid` hom of the `AddSubgroup` generated by a set equals
the `AddSubgroup` generated by the image of the set. -/
theorem AddMonoidHom.map_closure :
    ∀ {G : Type u_1} [inst : AddGroup G] {N : Type u_5} [inst_1 : AddGroup N] (f : G →+ N) (s : Set G),
      AddSubgroup.map f (AddSubgroup.closure s) = AddSubgroup.closure (⇑f '' s) :=
  by sorry

This theorem states that for any additive group `G`, any other additive group `N`, a homomorphism `f` from `G` to `N`, and a set `s` in `G`, the image under the homomorphism `f` of the additive subgroup generated by the set `s` is equal to the additive subgroup generated by the image of the set `s` under the homomorphism `f`.

In other words, the process of mapping a subgroup via a homomorphism and thereafter generating a subgroup from a set commutes with the process of first generating a subgroup and then mapping it via the homomorphism.

For any additive groups G and N, homomorphism f, and set s in G, the subgroup generated by the images of s under f is equal to f(the subgroup generated by s).


theorem Multiset.toDFinsupp_injective :
    ∀ {α : Type u_1} [inst : DecidableEq α], Function.Injective ⇑Multiset.toDFinsupp := by sorry

The theorem `Multiset.toDFinsupp_injective` states that for any type `α` which has decidable equality, the function `Multiset.toDFinsupp` is injective. In other words, if `Multiset.toDFinsupp` applied to two multiset `α` objects produces the same result, then those two multisets were identical. This function `Multiset.toDFinsupp` converts a multiset into a DFinsupp, which is a type of function from elements of `α` to natural numbers, basically representing the count of each element in the multiset.

For any decidably equal multisets of type `α`, their conversion to DFinsupps using `Multiset.toDFinsupp` results in equal functions.


theorem ENNReal.nhds_coe_coe : ∀ {r p : NNReal}, nhds (↑r, ↑p) = Filter.map (fun p => (↑p.1, ↑p.2)) (nhds (r, p)) := by
  sorry

This theorem, `ENNReal.nhds_coe_coe`, states that for any two nonnegative real numbers `r` and `p`, the neighborhood filter of the pair `(↑r, ↑p)` (where `↑r` and `↑p` denote the embeddings of `r` and `p` into the real numbers) is equal to the forward map, under the function that maps a pair to its embeddings into the real numbers, of the neighborhood filter of the pair `(r, p)`. In other words, the local topological structure at `(↑r, ↑p)` in the real numbers is exactly the same as the local topological structure at `(r, p)` in the nonnegative real numbers, when the latter is viewed as a subspace of the real numbers.

The neighborhood filters of `(r, p)` in the nonnegative real numbers and of `(↑r, ↑p)` in the real numbers are equal.


Set.Finite.pi

/-- Finite product of finite sets is finite  -/
theorem Set.Finite.pi :
    ∀ {ι : Type u_1} [inst : Finite ι] {κ : ι → Type u_2} {t : (i : ι) → Set (κ i)},
      (∀ (i : ι), Set.Finite (t i)) → Set.Finite (Set.pi Set.univ t) :=
  by sorry

This theorem states that the product of finite sets is also finite. More specifically, given an index set `ι` which is finite, a family of sets `t` indexed by `ι`, where each set `t i` is also finite for all `i` in `ι`, the set of all dependent functions (or products) `f : Πa, π a` such that `f a` belongs to `t a` for all `a` in `ι` is also finite. Here, the product is defined with respect to the universal set, which contains all elements of the index set `ι`. In mathematical terms, this theorem can be written as: if ι is a finite set and for every i in ι, t(i) is also a finite set, then ∏ t(i) over all i in ι is also finite.

If `ι` is a finite index set and every `t(i)` is a finite set, then the product `∏ t(i)` over all `i` in `ι` is also finite.


theorem CategoryTheory.GlueData.t_inv :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v, u₁} C] (D : CategoryTheory.GlueData C) (i j : D.J),
      CategoryTheory.CategoryStruct.comp (D.t i j) (D.t j i) = CategoryTheory.CategoryStruct.id (D.V (i, j)) :=
  by sorry

This theorem is a property in Category Theory concerning the structure of gluing data. Specifically, it states that for any category `C`, given a gluing data `D` on `C` and any two indices `i` and `j` in the indexing set of `D`, the composition of the transition morphisms `D.t i j` and `D.t j i` (in that order) is equal to the identity morphism on the object `D.V (i, j)`. In other words, the transition morphisms `D.t i j` and `D.t j i` are inverses of each other with respect to composition in the category `C`.

For any category `C` and gluing data `D` on `C`, the transition morphisms `D.t i j` and `D.t j i` are mutual inverses in `C`.


/-- For any function `f` from a normed vector space to a normed vector space, the set of points
`x` such that `f` is continuously polynomial at `x` is open.  -/
theorem isOpen_cPolynomialAt :
    ∀ (𝕜 : Type u_1) {E : Type u_2} {F : Type u_3} [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] (f : E → F),
      IsOpen {x | CPolynomialAt 𝕜 f x} :=
  by sorry

The theorem `isOpen_cPolynomialAt` states that for any function `f` mapping from one normed vector space to another over a non-trivially normed field `𝕜`, the set of points `x` at which `f` admits a finite power series expansion (or in other words, `f` is continuously polynomial at `x`) forms an open set in the topological space of the domain. This essentially means that around every point where the function is continuously polynomial, there exists an open neighbourhood entirely comprised of points where the function is also continuously polynomial.

The set of points in a normed vector space where a function admits a finite power series expansion forms an open subset.


theorem ENat.toNat_coe : ∀ (n : ℕ), ENat.toNat ↑n = n := by sorry

This theorem states that for any natural number `n`, the function `ENat.toNat`, which converts extended natural numbers (including infinity) to natural numbers by mapping infinity to zero, when applied to the coercion of `n` to an extended natural number, will yield `n` itself. In mathematical terms, for any natural number `n`, we have `ENat.toNat ↑n = n`, which means the function `ENat.toNat` is an identity function for natural numbers in the context of the extended natural numbers system.

For any natural number `n`, `ENat.toNat (coe toENat n) = n`. (Here, `coe` is the coercion function from natural numbers to extended natural numbers, and `toENat` is the conversion function from natural numbers to extended natural numbers.)


theorem ONote.fastGrowing_def :
    ∀ {o : ONote} {x : Option ONote ⊕ (ℕ → ONote)} (e : ONote.fundamentalSequence o = x),
      ONote.fastGrowing o =
        match (motive := (x : Option ONote ⊕ (ℕ → ONote)) → ONote.FundamentalSequenceProp o x → ℕ → ℕ) x, ⋯ with
        | Sum.inl none, x => Nat.succ
        | Sum.inl (some a), x => fun i => (ONote.fastGrowing a)^[i] i
        | Sum.inr f, x => fun i => ONote.fastGrowing (f i) i :=
  by sorry

This theorem, `ONote.fastGrowing_def`, describes the definition of the fast-growing hierarchy in ordinal notation. Given any ordinal notation `o` and a value `x`, which is either an optional ordinal notation or a function from natural numbers to ordinal notation, such that `x` equals the fundamental sequence of `o`, this theorem defines the fast-growing function on `o`. If `x` is `none`, the function is the successor function on natural numbers. If `x` is an ordinal notation `a`, the function is the iterated fast-growing function on `a`. If `x` is a function from natural numbers to ordinal notations, the function is a sequence of fast-growing functions indexed by natural numbers.

The theorem `ONote.fastGrowing_def` defines the fast-growing function on an ordinal `o` as the successor function on natural numbers if `o` is undefined, the iterated fast-growing function on `o` if `o` is defined as an ordinal, or a sequence of fast-growing functions indexed by natural numbers if `o` is defined as a function from natural numbers to ordinal notations.


theorem Finset.biUnion_mono :
    ∀ {α : Type u_1} {β : Type u_2} {s : Finset α} {t₁ t₂ : α → Finset β} [inst : DecidableEq β],
      (∀ a ∈ s, t₁ a ⊆ t₂ a) → Finset.biUnion s t₁ ⊆ Finset.biUnion s t₂ :=
  by sorry

The theorem `Finset.biUnion_mono` asserts that for any types `α` and `β`, any finite set `s` of `α`, and any two functions `t₁` and `t₂` from `α` to finite sets of `β` (assuming `β` has decidable equality), if for every element `a` in `s`, the finite set `t₁ a` is a subset of `t₂ a`, then the union of `t₁ a` over all `a` in `s` is a subset of the union of `t₂ a` over all `a` in `s`. In other words, if each individual finite set mapped by `t₁` from `s` is contained in the corresponding finite set mapped by `t₂`, then this containment relation is preserved when taking the unions over all elements of `s`.

If `β` has decidable equality and for all `a` in a finite set `s`, `t₁ a` is a subset of `t₂ a`, then the union of `t₁ a` over `a` in `s` is a subset of the union of `t₂ a` over `a` in `s`.


theorem Int.ediv_add_emod : ∀ (a b : ℤ), b * (a / b) + a % b = a := by sorry

This theorem states that for any two integers `a` and `b`, the product of `b` and the integer division of `a` by `b`, when added to the modulus of `a` with respect to `b`, equals `a`. This is the mathematical version of the formal statement that the division with remainder of an integer `a` by another integer `b` can be recombined to yield the original `a`, i.e., `a = b * (a div b) + (a mod b)`.

For any integers `a` and `b`, `a = b * (a // b) + a % b`.


theorem IsAddCyclic.exponent_eq_card :
    ∀ {α : Type u} [inst : AddGroup α] [inst_1 : IsAddCyclic α] [inst_2 : Fintype α],
      AddMonoid.exponent α = Fintype.card α :=
  by sorry

The theorem `IsAddCyclic.exponent_eq_card` states that for any type `α` that forms an Additive Group and is Additive Cyclic (i.e., there is an element in `α`, whose repeated addition generates all elements in `α`) and also is a Finite Type (i.e., `α` has a finite number of distinct elements), the exponent of the Additive Monoid of `α` is equal to the number of elements in `α`. In other words, the smallest positive integer `n` such that adding any element from the group to itself `n` times results in the additive identity element (zero), is equal to the total number of elements in the group, if `α` has these properties.

For any finite, additive group `α` that is additively cyclic, the order of its additive monoid equals its number of elements.


theorem StarSubalgebra.coe_sInf :
    ∀ {R : Type u_2} {A : Type u_3} [inst : CommSemiring R] [inst_1 : StarRing R] [inst_2 : Semiring A]
      [inst_3 : Algebra R A] [inst_4 : StarRing A] [inst_5 : StarModule R A] (S : Set (StarSubalgebra R A)),
      ↑(sInf S) = ⋂ s ∈ S, ↑s :=
  by sorry

This theorem states that for any type `R` and `A`, where `R` is a commutative semiring and also a star ring, and `A` is a semiring which is an algebra over `R` and also a star ring,  and `A` is a star module over `R`, and given a set `S` of star subalgebras of `R` and `A`, the coercion of the infimum of `S` is equal to the intersection over all elements `s` in `S` of the coercion of `s`.

In mathematical terms, this theorem asserts that for any set of star subalgebras in a star module, the infimum of the set (viewed as a subset of the module) is equal to the intersection of the sets corresponding to each subalgebra.

Let `R` be a commutative semiring and star ring, `A` a semiring that is an algebra and star module over `R`, and `S` a set of star subalgebras of `R` and `A`. Then, the infimum of `S` as subsets of `A` equals the intersection of the sets of subalgebras in `S`.


theorem Nat.card_zmod : ∀ (n : ℕ), Nat.card (ZMod n) = n := by sorry

This theorem states that for any natural number `n`, the cardinality of the set of integers modulo `n` is equal to `n` itself. It implies that there are exactly `n` distinct equivalence classes in the set of integers under modulo `n` operation. In other words, there are `n` different possible residues when dividing an integer by `n`.

The number of integers modulo n is equal to n.


theorem invOf_mul_self_assoc' : ∀ {α : Type u} [inst : Monoid α] (a b : α) {x : Invertible a}, ⅟a * (a * b) = b := by
  sorry

This theorem states that for any monoid `α`, and any elements `a` and `b` of `α`, if `a` has an inverse, then multiplying the inverse of `a` by the result of `a` and `b` multiplication equals `b`. In terms of mathematical notation, for `a` and `b` in `α` and `a` being invertible, this is saying that ⅟`a` * (`a` * `b`) = `b`.

If `a` in monoid `α` has an inverse, then `(a^(-1) * a) * b = b`.


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

This theorem states that for any type `ι`, given `I`, `J`, `J₁` and `J₂` as boxes in the `BoxIntegral.Box ι` space and a prepartition `π` of box `I`, if both `J₁` and `J₂` are part of the prepartition `π` and box `J` is less than or equal to both `J₁` and `J₂`, then `J₁` and `J₂` must be equal. Basically, it's stating that if two boxes in a prepartition are both larger than or equal to a certain box, then these two boxes must be the same. This theorem is a property of partitions in the context of integral calculus.

If `π` is a prepartition of type `ι`, `J₁`, `J₂` are boxes in `BoxIntegral.Box ι` belonging to `π`, and `J ≤ J₁ ≤ J₂`, then `J₁ = J₂`.


theorem LinearMap.ker_le_ker_comp :
    ∀ {R : Type u_1} {R₂ : Type u_3} {R₃ : Type u_4} {M : Type u_6} {M₂ : Type u_8} {M₃ : Type u_9} [inst : Semiring R]
      [inst_1 : Semiring R₂] [inst_2 : Semiring R₃] [inst_3 : AddCommMonoid M] [inst_4 : AddCommMonoid M₂]
      [inst_5 : AddCommMonoid M₃] [inst_6 : Module R M] [inst_7 : Module R₂ M₂] [inst_8 : Module R₃ M₃] {τ₁₂ : R →+* R₂}
      {τ₂₃ : R₂ →+* R₃} {τ₁₃ : R →+* R₃} [inst_9 : RingHomCompTriple τ₁₂ τ₂₃ τ₁₃] (f : M →ₛₗ[τ₁₂] M₂)
      (g : M₂ →ₛₗ[τ₂₃] M₃), LinearMap.ker f ≤ LinearMap.ker (LinearMap.comp g f) :=
  by sorry

This theorem states that for any three semirings R, R₂, R₃ and three additively commutative monoids M, M₂, M₃, with M, M₂, M₃ being modules over R, R₂, R₃ respectively, and given three ring homomorphisms τ₁₂, τ₂₃, τ₁₃ (with τ₁₃ being the composition of τ₁₂ and τ₂₃), and two linear maps f (from M to M₂) and g (from M₂ to M₃), the kernel of the linear map f is a subspace (or is contained in) the kernel of the composition of the linear maps g and f. In terms of category theory, it suggests that the kernel of a morphism is always a subset of the kernel of its composition with another morphism.

For any three semirings R, R₂, R₃, three additively commutative monoids M, M₂, M₃ that are modules over R, R₂, R₃ respectively, and given ring homomorphisms τ₁₂, τ₂₃, τ₁₃, two linear maps f : M → M₂ and g : M₂ → M₃, the kernel of f is contained in the kernel of g ∘ f.


theorem List.Palindrome.reverse_eq : ∀ {α : Type u_1} {l : List α}, List.Palindrome l → List.reverse l = l := by sorry

This theorem states that for any type `α` and a list `l` of type `α`, if the list `l` is a palindrome, then the reverse of the list `l` is equal to the list `l` itself. In other words, for a palindromic list, reversing the list doesn't change the list.

If `α` is a type and `l` is a list of `α` that is a palindrome, then `l = reverse l`.


theorem Submodule.span_smul_of_span_eq_top :
    ∀ {R : Type u} {S : Type v} {A : Type w} [inst : Semiring R] [inst_1 : Semiring S] [inst_2 : AddCommMonoid A]
      [inst_3 : Module R S] [inst_4 : Module S A] [inst_5 : Module R A] [inst_6 : IsScalarTower R S A] {s : Set S},
      Submodule.span R s = ⊤ →
        ∀ (t : Set A), Submodule.span R (s • t) = Submodule.restrictScalars R (Submodule.span S t) :=
  by sorry

The theorem `Submodule.span_smul_of_span_eq_top` states that for any types `R`, `S`, `A` with `R` and `S` being semirings, `A` an additive commutative monoid, `S` a module over `R`, `A` a module over both `R` and `S`, and `A` a scalar tower over `R` and `S`, if the span of a set `s` of type `S` over `R` equals the top submodule, then for any set `t` of type `A`, the span of the scaled set `s • t` over `R` equals the restriction of the scalars of the span of `t` over `S` to `R`. Here, `s • t` denotes the set of all elements obtained by scaling elements of `t` by elements of `s`. The `Submodule.span R s = ⊤` condition means that every element of the module `S` can be expressed as a linear combination of elements from the set `s` with coefficients in `R`.

If the span of a set in an `R`-module `S` over `R` equals the whole module, then the span of the scalar multiples of another set in `S` over `R` is equal to the restriction of scalars of the span of that set over `S` to `R`.


theorem NNReal.sqrt_one : NNReal.sqrt 1 = 1 := by sorry

This theorem states that the square root of 1, when considered within the set of nonnegative real numbers, is equal to 1. This is consistent with the usual mathematical understanding of square roots.

The square root of 1, in the non-negative real numbers, equals 1.


/-- Uses `left` co(ntra)variant.  -/
theorem Left.inv_lt_one_iff :
    ∀ {α : Type u} [inst : Group α] [inst_1 : LT α]
      [inst_2 : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x < x_1] {a : α}, a⁻¹ < 1 ↔ 1 < a :=
  by sorry

This theorem, `Left.inv_lt_one_iff`, states that for any type `α` that forms a group and has a less than (`<`) operation, and for any given element `a` of this type `α`, the inverse of `a` is less than 1 if and only if 1 is less than `a`. This relies on the `CovariantClass` property of `α` which, for this theorem, asserts that multiplying elements in `α` preserves the less than relation. In mathematical notation, this would be expressed as: for all `a` in `α`, `a⁻¹ < 1` is equivalent to `1 < a`.

For any group type `α` with a `<` relation, the inverse of an element `a` is less than 1 if and only if 1 is less than `a`. (Assuming the `<` relation is covariant.)


/-- The definition of `vectorSpan`, for rewriting.  -/
theorem vectorSpan_def :
    ∀ (k : Type u_1) {V : Type u_2} {P : Type u_3} [inst : Ring k] [inst_1 : AddCommGroup V] [inst_2 : Module k V]
      [inst_3 : AddTorsor V P] (s : Set P), vectorSpan k s = Submodule.span k (s -ᵥ s) :=
  by sorry

The theorem `vectorSpan_def` describes the equivalency between the definition of `vectorSpan` and `Submodule.span` for a given set of points. Specifically, for any field `k` and set `s`, the `vectorSpan` of `s` in `k` is exactly the same as the span of the differences of `s` in `k`. Here, the `vectorSpan` is defined as the submodule spanning the differences of a set of points, while `Submodule.span` is defined as the smallest submodule that contains the set. The differences of a set `s` is represented as `s -ᵥ s` in Lean 4.

For any field `k` and set `s` in `k`, the submodule generated by the differences of `s` is equal to the span of `s` in `k`. In Lean 4 notation, `vectorSpan s = Submodule.span (s -ᵥ s)`.


theorem Submodule.mem_span :
    ∀ {R : Type u_1} {M : Type u_4} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {x : M}
      {s : Set M}, x ∈ Submodule.span R s ↔ ∀ (p : Submodule R M), s ⊆ ↑p → x ∈ p :=
  by sorry

This theorem states that for any semiring `R` and an additive commutative monoid `M` that is also a module over `R`, a member `x` of type `M` is in the span of a set `s` (of elements of `M`) if and only if for every submodule `p` of `M` over `R`, whenever `s` is a subset of `p`, `x` is an element of `p`. In simple terms, it establishes that an element is in the span of a set if it belongs to every submodule that contains the set.

An element of an additive commutative `R`-module is in the span of a set if and only if it belongs to every submodule containing the set.


theorem ContinuousMultilinearMap.le_opNorm_mul_pow_card_of_le :
    ∀ {𝕜 : Type u} {ι : Type v} {E : ι → Type wE} {G : Type wG} [inst : Fintype ι] [inst_1 : NontriviallyNormedField 𝕜]
      [inst_2 : (i : ι) → SeminormedAddCommGroup (E i)] [inst_3 : (i : ι) → NormedSpace 𝕜 (E i)]
      [inst_4 : SeminormedAddCommGroup G] [inst_5 : NormedSpace 𝕜 G] (f : ContinuousMultilinearMap 𝕜 E G)
      {m : (i : ι) → E i} {b : ℝ}, ‖m‖ ≤ b → ‖f m‖ ≤ ‖f‖ * b ^ Fintype.card ι :=
  by sorry

The theorem `ContinuousMultilinearMap.le_opNorm_mul_pow_card_of_le` states that for a given continuous multilinear map `f` from a nontrivially normed field `𝕜` to a normed space `G`, and a tuple `m` from a finitely indexed family of seminormed additive commutative groups `E`, if the norm of `m` is less than or equal to a real number `b`, then the norm of the image of `m` under `f` is less than or equal to the operator norm of `f` times `b` raised to the power of the cardinality (the number of elements) of the index set `ι`. The norm, operator norm, and cardinality are all defined in the usual way for their respective mathematical objects.

For a continuous multilinear map from a nontrivially normed field to a normed space and a tuple from a finitely indexed family of seminormed additive commutative groups with norm less than or equal to a real number, the image norm is less than or equal to the operator norm times the number raising to the power of the cardinality of the index set.


theorem Mathlib.Order.Basic._auxLemma.3 :
    ∀ {α : Type u} [inst : Preorder α] {a b : α} [inst_1 : Subsingleton α], (a ≤ b) = True := by sorry

This theorem states that for any type `α` with a preorder and subsingleton structures, and any two elements `a` and `b` of type `α`, the statement "a is less than or equal to b" is always true. In other words, in a type with a preorder where there is at most one element, any two elements are always considered to be in a "less than or equal to" relationship.

In a preordered type with a subsingleton structure, any two elements are equivalent with respect to the preorder relation.


theorem isClosed_induced_iff' :
    ∀ {α : Type u_1} {β : Type u_2} [t : TopologicalSpace β] {f : α → β} {s : Set α},
      IsClosed s ↔ ∀ (a : α), f a ∈ closure (f '' s) → a ∈ s :=
  by sorry

This theorem states that for any two types `α` and `β`, a topological space `t` over `β`, a function `f` from `α` to `β`, and a set `s` of `α`, the set `s` is closed if and only if for every element `a` of `α`, if `f(a)` is in the closure of the image of `s` under `f`, then `a` must belong to `s`. In other words, the closure of the image of `s` under `f` is such that any `a` in `α` that maps into this closure must have come from `s`. This theorem provides a characterization of closed sets in terms of their images under a function in the context of topological spaces.

A set in a topological space is closed if and only if the closure of its image under any continuous function contains only elements mapping from the set itself.


theorem Mathlib.Data.Finset.Lattice._auxLemma.5 : ∀ {a b c : Prop}, (a ∨ b → c) = ((a → c) ∧ (b → c)) := by sorry

This theorem, `Mathlib.Data.Finset.Lattice._auxLemma.5`, states that for any three propositions `a`, `b`, and `c`, the proposition that `c` is implied by either `a` or `b` (`a ∨ b → c`) is equivalent to the proposition that `c` is implied by `a` and `c` is implied by `b` (`(a → c) ∧ (b → c)`). In other words, if `c` follows from either `a` or `b`, then it must follow from `a` and it must also follow from `b`.

The proposition `(a ∨ b) → c` is logically equivalent to `(a → c) ∧ (b → c)`.


theorem Mathlib.Data.Finset.Lattice._auxLemma.6 :
    ∀ {α : Sort u_1} {p q : α → Prop}, (∀ (x : α), p x ∧ q x) = ((∀ (x : α), p x) ∧ ∀ (x : α), q x) := by sorry

This theorem, named `Mathlib.Data.Finset.Lattice._auxLemma.6`, asserts that for any type `α` and for any two properties `p` and `q` of elements of type `α`, the property of each element satisfying both `p` and `q` is equivalent to the property of each element satisfying `p` and each element satisfying `q`. In mathematical terms, this theorem states that $\forall x \in \alpha, (p(x) \land q(x))$ is equivalent to $(\forall x \in \alpha, p(x)) \land (\forall x \in \alpha, q(x))$.

The theorem asserts that for any type `α` and properties `p` and `q` of its elements, the element-wise conjunction `p ∧ q` is equivalent to the conjunction of the sets of elements satisfying `p` and `q`, i.e., `{x | p(x)} ∧ {x | q(x)}`.


theorem Asymptotics.isTheta_const_smul_right :
    ∀ {α : Type u_1} {E : Type u_3} {F' : Type u_7} {𝕜 : Type u_14} [inst : Norm E] [inst_1 : SeminormedAddCommGroup F']
      [inst_2 : NormedField 𝕜] {f : α → E} {g' : α → F'} {l : Filter α} [inst_3 : NormedSpace 𝕜 F'] {c : 𝕜},
      c ≠ 0 → ((f =Θ[l] fun x => c • g' x) ↔ f =Θ[l] g') :=
  by sorry

This theorem states that for any types `α`, `E`, `F'`, `𝕜` and any functions `f : α → E` and `g' : α → F'`, if `𝕜` is a normed field, `E` is a normed space, `F'` is a seminormed additive commutative group, and `c` is a non-zero scalar in `𝕜`, then `f` is asymptotically equivalent to `c` times `g'` with respect to a filter `l` if and only if `f` is asymptotically equivalent to `g'` with respect to the same filter `l`. Here, "asymptotically equivalent" means that the ratio of `f` and `g'` (or `f` and `c • g'`) tends towards 1 as we follow the filter `l`.

For types `α`, `E`, `F'`, `𝕜`, functions `f : α → E`, `g' : α → F'`, and a non-zero scalar `c` in a normed field `𝕜`, `f` is asymptotically equivalent to `c` times `g'` with respect to a filter `l` if and only if `f` is asymptotically equivalent to `g'` with respect to `l`. (Here, "asymptotically equivalent" refers to the ratio of `f` and `g'` or `f` and `c` times `g'` approaching 1 as the filter `l` is followed.)


theorem MeasureTheory.lmarginal_union :
    ∀ {δ : Type u_1} {π : δ → Type u_3} [inst : (x : δ) → MeasurableSpace (π x)]
      (μ : (i : δ) → MeasureTheory.Measure (π i)) [inst_1 : ∀ (i : δ), MeasureTheory.SigmaFinite (μ i)]
      [inst_2 : DecidableEq δ] {s t : Finset δ} (f : ((i : δ) → π i) → ENNReal),
      Measurable f → Disjoint s t → ∫⋯∫⁻_s ∪ t, f ∂μ = ∫⋯∫⁻_s, ∫⋯∫⁻_t, f ∂μ ∂μ :=
  by sorry

This theorem, `MeasureTheory.lmarginal_union`, states that for any type `δ`, function `π` from `δ` to another type, where each element of `δ` has an associated measurable space, a family `μ` of measures (each `μ i` is a measure on the measurable space `π i`), a function `f` from a `δ`-indexed product space to the Extended Nonnegative Real numbers (ENNReal), and disjoint finite subsets `s` and `t` of `δ`: If the function `f` is measurable and `s` and `t` are disjoint, then the integral over `s` union `t` of `f` with respect to `μ` is equal to the double integral over `s` and then `t` of `f` with respect to `μ`. This means that, under these conditions, the measure of `f` over the union of `s` and `t` can be computed by separately measuring over `s` and `t` and then combining these measurements.

For measurable functions `f` and disjoint sets `s` and `t` in a product measurable space, the integral of `f` over `s` union `t` equals the sum of the integrals over `s` and `t`.


theorem FilterBasis.mem_filter_of_mem :
    ∀ {α : Type u_1} (B : FilterBasis α) {U : Set α}, U ∈ B → U ∈ FilterBasis.filter B := by sorry

The theorem `FilterBasis.mem_filter_of_mem` states that for any type `α`, given a filter basis `B` of this type and a set `U` of the same type, if the set `U` is an element of the filter basis `B`, then `U` is also an element of the filter associated with the filter basis `B`. This essentially says that any set that belongs to a filter basis will automatically belong to the filter generated by that basis.

If `B` is a filter basis for the type `α`, and `U` is an element of `B`, then `U` is a member of the filter `filterBASIS B`.


theorem image_eq_zero_of_nmem_tsupport :
    ∀ {X : Type u_1} {α : Type u_2} [inst : Zero α] [inst_1 : TopologicalSpace X] {f : X → α} {x : X},
      x ∉ tsupport f → f x = 0 :=
  by sorry

This theorem states that for any given function `f` from a type `X` to a type `α`, where `α` has a zero element and `X` has a topological structure, if an element `x` of `X` does not belong to the topological support of the function `f` (i.e., it is not in the closure of the set of all elements where the function is nonzero), then the value of the function `f` at `x` is zero. In other words, in terms of function support, if `x` is outside the topological support of `f`, then `f(x)` is zero.

If a function `f` from a topological space `X` to a type `α` with a zero element, has no nonzero values in the closure of a point `x` in `X`, then `f(x) = 0`.


theorem CauSeq.Completion.mk_eq :
    ∀ {α : Type u_1} [inst : LinearOrderedField α] {β : Type u_2} [inst_1 : Ring β] {abv : β → α}
      [inst_2 : IsAbsoluteValue abv] {f g : CauSeq β abv}, CauSeq.Completion.mk f = CauSeq.Completion.mk g ↔ f ≈ g :=
  by sorry

The theorem `CauSeq.Completion.mk_eq` states that for any linearly ordered field `α` and ring `β` with a function `abv: β → α` that is an absolute value, and for any two Cauchy sequences `f, g` of `β` with respect to the absolute value `abv`, the sequences `f` and `g` are equivalent if and only if their respective completions under `CauSeq.Completion.mk` are equal. Here, a Cauchy sequence is a sequence where the difference between any two sufficiently far terms can be made arbitrarily small, and the completion refers to the process of filling in any "gaps" in a sequence to make it complete. The equivalence `f ≈ g` of two Cauchy sequences means that the difference between `f` and `g` becomes arbitrarily small for sufficiently large indices.

For any linearly ordered field `α` and ring `β` with an absolute value function `abv`, two Cauchy sequences `f` and `g` in `β` with respect to `abv` are equivalent if and only if their completions under `CauSeq.Completion.mk` are equal.


/-- If `β` is a second-countable space, then its induced topology via
`f` on `α` is also second-countable.  -/
theorem TopologicalSpace.secondCountableTopology_induced :
    ∀ (α : Type u) (β : Type u_1) [t : TopologicalSpace β] [inst : SecondCountableTopology β] (f : α → β),
      SecondCountableTopology α :=
  by sorry

This theorem states that if `β` is a second-countable space, then the topology induced on `α` via a function `f` from `α` to `β` is also second-countable. In other words, if you have a second-countable topological space, and you define a new topology on a different space using a function from that space to the second-countable one, the new topology is also second-countable. This holds for any types `α` and `β` and any function `f` from `α` to `β`.

If `β` is a second-countable topological space and `f` is a function from a topological space `α` to `β`, then the topology on `α` induced by `f` is also second-countable.


Convex.smul

theorem Convex.smul :
    ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : OrderedCommSemiring 𝕜] [inst_1 : AddCommMonoid E] [inst_2 : Module 𝕜 E]
      {s : Set E}, Convex 𝕜 s → ∀ (c : 𝕜), Convex 𝕜 (c • s) :=
  by sorry

The theorem `Convex.smul` states that for every ordered commutative semiring `𝕜`, every additive commutative monoid `E`, and every `𝕜`-module `E`, if a set `s` in `E` is convex, then the scaled set `c • s` is also convex. In other words, multiplying all elements of a convex set by a scalar yields another convex set. Here, "convex" means that for any two points in the set, the line segment that joins them stays completely within the set.

For every ordered commutative semiring 𝕜, every additive commutative monoid E made into a 𝕜-module, and convex set s in E, the scaled set c • s is also convex.


Filter.Subsingleton.map

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

The theorem `Filter.Subsingleton.map` states that for all types `α` and `β`, and for any filter `l` on type `α`, if the filter `l` is a subsingleton (which means there exists a subsingleton set that belongs to the filter `l`), then for any function `f` from `α` to `β`, the filter resulting from mapping `f` onto `l` is also a subsingleton. In simple terms, it means that the property of being a subsingleton is preserved under the operation of mapping a function onto a filter.

If `l` is a subsingleton filter on type `α` and `f` is a function from `α` to `β`, then the filter `Map (f) l` on `β` is also a subsingleton filter.


theorem LipschitzWith.dist_le_mul_of_le :
    ∀ {α : Type u} {β : Type v} [inst : PseudoMetricSpace α] [inst_1 : PseudoMetricSpace β] {K : NNReal} {f : α → β}
      {x y : α} {r : ℝ}, LipschitzWith K f → dist x y ≤ r → dist (f x) (f y) ≤ ↑K * r :=
  by sorry

The theorem `LipschitzWith.dist_le_mul_of_le` states that, for all types `α` and `β` equipped with a pseudometric space structure, a nonnegative real number `K`, a function `f` from `α` to `β`, elements `x` and `y` of `α`, and a real number `r`, if the function `f` is Lipschitz continuous with constant `K` and the distance between `x` and `y` is less than or equal to `r`, then the distance between `f(x)` and `f(y)` is less than or equal to `K` times `r`. In other words, the distance between the images under a Lipschitz continuous function does not exceed the Lipschitz constant times the original distance.

For all pseudometric spaces (α, d\_α) and (β, d\_β), and for all Lipschitz continuous functions f : α --> β with constant K, x, y in α, and r in R, if d\_α(x, y) <= r then d\_β(f(x), f(y)) <= K * r.


theorem Int.mul_pos : ∀ {a b : ℤ}, 0 < a → 0 < b → 0 < a * b := by sorry

This theorem states that for any two integers `a` and `b`, if both `a` and `b` are greater than zero, then their product is also greater than zero. In other words, the product of two positive integers is always a positive integer.

For all integers `a` and `b` > 0, their product `a * b` is also positive.


/-- A version of `Nat.exists_infinite_primes` using the `Set.Infinite` predicate.  -/
theorem Nat.infinite_setOf_prime : Set.Infinite {p | Nat.Prime p} := by sorry

The theorem `Nat.infinite_setOf_prime` states that the set of prime numbers is infinite. In other words, there are infinitely many natural numbers that are prime, where a prime number is defined as a natural number at least 2 whose only divisors are itself and 1. This theorem is a version of `Nat.exists_infinite_primes` which uses the `Set.Infinite` predicate to define infiniteness of a set.

The set of prime natural numbers is infinite.


theorem Subtype.mk_lt_mk :
    ∀ {α : Type u} [inst : LT α] {p : α → Prop} {x y : α} {hx : p x} {hy : p y},
      { val := x, property := hx } < { val := y, property := hy } ↔ x < y :=
  by sorry

The theorem `Subtype.mk_lt_mk` states that for any type `α` with a less-than (`<`) operation, and for any property `p` on `α`, given two elements `x` and `y` of `α` such that `p(x)` and `p(y)` are true, the proposition that the subtype element constructed from `x` and `hx` is less than the subtype element constructed from `y` and `hy` is equivalent to the proposition that `x` is less than `y`. This theorem essentially states that the less-than relation on the original type `α` is preserved when we move to the corresponding subtype where all elements satisfy the property `p`.

Given a type `α` with a total order `<`, and a property `p` on `α`, if `x < y` and `p(x)` and `p(y)` hold, then `Subtype.mk x hx < Subtype.mk y hy` in the subtype `p  ℝ`.


theorem MvPFunctor.w_cases :
    ∀ {n : ℕ} (P : MvPFunctor.{u} (n + 1)) {α : TypeVec.{u} n} {C : MvPFunctor.W P α → Prop},
      (∀ (a : P.A) (f' : TypeVec.Arrow ((MvPFunctor.drop P).B a) α) (f : (MvPFunctor.last P).B a → MvPFunctor.W P α),
          C (MvPFunctor.wMk P a f' f)) →
        ∀ (x : MvPFunctor.W P α), C x :=
  by sorry

This theorem states that for any natural number `n`, multivariate polynomial functor `P` of arity `n+1`, and `α` which is an `n`-tuple of types, and a predicate `C` on `W`-type of `P` with `α`, if `C` holds for any value constructed by `MvPFunctor.wMk` with inputs `a`, `f'`, and `f` where `a` is in the sort of `P`, `f'` is an arrow in the `TypeVec` category from `(MvPFunctor.drop P).B a` to `α`, and `f` is a function from `(MvPFunctor.last P).B a` to `MvPFunctor.W P α`, then `C` holds for any element in `MvPFunctor.W P α`. This can be seen as a form of structural induction over the `W`-type of a multivariate polynomial functor.

If a predicate `C` holds for all values constructed by `MvPFunctor.wMk` from an `n+1`-ary multivariate polynomial functor `P`, inputs in the sort of `P` and functions from the base types of `P` to `α` and `MvPFunctor.W P α`, then `C` holds for all elements in `MvPFunctor.W P α`.


theorem CategoryTheory.Discrete.addMonoidalFunctor.proof_1 :
    ∀ {M : Type u_2} [inst : AddMonoid M] {N : Type u_1} [inst_1 : AddMonoid N] (F : M →+ N)
      {X Y : CategoryTheory.Discrete M}, (X ⟶ Y) → F X.as = F Y.as :=
  by sorry

This theorem states that for any two objects `X` and `Y` in a discrete category whose objects are elements of an additive monoid `M`, and any additive monoid homomorphism `F` from `M` to another additive monoid `N`, the action of `F` on the objects `X` and `Y` is the same if there exists a morphism from `X` to `Y`. In other words, every morphism in the discrete category induces an equation between the results of applying `F` to the source and target of the morphism.

For any additive monoid homomorphism F between additive monoids M and N, and any objects X and Y in the discrete category of M with a morphism f : X -> Y, we have F(X) = F(Y).


theorem LieHom.idealRange_eq_top_of_surjective :
    ∀ {R : Type u} {L : Type v} {L' : Type w₂} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L]
      [inst_3 : LieRing L'] [inst_4 : LieAlgebra R L'] (f : L →ₗ⁅R⁆ L'),
      Function.Surjective ⇑f → LieHom.idealRange f = ⊤ :=
  by sorry

This theorem states that for any commutative ring `R`, Lie rings `L` and `L'`, and a morphism `f` from `L` to `L'` as Lie algebras over `R`, if the morphism `f` is surjective (i.e., every element of `L'` can be mapped from some element of `L`), then the ideal range of `f` (the set of all images of `f`, considered as a Lie ideal in `L'`) equals the whole Lie algebra `L'`. In other words, the ideal range of a surjective Lie algebra morphism spans the entire codomain.

If `f` is a surjective Lie algebra homomorphism from a Lie algebra `L` over a commutative ring `R` to a Lie algebra `L'`, then the ideal range of `f` equals `L'`.


theorem Mathlib.CategoryTheory.Sites.Grothendieck._auxLemma.4 :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} (J : CategoryTheory.GrothendieckTopology C)
      (S : CategoryTheory.Sieve X) (f : Y ⟶ X),
      CategoryTheory.GrothendieckTopology.Covers J S f = (CategoryTheory.Sieve.pullback f S ∈ J.sieves Y) :=
  by sorry

This theorem is about the relation between Grothendieck topologies and sieves in category theory. It states that, for any category `C` with objects `X` and `Y`, a Grothendieck topology `J` on `C`, a sieve `S` on `X`, and a morphism `f` from `Y` to `X`, the statement that `S` `J`-covers `f` is equivalent to the statement that the pullback of `S` by `f` is in the collection of sieves in `J` on `Y`. The pullback of `S` by `f` is the inverse image of `S` with `_ ≫ f`, and the `J`-cover is defined as the condition that this pullback belongs to the topology `J`.

For a category `C`, object `X`, Grothendieck topology `J`, sieve `S` on `X`, and morphism `f: Y → X` in `C`, `S` `J`-covers `f` if and only if the pullback of `S` by `f` is in `J`.


theorem AddSubgroup.eq_top_of_card_eq :
    ∀ {G : Type u_1} [inst : AddGroup G] (H : AddSubgroup G) [inst_1 : Fintype ↥H] [inst_2 : Fintype G],
      Fintype.card ↥H = Fintype.card G → H = ⊤ :=
  by sorry

The theorem `AddSubgroup.eq_top_of_card_eq` states that for any additive group `G` and any of its additive subgroups `H`, given that both `G` and `H` are finite (`Fintype G` and `Fintype ↥H`, where `↥H` represents the set of elements in `H`), if the number of elements in the subgroup `H` (`Fintype.card ↥H`) is equal to the number of elements in the group `G` (`Fintype.card G`), then the subgroup `H` must be equal to the entire group `G` (denoted `⊤`). In other words, if a finite group and one of its subgroups have the same cardinality, then the subgroup must in fact be the whole group.

If two finite additive groups have equal cardinalities, then the smaller subgroup is equal to the larger group.


theorem SymAlg.sym_mul_sym :
    ∀ {α : Type u_1} [inst : Mul α] [inst_1 : Add α] [inst_2 : One α] [inst_3 : OfNat α 2] [inst_4 : Invertible 2]
      (a b : α), SymAlg.sym a * SymAlg.sym b = SymAlg.sym (⅟2 * (a * b + b * a)) :=
  by sorry

The theorem `SymAlg.sym_mul_sym` states that for any type `α` equipped with multiplication, addition, a one element, a representation of the natural number 2, and where 2 is invertible, the product of the symmetric algebra elements corresponding to `a` and `b` (denoted `SymAlg.sym a` and `SymAlg.sym b` respectively) is equal to the symmetric algebra element corresponding to half of the sum of `a * b` and `b * a` (denoted `SymAlg.sym (⅟2 * (a * b + b * a))`).

For any type `α` with multiplication, addition, a one element, a representation of 2, and 2 invertible, `SymAlg.sym (a * b) = SymAlg.sym (⅟2 * (a * b + b * a))` for all `a, b : α`.


theorem Polynomial.eval_eq_sum_range :
    ∀ {R : Type u} [inst : Semiring R] {p : Polynomial R} (x : R),
      Polynomial.eval x p =
        Finset.sum (Finset.range (Polynomial.natDegree p + 1)) fun i => Polynomial.coeff p i * x ^ i :=
  by sorry

The theorem `Polynomial.eval_eq_sum_range` states that for any semiring `R` and any polynomial `p` of type `R`, the evaluation of the polynomial `p` at a point `x` in `R` is equal to the sum over the range from 0 to the natural degree of `p` (inclusive) of the `i`-th coefficient of `p` times `x` raised to the `i`-th power. In other words, the polynomial evaluation at `x` is the sum of each term's contribution at `x`, where each term is the product of the coefficient of the term and `x` raised to the power equal to the degree of the term, which is essentially the definition of polynomial evaluation in a semiring.

For any semiring `R` and polynomial `p` of type `R`, the evaluation of `p` at a point `x` in `R` equals the sum of the products of each `i`-th coefficient of `p` with `x` raised to the power `i`, from `i` equal to `0` to the natural degree of `p`.


theorem LinearMap.comp_add :
    ∀ {R₁ : Type u_2} {R₂ : Type u_3} {R₃ : Type u_4} {M : Type u_9} {M₂ : Type u_11} {M₃ : Type u_12}
      [inst : Semiring R₁] [inst_1 : Semiring R₂] [inst_2 : Semiring R₃] [inst_3 : AddCommMonoid M]
      [inst_4 : AddCommMonoid M₂] [inst_5 : AddCommMonoid M₃] [inst_6 : Module R₁ M] [inst_7 : Module R₂ M₂]
      [inst_8 : Module R₃ M₃] {σ₁₂ : R₁ →+* R₂} {σ₂₃ : R₂ →+* R₃} {σ₁₃ : R₁ →+* R₃}
      [inst_9 : RingHomCompTriple σ₁₂ σ₂₃ σ₁₃] (f g : M →ₛₗ[σ₁₂] M₂) (h : M₂ →ₛₗ[σ₂₃] M₃),
      LinearMap.comp h (f + g) = LinearMap.comp h f + LinearMap.comp h g :=
  by sorry

This theorem, `LinearMap.comp_add`, states that for any three semirings R₁, R₂, and R₃ and any three additive commutative monoids M, M₂, and M₃ that are also R₁, R₂, and R₃-modules respectively, and for any three ring homomorphisms σ₁₂ from R₁ to R₂, σ₂₃ from R₂ to R₃, and σ₁₃ from R₁ to R₃ (which form a composition triple), the composition of a linear map h from M₂ to M₃ with the sum of two linear maps f and g from M to M₂ is the same as the sum of the composition of h with f and the composition of h with g. In simpler terms, this theorem asserts the distributivity of function composition over addition for linear maps, which is a fundamental property in linear algebra.

For any semirings R₁, R₂, and R₃, and additive commutative monoids M, M₂, and M₃ that are R₁, R₂, and R₃-modules respectively, and for any ring homomorphisms σ₁₂, σ₂₃, and σ₁₃ between them forming a composition triple, the composition of a linear map h from M₂ to M₃ with the sum of two linear maps f and g from M to M₂ is equal to the sum of the compositions of h with f and h with g.


theorem isUpperSet_iUnion₂ :
    ∀ {α : Type u_1} {ι : Sort u_4} {κ : ι → Sort u_5} [inst : LE α] {f : (i : ι) → κ i → Set α},
      (∀ (i : ι) (j : κ i), IsUpperSet (f i j)) → IsUpperSet (⋃ i, ⋃ j, f i j) :=
  by sorry

The theorem `isUpperSet_iUnion₂` states that for any type `α` that has a less-than-or-equal-to (`LE`) relation, and for any functions `f` that maps elements from types `ι` and `κ` to sets of `α`, if each set `f i j` is an upper set (that is, for any elements `a` and `b` of the set, if `a` is less than or equal to `b`, then `b` is also in the set), then the union of all such sets (for all `i` in `ι` and `j` in `κ i`) is also an upper set. This means that any element greater than a member of the union set is also a member of the union set.

If `f i j` is an upper set for each `i` in `ι` and `j` in `κ`, then the union of all `f i j` is an upper set.


theorem Real.sin_int_mul_pi : ∀ (n : ℤ), Real.sin (↑n * Real.pi) = 0 := by sorry

This theorem states that for all integers 'n', the sine of 'n' times pi is equal to zero. In mathematical terms, it states that for any integer \(n\), \(\sin(n \pi) = 0\). This is a well-known result in trigonometry, reflecting the periodicity and symmetry of the sine function.


theorem CategoryTheory.CommSq.fac_left :
    ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] {A B X Y : C} {f : A ⟶ X} {i : A ⟶ B} {p : X ⟶ Y}
      {g : B ⟶ Y} (sq : CategoryTheory.CommSq f i p g) [hsq : CategoryTheory.CommSq.HasLift sq],
      CategoryTheory.CategoryStruct.comp i (CategoryTheory.CommSq.lift sq) = f :=
  by sorry

This theorem states that in the context of a category `C`, for any commutative square `sq`, which is determined by objects `A, B, X, Y` and morphisms `f : A ⟶ X`, `i : A ⟶ B`, `p : X ⟶ Y`, `g : B ⟶ Y` such that `f` followed by `p` is the same as `i` followed by `g`, if the commutative square `sq` has a lift, then the composition of the morphism `i` and the lift of the square `sq` equals to the morphism `f`. In terms of category theory, this means that if we have a diagonal morphism providing a lift for the commutative square, then traversing the square via this morphism and `i` is equivalent to directly traversing via `f`.

If a commutative square in a category has a lift, then the composition of the morphism along the left edge and the lift equals the morphism along the bottom edge.


theorem ContinuousLinearMap.isBigO_comp :
    ∀ {𝕜₂ : Type u_2} {𝕜₃ : Type u_3} {F : Type u_5} {G : Type u_6} [inst : SeminormedAddCommGroup F]
      [inst_1 : SeminormedAddCommGroup G] [inst_2 : NontriviallyNormedField 𝕜₂] [inst_3 : NontriviallyNormedField 𝕜₃]
      [inst_4 : NormedSpace 𝕜₂ F] [inst_5 : NormedSpace 𝕜₃ G] {σ₂₃ : 𝕜₂ →+* 𝕜₃} [inst_6 : RingHomIsometric σ₂₃]
      {α : Type u_7} (g : F →SL[σ₂₃] G) (f : α → F) (l : Filter α), (fun x' => g (f x')) =O[l] f :=
  by sorry

This theorem states that, for all types `𝕜₂`, `𝕜₃`, `F`, `G`, and `α`, given a continuous linear map `g` from `F` to `G` over a ring homomorphism `σ₂₃` from `𝕜₂` to `𝕜₃`, and a function `f` from `α` to `F`, with `l` as a filter on `α`, the composition function `(fun x' => g (f x'))` is a big O of function `f` at filter `l`. Here "big O" notation is a mathematical notation used to describe the limiting behavior of a function when the argument tends towards a particular value or infinity, usually in terms of simpler functions.

For any types `𝕜₂`, `𝕜₃`, `F`, `G`, `α`, given a continuous linear map `g` from `F` to `G` over a ring homomorphism `σ₂₃` from `𝕜₂` to `𝕜₃`, and a function `f` from `α` to `F`, the composition `g ∘ f` is a big O of `f` with respect to filter `l` on `α`.


theorem CategoryTheory.GrothendieckTopology.sheafifyLift_unique :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (J : CategoryTheory.GrothendieckTopology C) {D : Type w}
      [inst_1 : CategoryTheory.Category.{max v u, w} D]
      [inst_2 :
        ∀ (P : CategoryTheory.Functor Cᵒᵖ D) (X : C) (S : CategoryTheory.GrothendieckTopology.Cover J X),
          CategoryTheory.Limits.HasMultiequalizer (CategoryTheory.GrothendieckTopology.Cover.index S P)]
      [inst_3 : ∀ (X : C), CategoryTheory.Limits.HasColimitsOfShape (CategoryTheory.GrothendieckTopology.Cover J X)ᵒᵖ D]
      {P Q : CategoryTheory.Functor Cᵒᵖ D} (η : P ⟶ Q) (hQ : CategoryTheory.Presheaf.IsSheaf J Q)
      (γ : CategoryTheory.GrothendieckTopology.sheafify J P ⟶ Q),
      CategoryTheory.CategoryStruct.comp (CategoryTheory.GrothendieckTopology.toSheafify J P) γ = η →
        γ = CategoryTheory.GrothendieckTopology.sheafifyLift J η hQ :=
  by sorry

The theorem `CategoryTheory.GrothendieckTopology.sheafifyLift_unique` states that in a category `C` with a Grothendieck topology `J`, for given functors `P` and `Q` from the opposite category `Cᵒᵖ` to another category `D`, if `P` has a multiequalizer for every cover in `J` and `D` has all colimits of shapes given by covers in `J`, then given a morphism `η` from `P` to `Q` and another morphism `γ` from the sheafification of `P` with respect to `J` to `Q`, if the composition of the morphism from `P` to its sheafification and `γ` equals `η`, then `γ` is unique and equals to the lift of `η` with respect to the sheafification process.

In other words, this theorem is about the uniqueness of morphisms in a certain context related to sheafification in the category theory, specifically in the context of Grothendieck topologies.

Given functors `P` and `Q` from the opposite category of a Grothendieck topos `(C, J)` to category `D` with colimits of shapes given by covers in `J`, if `P` has a multiequalizer for every cover and `η: P ⥤ Q` has a unique lift `γ: ʃP ⥤ Q` to the sheafification `ʃP` of `P`, then `γ = η⊤`.


theorem neg_lt_iff_pos_add' :
    ∀ {α : Type u} [inst : AddGroup α] [inst_1 : LT α]
      [inst_2 : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x < x_1] {a b : α}, -a < b ↔ 0 < a + b :=
  by sorry

This theorem states that for any type `α` that forms an additive group and has a less than (`<`) relation, and for any two elements `a` and `b` of that type, `-a` is less than `b` if and only if `0` is less than the sum of `a` and `b`. The condition `CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x < x_1` ensures that the less than relation `<` and the addition operation `+` interact in the way expected for an ordered additive group.

For any additive group `α` with a total order, `-a < b` if and only if `0 < a + b`.


theorem isExtrFilter_const :
    ∀ {α : Type u} {β : Type v} [inst : Preorder β] {l : Filter α} {a : α} {b : β}, IsExtrFilter (fun x => b) l a := by
  sorry

The theorem `isExtrFilter_const` states that for any type `α` and any preorder type `β`, given any filter `l` on `α`, any element `a` from `α`, and any element `b` from `β`, the constant function (which maps every `x` to `b`) is an extreme filter at `a` with respect to `l`. In other words, the constant function either achieves a minimum or a maximum at `a` under the filter `l`.

For any filter `l` on type `α`, element `a` from `α`, and element `b` from a preorder type `β`, the constant function from `α` to `β` with value `b` is an extreme filter element at `a` with respect to `l`.


theorem Primrec.vector_cons : ∀ {α : Type u_1} [inst : Primcodable α] {n : ℕ}, Primrec₂ Vector.cons := by sorry

The theorem `Primrec.vector_cons` asserts that for any type `α` which is Primcodable (denoted by `[inst : Primcodable α]`), and for any natural number `n`, the function `Vector.cons` is a binary primitive recursive function. In other words, given any element of type `α` and a vector of `n` elements of type `α`, we can construct a new vector of length `n + 1` (by appending the element to the beginning of the existing vector) in a way that is computationally primitive recursive.

For any type `α` that is Primcodable and natural number `n`, the function ` Vector.cons : α → Vector α n → Vector α (n + 1)` is a primitive recursive function.


theorem Int.emod_add_cancel_right : ∀ {m n k : ℤ} (i : ℤ), (m + i) % n = (k + i) % n ↔ m % n = k % n := by sorry

This theorem states that for all integers `m`, `n`, `k`, and `i`, the equivalence of the remainders of `m + i` and `k + i` when divided by `n` implies the equivalence of the remainders of `m` and `k` when divided by `n`. In other words, if `(m + i) mod n` equals `(k + i) mod n`, then `m mod n` equals `k mod n`. This theorem essentially asserts that the addition of a same integer `i` to two numbers `m` and `k` doesn't affect the congruence relation of `m` and `k` mod `n`.

If `m` is congruent to `k` modulo `n`, then `(m + i)` is congruent to `(k + i)` modulo `n` for any integer `i`.


Semiquot.ext

theorem Semiquot.ext : ∀ {α : Type u_1} {q₁ q₂ : Semiquot α}, q₁ = q₂ ↔ ∀ (a : α), a ∈ q₁ ↔ a ∈ q₂ := by sorry

The theorem `Semiquot.ext` states that for any type `α` and any two semiquotients `q₁` and `q₂` of that type, `q₁` is equal to `q₂` if and only if for any element `a` of type `α`, `a` is a member of `q₁` if and only if `a` is a member of `q₂`. In other words, two semiquotients are equal if they contain exactly the same elements.

Two semiquotients of a type are equal if and only if they contain the same elements.


theorem Mathlib.Algebra.Group.Units._auxLemma.27 :
    ∀ {M : Type u_1} [inst : Monoid M] [inst_1 : Subsingleton M] (a : M), IsUnit a = True := by sorry

The theorem `Mathlib.Algebra.Group.Units._auxLemma.27` states that for any type `M` that is a Monoid (a mathematical structure with a binary operation that is associative, and an identity element), and further assuming `M` is a Subsingleton (i.e., it has at most one distinct element), then any element `a` of `M` is a unit. In other words, every element `a` of such a Monoid `M` has a two-sided inverse. Here the two-sided inverse is defined in a bundled form, where an element `a` is a unit if there exists some `u` such that `u` when coerced (`↑u`) equals `a`.

In a Monoid of at most one element, every element is a unit with a two-sided inverse.


Equiv.Perm.IsCycle.inv

theorem Equiv.Perm.IsCycle.inv : ∀ {α : Type u_2} {f : Equiv.Perm α}, Equiv.Perm.IsCycle f → Equiv.Perm.IsCycle f⁻¹ :=
  by sorry

The theorem `Equiv.Perm.IsCycle.inv` states that for all types `α` and any permutation `f` of type `α`, if `f` is a cycle (i.e., it's a non-identity permutation where any two nonfixed points are related by repeated application of the permutation), then the inverse of `f` is also a cycle. This theorem, in essence, proposes that the cycle property is preserved under the operation of inversion.

If `f` is a cycle permution of type `α`, then the inverse `f⁻¹` is also a cycle.


theorem Set.image2_image2_image2_comm :
    ∀ {α : Type u_1} {β : Type u_3} {γ : Type u_5} {δ : Type u_7} {ε : Type u_9} {ε' : Type u_10} {ζ : Type u_11}
      {ζ' : Type u_12} {ν : Type u_13} {s : Set α} {t : Set β} {u : Set γ} {v : Set δ} {f : ε → ζ → ν} {g : α → β → ε}
      {h : γ → δ → ζ} {f' : ε' → ζ' → ν} {g' : α → γ → ε'} {h' : β → δ → ζ'},
      (∀ (a : α) (b : β) (c : γ) (d : δ), f (g a b) (h c d) = f' (g' a c) (h' b d)) →
        Set.image2 f (Set.image2 g s t) (Set.image2 h u v) = Set.image2 f' (Set.image2 g' s u) (Set.image2 h' t v) :=
  by sorry

The theorem `Set.image2_image2_image2_comm` states that for all sets `s` of type `α`, `t` of type `β`, `u` of type `γ`, and `v` of type `δ`, and for all binary functions `f : ε → ζ → ν`, `g : α → β → ε`, `h : γ → δ → ζ`, `f' : ε' → ζ' → ν`, `g' : α → γ → ε'`, and `h' : β → δ → ζ'`, if for all elements `a` from `α`, `b` from `β`, `c` from `γ` and `d` from `δ`, the function `f` applied to the results of `g` applied to `a` and `b` and `h` applied to `c` and `d` equals `f'` applied to the results of `g'` applied to `a` and `c` and `h'` applied to `b` and `d`, then the image of `f` with respect to the image of `g` with sets `s` and `t` and the image of `h` with sets `u` and `v` equals the image of `f'` with respect to the image of `g'` with sets `s` and `u` and the image of `h'` with sets `t` and `v`. This theorem expresses a kind of commutativity property for the operation of forming images of binary functions applied to elements of sets.

If for all `a: α, b: β, c: γ, d: δ, f, g, h, f', g', h', `image (f) (image (g) (s) × image (h) (u)) = image (f') (image (g') (s) × image (h') (t))`, then `image (f) (image (g) (s)) ⊆ image (f') (image (g') (s) × image (h') (t))` and `image (f') (image (g') (s) × image (h') (t)) ⊆ image (f) (image (g) (s))`.


/-- The embedding of a metric space in its completion is an isometry.  -/
theorem UniformSpace.Completion.coe_isometry : ∀ {α : Type u} [inst : PseudoMetricSpace α], Isometry ↑α := by sorry

The theorem states that the embedding of a pseudometric space into its completion is an isometry. In other words, for any pseudometric space `α`, the function that embeds `α` into its completion preserves the extended distance (`edist`) between any two points. This means that the extended distance between any two points in `α` is the same as the extended distance between their images in the completion of `α`.

The embedding of a pseudometric space into its completion preserves extended distances, i.e., for any pseudometric spaces `α`, the extended distance between any two points in `α` equals the extended distance between their images in the completion of `α`.


theorem Submodule.top_coe :
    ∀ {R : Type u_1} {M : Type u_3} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M],
      ↑⊤ = Set.univ :=
  by sorry

The theorem `Submodule.top_coe` states that for any type `R` representing a semiring, a type `M` representing an additive commutative monoid, and given that `M` is an `R`-module, the top submodule (denoted as `⊤`) when coerced to a set, is equal to the universal set (`Set.univ`). In mathematical terms, this means that all elements of the module type `M` are included in the top submodule, making it equivalent to the universal set of `M`.

For any semiring `R` and an additive commutative monoid `M` being an `R`-module, the top submodule of `M` equals the universal set of `M`.


theorem SimpleGraph.edgeSet_sdiff :
    ∀ {V : Type u} (G₁ G₂ : SimpleGraph V),
      SimpleGraph.edgeSet (G₁ \ G₂) = SimpleGraph.edgeSet G₁ \ SimpleGraph.edgeSet G₂ :=
  by sorry

This theorem states that for any two simple graphs, `G₁` and `G₂`, of the same type `V`, the edge set of the graph resulting from the difference of `G₁` and `G₂` (denoted `G₁ \ G₂`) is equal to the difference of the edge sets of `G₁` and `G₂`. That is, subtracting the edges in `G₂` from `G₁` is the same as subtracting the edge set of `G₂` from the edge set of `G₁`.

For any simple graphs `G₁` and `G₂` of the same type `V`, the edge difference `(Edge G₁) \ (Edge G₂)` equals the set difference of `Edge G₁` and `Edge G₂`.


theorem MeasureTheory.StronglyMeasurable.of_finite :
    ∀ {α : Type u_1} {β : Type u_2} [inst : Finite α] {x : MeasurableSpace α} [inst : MeasurableSingletonClass α]
      [inst : TopologicalSpace β] (f : α → β), MeasureTheory.StronglyMeasurable f :=
  by sorry

The theorem `MeasureTheory.StronglyMeasurable.of_finite` states that for any function `f` mapping from a finite type `α` to a topological space `β`, `f` is strongly measurable. In particular, this theorem applies when the measurable space over `α` is a measurable singleton class. Here, a function is defined as strongly measurable if it is the limit of simple functions.

A function from a finite type to a topological space is strongly measurable.


theorem IsKleinFour.card_four' :
    ∀ {G : Type u_1} [inst : Group G] [inst_1 : Fintype G] [inst : IsKleinFour G], Fintype.card G = 4 := by sorry

The theorem `IsKleinFour.card_four'` asserts that for any type `G` which forms a group, has a finite number of elements (i.e., is a `Fintype`), and satisfies the property of being a Klein four-group (`IsKleinFour`), the cardinality (or number of elements) of `G` is always equal to 4. This is a property specific to Klein four-groups, which are known in abstract algebra to always consist of precisely four elements.

A finite group with four elements and the property of being a Klein four-group has exactly 4 elements.


IsLprojection.mul

theorem IsLprojection.mul :
    ∀ {X : Type u_1} [inst : NormedAddCommGroup X] {M : Type u_2} [inst_1 : Ring M] [inst_2 : Module M X]
      [inst_3 : FaithfulSMul M X] {P Q : M}, IsLprojection X P → IsLprojection X Q → IsLprojection X (P * Q) :=
  by sorry

This theorem states that for any types `X` and `M`, where `X` is a normed add commutative group and `M` is a ring, and `X` is a module over `M` with faithful scalar multiplication, if `P` and `Q` are elements of `M` that are left projections onto `X`, then the product `P * Q` is also a left projection onto `X`. A left projection in this context is an idempotent linear transformation from the module to itself.

If `X` is a normed add commutative group and a faithful `M`-module, where `M` is a ring, and `P` and `Q` are left projections in `M` onto `X`, then `P * Q` is also a left projection onto `X`.


PiTensorProduct.ext

theorem PiTensorProduct.ext :
    ∀ {ι : Type u_1} {R : Type u_4} [inst : CommSemiring R] {s : ι → Type u_7} [inst_1 : (i : ι) → AddCommMonoid (s i)]
      [inst_2 : (i : ι) → Module R (s i)] {E : Type u_9} [inst_3 : AddCommMonoid E] [inst_4 : Module R E]
      {φ₁ φ₂ : (PiTensorProduct R fun i => s i) →ₗ[R] E},
      LinearMap.compMultilinearMap φ₁ (PiTensorProduct.tprod R) =
          LinearMap.compMultilinearMap φ₂ (PiTensorProduct.tprod R) →
        φ₁ = φ₂ :=
  by sorry

The theorem `PiTensorProduct.ext` states that for a given type `ι`, a commutative semiring `R`, a function `s : ι → Type u_7` wherein each `s i` is an additive commutative monoid and a module over `R`, and another module `E` over `R`, if there are two linear mappings `φ₁` and `φ₂` from the Pi Tensor Product of `s i` over `R` to `E` such that the composition of these mappings with the canonical multilinear map from `s` to the Pi Tensor Product equals, then `φ₁` and `φ₂` must be the same. In other words, if two linear maps agree on the output of the canonical multilinear map, they are the same.

Given a commutative semiring R, a type ι, and for each i in ι, a commutative additive monoid s(i) that is an R-module, if two linear maps from the Pi tensor product of the s(i) over R to an R-module E agree on the canonical multilinear map, then they are equal.


theorem Set.image_iInter_subset :
    ∀ {α : Type u_1} {β : Type u_2} {ι : Sort u_4} (s : ι → Set α) (f : α → β), f '' ⋂ i, s i ⊆ ⋂ i, f '' s i := by
  sorry

The theorem `Set.image_iInter_subset` states that for any types `α` and `β`, and for any indexing type `ι`, given a function `f` from `α` to `β` and a mapping `s` from `ι` to a set of `α`, the image under `f` of the intersection over all `ι` of `s i` is a subset of the intersection over all `ι` of the image of `s i` under `f`. In mathematical terms, for every function `f: α → β` and for every family of sets `(s_i)_{i in ι}`, we have `f([⋂ i, s_i]) ⊆ ⋂ i, f(s_i)`.

For any function `f: α → β` and family of sets `(s\_i): ι → Set α`, we have `f(⋂ i, s\_i) ⊆ ⋂ i, f(s\_i)`.


/-- Uses `left` co(ntra)variant. -/
theorem Left.nonneg_neg_iff :
    ∀ {α : Type u} [inst : AddGroup α] [inst_1 : LE α]
      [inst_2 : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] {a : α}, 0 ≤ -a ↔ a ≤ 0 :=
  by sorry

This theorem, `Left.nonneg_neg_iff`, states for all types `α` that are part of an `AddGroup` and also have a `≤` order defined, with covariance between addition and this order, the non-negativity of the negation of a value `a` is equivalent to `a` being less than or equal to zero. In simpler terms, it provides a condition to check if a certain element `a` is less than or equal to zero in the context of an additive group with a suitable order relation.

For types `α` in an additive group with a covariant order `≤` such that `a ≤ 0` if and only if `-a ≥ 0`, the negation of `a` is non-negative if and only if `a` is less than or equal to zero.