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

The theorem `MeasureTheory.OuterMeasure.ofFunction_le` states that for any type `α`, any function `m` that assigns extended nonnegative real numbers to sets of `α` such that the empty set is assigned 0, and any set `s` of `α`, the outer measure of `s` under the outer measure constructed from `m` (denoted as `MeasureTheory.OuterMeasure.ofFunction m`) is less than or equal to the measure `m` assigns to `s`. Essentially, this theorem expresses that the outer measure created from a measure function will never assign a larger measure to a set than the original measure function.

For any function `m` that assigns extended nonnegative real numbers to sets and sets the empty set to 0, the outer measure `MeasureTheory.OuterMeasure.ofFunction m` of a set `s` is less than or equal to `m(s)`.


theorem Real.toNNReal_one : Real.toNNReal 1 = 1 := by sorry

This theorem states that when we convert the real number 1 into a non-negative real number using the function `Real.toNNReal`, we get 1. In other words, the function `Real.toNNReal` when applied to 1 produces 1 as the output. The function `Real.toNNReal` is designed to provide zero if the input is less than zero, but since 1 is not less than zero, the function just returns 1 as expected.

The theorem asserts that `Real.toNNReal 1` equals 1.


NumberField.Embeddings.card

/-- The number of embeddings of a number field is equal to its finrank.  -/
theorem NumberField.Embeddings.card :
    ∀ (K : Type u_1) [inst : Field K] [inst_1 : NumberField K] (A : Type u_2) [inst_2 : Field A] [inst_3 : CharZero A]
      [inst_4 : IsAlgClosed A], Fintype.card (K →+* A) = FiniteDimensional.finrank ℚ K :=
  by sorry

The theorem states that the number of embeddings of a number field is equal to its rank. More specifically, for any type `K` with a field structure and a number field structure, and any type `A` with a field structure, a characteristic zero structure, and an algebraically closed structure, the number of ring homomorphisms from `K` to `A` (represented by `K →+* A`) is equal to the rank of `K` as a vector space over the rationals `ℚ` (represented by `FiniteDimensional.finrank ℚ K`). In essence, this theorem links the algebraic structure of a number field with its geometric or vector space structure.

The number of embeddings of a number field into an algebraically closed field of characteristic zero equals the finite dimensionality of the field as a vector space over the rationals.


theorem Nat.card_Icc : ∀ (a b : ℕ), (Finset.Icc a b).card = b + 1 - a := by sorry

This theorem states that for any two natural numbers `a` and `b`, the cardinality (or the number of elements) of the finite set which includes all natural numbers `x` such that `a ≤ x` and `x ≤ b` (also denoted as `[a, b]` in interval notation) is equal to `b + 1 - a`. In simpler terms, it calculates the number of natural numbers between `a` and `b`, inclusive, by subtracting `a` from `b` and adding one.

The cardinality of the finite set of natural numbers between `a` and `b` (inclusive) is equal to `b - a + 1`.


theorem directed_of : ∀ {α : Type u} (r : α → α → Prop) [inst : IsDirected α r] (a b : α), ∃ c, r a c ∧ r b c := by
  sorry

This theorem states that for any type `α` and a binary relation `r` on `α`, if `α` with `r` is directed (which means that for every pair of elements in `α`, there exists a third element in `α` that is related to both of them), then for any two elements `a` and `b` in `α`, there exists a third element `c` in `α` such that `a` is related to `c` and `b` is related to `c` via the relation `r`.

If `α` is a type with a directed binary relation `r`, then for any `a, b ∈ α`, there exists `c ∈ α` such that `r a c` and `r b c`.


theorem Finset.le_iff_subset : ∀ {α : Type u_1} {s₁ s₂ : Finset α}, s₁ ≤ s₂ ↔ s₁ ⊆ s₂ := by sorry

This theorem states that for any two finite sets `s₁` and `s₂` of the same type `α`, `s₁` is less than or equal to `s₂` if and only if `s₁` is a subset of `s₂`. In the context of sets, the less than or equal to relationship is defined in terms of subset inclusion.

For any finite sets `s₁` and `s₂` of type `α`, `s₁ ⊆ s₂` if and only if `s₁ ≤ s₂` (where `≤` denotes subset inclusion).


theorem CovBy.succ_eq :
    ∀ {α : Type u_1} [inst : PartialOrder α] [inst_1 : SuccOrder α] {a b : α}, a ⋖ b → Order.succ a = b := by sorry

The theorem `CovBy.succ_eq` states that for any partially ordered set type `α`, endowed with a successor order, and any two elements `a` and `b` of type `α`, if `a` is covered by `b` (denoted `a ⋖ b`), then the successor of `a` is equal to `b`. In other words, if `b` is the least element greater than `a` (and no element exists between `a` and `b`), then `b` is the successor of `a`.

If `a` is covered by `b` in a successor ordered set `α`, then `b` is the successor of `a` (i.e., `a < b` and there is no element `x` such that `a < x < b`).


theorem Finset.singleton_injective : ∀ {α : Type u_1}, Function.Injective singleton := by sorry

The theorem `Finset.singleton_injective` states that for all types `α`, the `singleton` function, which takes an element and returns a set containing only that element, is injective. In more mathematical terms, this means that for any two elements `a₁` and `a₂` of type `α`, if the singleton sets `{a₁}` and `{a₂}` are equal, then `a₁` and `a₂` themselves must be equal.

If two singleton sets in a type `α` are equal, then the elements they contain are equal.


theorem TypeVec.eq_of_drop_last_eq :
    ∀ {n : ℕ} {α : TypeVec.{u_1} (n + 1)} {β : TypeVec.{u_2} (n + 1)} {f g : TypeVec.Arrow α β},
      TypeVec.dropFun f = TypeVec.dropFun g → TypeVec.lastFun f = TypeVec.lastFun g → f = g :=
  by sorry

This theorem, `TypeVec.eq_of_drop_last_eq`, states that for any natural number `n`, and any two `n+1`-tuples of types `α` and `β`, if two arrows `f` and `g` from `α` to `β` have the same "drop function" and the same "last function", then these two arrows `f` and `g` are equal. The "drop function" is obtained by removing the first type from the arrow, and the "last function" is obtained by isolating the last type of the arrow. Essentially, this theorem establishes that an arrow in the category of `n+1`-tuples of types is determined by its effect on the initial `n` types and the last type.

Given natural number `n` and `n+1`-tuples of types `α` and `β`, if two functions `f : α → β` and `g : α → β` have equal drop functions (i.e., remove the first component) and equal last functions, then `f = g`.


theorem Ordinal.omega_isLimit : Ordinal.IsLimit Ordinal.omega := by sorry

The theorem `Ordinal.omega_isLimit` states that the ordinal `ω` is a limit ordinal. In other words, the ordinal number `ω`, which is defined as the order type of the set of natural numbers, is not zero and is not the successor of any other ordinal. This implies that for all ordinals `a` less than `ω`, the successor of `a` is also less than `ω`.

The ordinal `ω` is a limit ordinal, meaning it is neither zero nor the successor of any ordinal.


theorem Ideal.IsMaximal.eq_of_le :
    ∀ {α : Type u} [inst : Semiring α] {I J : Ideal α}, Ideal.IsMaximal I → J ≠ ⊤ → I ≤ J → I = J := by sorry

This theorem states that for any type `α` that forms a semiring, given two ideals `I` and `J` of `α`, if `I` is a maximal ideal, and `J` is not the entire set, then whenever `I` is a subset (or equal) of `J`, `I` must be equal to `J`. In other words, there can be no ideal `J` strictly larger than a maximal ideal `I` (unless `J` is the whole set).

If `α` is a semiring and `I` is a maximal ideal of `α` that is a proper subset of ideal `J`, then `I` equals `J`.


theorem symmDiff_eq_sup_sdiff_inf :
    ∀ {α : Type u_2} [inst : GeneralizedCoheytingAlgebra α] (a b : α), symmDiff a b = (a ⊔ b) \ (a ⊓ b) := by sorry

This theorem states that for any type `α` equipped with a structure of a generalized coheyting algebra, and for any elements `a` and `b` of that type, the symmetric difference of `a` and `b` (defined as `(a \ b) ⊔ (b \ a)`) is equal to the union of `a` and `b` minus the intersection of `a` and `b` (expressed as `(a ⊔ b) \ (a ⊓ b)`). In other words, the symmetric difference operation can also be computed by taking the union of the two elements and then removing their intersection.

For any type `α` with a generalized coalgebra structure and elements `a` and `b` in `α`, the symmetric difference `(a \ b) ⊔ (b \ a)` equals the set difference between the union of `a` and `b` and their intersection, `(a ⊔ b) \ (a ⊓ b)`.


theorem ENNReal.toReal_ofNat : ∀ (n : ℕ) [inst : Nat.AtLeastTwo n], (OfNat.ofNat n).toReal = OfNat.ofNat n := by sorry

The theorem `ENNReal.toReal_ofNat` states that for all natural numbers `n` that are at least two, the real number representation of `n` obtained using the `toReal` function on the `OfNat.ofNat n` object equals the `OfNat.ofNat n` object itself. In other words, for natural numbers that are at least two, converting them to `OfNat` objects and then to real numbers will not change their identity.

For all natural numbers `n` greater than or equal to 2, `OfNat.ofNat n = toReal (OfNat.ofNat n)`.


theorem padicValNat_def' : ∀ {p n : ℕ}, p ≠ 1 → 0 < n → ↑(padicValNat p n) = multiplicity p n := by sorry

The theorem `padicValNat_def'` states that for any two natural numbers `p` and `n`, given that `p` is not equal to `1` and `n` is positive, the `p`-adic valuation of `n`, when converted to an infinite natural number (`PartENat`), is equal to the multiplicity of `p` in `n`. In other words, the largest exponent `k` such that `p^k` divides `n` is the same whether we compute it using the `p`-adic valuation function or the multiplicity function.

For any prime number `p` and positive natural number `n`, the `p`-adic valuation of `n` equals the multiplicity of `p` in `n`.


theorem zero_lie :
    ∀ {L : Type v} {M : Type w} [inst : LieRing L] [inst_1 : AddCommGroup M] [inst_2 : LieRingModule L M] (m : M),
      ⁅0, m⁆ = 0 :=
  by sorry

This theorem states that for any types `L` and `M`, given `L` is a Lie ring, `M` is an additive commutative group, and `M` is a Lie ring module over `L`, the Lie bracket of zero from `L` and any element `m` from `M` is zero. In other words, the Lie bracket of zero with any element in a Lie ring module results in zero.

For any Lie ring `L`, additive commutative group `M`, and Lie ring module `M` over `L`, the Lie bracket of the zero element in `L` with any element in `M` is the zero element in `L`.


theorem self_le_add_left : ∀ {α : Type u} [inst : CanonicallyOrderedAddCommMonoid α] (a b : α), a ≤ b + a := by sorry

This theorem, `self_le_add_left`, states that for any canonically ordered additive commutative monoid `α`, and for any two elements `a` and `b` from `α`, `a` is less than or equal to the sum of `b` and `a`. In other words, for any two elements in a commutative monoid that follows a canonical order, the value of any element is always less than or equal to the sum of this element and any other element from the same monoid.

For any commutative additive monoid `α` and its elements `a` and `b`, `a ≤ b + a`.


theorem MeasureTheory.VectorMeasure.zero_apply :
    ∀ {α : Type u_1} {m : MeasurableSpace α} {M : Type u_3} [inst : AddCommMonoid M] [inst_1 : TopologicalSpace M]
      (i : Set α), ↑0 i = 0 :=
  by sorry

This theorem states that for any type α, with a corresponding measurable space `m`, and any type M, which forms an additive commutative monoid and a topological space, the zero vector measure applied to any set `i` of type α is zero. In other words, if we have a measure space and a specific set within that space, the measure of that set under the zero vector measure is always zero, regardless of the specific elements in the set.

For any measurable space (α, m), and any additive commutative monoid and topological space M, the zero vector measure assigns a measure of 0 to any set in α.


theorem CategoryTheory.Limits.biproduct.map_π :
    ∀ {J : Type w} {C : Type u} [inst : CategoryTheory.Category.{v, u} C]
      [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] {f g : J → C} [inst_2 : CategoryTheory.Limits.HasBiproduct f]
      [inst_3 : CategoryTheory.Limits.HasBiproduct g] (p : (j : J) → f j ⟶ g j) (j : J),
      CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.biproduct.map p)
          (CategoryTheory.Limits.biproduct.π g j) =
        CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.biproduct.π f j) (p j) :=
  by sorry

The theorem `CategoryTheory.Limits.biproduct.map_π` states that for any category `C`, which possesses zero morphisms and for any pair of functions `f` and `g` from `J` to `C`, such that `C` has biproducts of both `f` and `g`, and for any function `p` from elements of `J` to morphisms from `f j` to `g j` for each `j` in `J`, the composition of the map from the biproduct of `f` to the biproduct of `g` induced by `p` and the projection onto the `j`-th summand of the biproduct of `g` is equal to the composition of the projection onto the `j`-th summand of the biproduct of `f` and the `j`-th component of `p`. In mathematical terms, this says that the diagram involving the biproducts and the maps `p` commutes.

For any category with zero morphisms having biproducts of `f` and `g` from `J`, and a function `p` from `J` to morphisms from `f j` to `g j`, the diagram commuting between the projections and `p` components of the biproducts of `f` and `g` holds.


Computation.Results.mem

theorem Computation.Results.mem :
    ∀ {α : Type u} {s : Computation α} {a : α} {n : ℕ}, Computation.Results s a n → a ∈ s := by sorry

The theorem `Computation.Results.mem` states that for any type `α`, any computation `s` of type `α`, any element `a` of type `α`, and any natural number `n`, if the computation `s` terminates after `n` steps with the result `a` (denoted as `Computation.Results s a n`), then the element `a` is indeed an element in the computation `s` (denoted as `a ∈ s`). This means that if the computation terminates with a certain result, that result must come from the computation itself.

For any type `α`, computation `s` of type `α`, element `a` of type `α`, and natural number `n`, if `Computation.Results s a n`, then `a ∈ s`.


theorem Finset.comp_sup_eq_sup_comp :
    ∀ {α : Type u_2} {β : Type u_3} {γ : Type u_4} [inst : SemilatticeSup α] [inst_1 : OrderBot α]
      [inst_2 : SemilatticeSup γ] [inst_3 : OrderBot γ] {s : Finset β} {f : β → α} (g : α → γ),
      (∀ (x y : α), g (x ⊔ y) = g x ⊔ g y) → g ⊥ = ⊥ → g (Finset.sup s f) = Finset.sup s (g ∘ f) :=
  by sorry

The theorem `Finset.comp_sup_eq_sup_comp` states that for any sets `α`, `β`, and `γ`, given that `α` and `γ` are semilattice supremum and have the smallest element, and given a finite set `s` of type `β` and a function `f` from `β` to `α`, along with another function `g` from `α` to `γ`, if the function `g` preserves the supremum operation and maps the smallest element of `α` to the smallest element of `γ`, then applying the function `g` to the supremum of the image of `s` under `f` is the same as first applying `g ∘ f` to `s` and then taking the supremum. In mathematical terms, it would be expressed as `g(sup(s,f)) = sup(s, g ∘ f)`.

If `f: β → α`, `g: α → γ` preserve suprema and map the least elements respectively, then `g(sup(s, f s)) = sup(s, g ∘ f)` for any finite set `s` in `β`.


Set.Subsingleton.finite

theorem Set.Subsingleton.finite : ∀ {α : Type u} {s : Set α}, Set.Subsingleton s → Set.Finite s := by sorry

The theorem `Set.Subsingleton.finite` states that for any type `α` and any set `s` of type `α`, if `s` is a subsingleton (i.e., it contains at most one element), then `s` is finite. In other words, all subsingleton sets are finite. This theorem guarantees that any set with the property of having at most one element is finite.


theorem Polynomial.splits_of_splits_of_dvd :
    ∀ {K : Type v} {L : Type w} [inst : Field K] [inst_1 : Field L] (i : K →+* L) {f g : Polynomial K},
      f ≠ 0 → Polynomial.Splits i f → g ∣ f → Polynomial.Splits i g :=
  by sorry

This theorem states that for any two polynomials `f` and `g` over a field `K`, with `K` being mapped to a field `L` through a ring homomorphism `i`, if `f` is not the zero polynomial and `f` splits over `L` (meaning `f` is a zero polynomial or all of its irreducible factors have degree 1 when mapped to `L`), and if `g` divides `f`, then `g` also splits over `L`. Simply, if a polynomial is divisible by another polynomial and the original one splits into linear factors, then the dividing polynomial also splits into linear factors.

If a polynomial `f` over a field `K` splits into linear factors over an extension field `L` via a ring homomorphism `i`, and `g` is a divisor of `f` over `K`, then `g` also splits into linear factors over `L`.


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

This theorem, `multiplicity.pow_multiplicity_dvd`, asserts that for any type `α` that forms a Monoid, and any two elements `a` and `b` of that type, if `a` has finite multiplicity in `b`, then `b` is divisible by `a` raised to the power of the multiplicity of `a` in `b`. In other words, if `a` appears finitely many times in `b` as a factor, then `b` is divisible by `a` to the power of that count. This theorem is fundamental to understanding the structure of elements in a monoid that can be expressed as products of other elements.

For any monoid type `α` and elements `a, b` of `α`, if `a` has finite multiplicity in `b`, then `b` is divisible by `a` raised to that power.


theorem UniformSpace.Completion.continuous_map₂ :
    ∀ {α : Type u_1} [inst : UniformSpace α] {β : Type u_2} [inst_1 : UniformSpace β] {γ : Type u_3}
      [inst_2 : UniformSpace γ] {δ : Type u_4} [inst_3 : TopologicalSpace δ] {f : α → β → γ}
      {a : δ → UniformSpace.Completion α} {b : δ → UniformSpace.Completion β},
      Continuous a → Continuous b → Continuous fun d => UniformSpace.Completion.map₂ f (a d) (b d) :=
  by sorry

The theorem `UniformSpace.Completion.continuous_map₂` states that for any three types `α`, `β`, and `γ` each equipped with a uniform structure, and a fourth type `δ` with a topological structure, given a continuous function `a: δ → UniformSpace.Completion α` and a continuous function `b: δ → UniformSpace.Completion β`, the mapping function `f: α → β → γ` can be lifted to a function on the completions `UniformSpace.Completion.map₂ f (a d) (b d)` and this function is continuous. In other words, the lifted function `f` is a continuous function when operating on the Hausdorff completions of `α` and `β`.

Given continuous functions from a Hausdorff space with uniform structure to the completions of two uniform spaces, their composition can be lifted to a continuous function between the completions.


theorem ne_zero_of_irreducible_X_pow_sub_C :
    ∀ {K : Type u} [inst : Field K] {n : ℕ} {a : K}, Irreducible (Polynomial.X ^ n - Polynomial.C a) → n ≠ 0 := by sorry

The theorem `ne_zero_of_irreducible_X_pow_sub_C` states that for any field `K`, any natural number `n`, and any element `a` of `K`, if the polynomial `X^n - C a` is irreducible, then `n` is not equal to zero. Here, `X` denotes the polynomial variable and `C a` represents a constant polynomial with coefficient `a`. Irreducible, in the context of polynomials, means the polynomial cannot be factored into two non-trivial polynomials.

If `X^n - Ca` is an irreducible polynomial over a field `K`, then `n` is different from zero.


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

The theorem `Computable₂.comp` states that, given types `α`, `β`, `γ`, and `σ` that have a `Primcodable` instance, and given functions `f` from `β` and `γ` to `σ`, `g` from `α` to `β`, and `h` from `α` to `γ`, if `f` is a computable function of two variables, and `g` and `h` are computable functions of one variable, then the function that takes an input `a` of type `α` and returns the result of applying `f` to `g(a)` and `h(a)` is also a computable function. This theorem essentially asserts the closure of computable functions under composition.

If `f: β → σ`, `g: α → β`, and `h: α → γ` are computable functions, and `f` is computable in two variables, then the function `x ↦ f (g x) (h x)` is computable.


theorem Set.add_subset_add :
    ∀ {α : Type u_2} [inst : Add α] {s₁ s₂ t₁ t₂ : Set α}, s₁ ⊆ t₁ → s₂ ⊆ t₂ → s₁ + s₂ ⊆ t₁ + t₂ := by sorry

The theorem `Set.add_subset_add` states that for any type `α` that has an addition operation, given two sets `s₁` and `s₂` of type `α`, and two other sets `t₁` and `t₂` of the same type, if `s₁` is a subset of `t₁` and `s₂` is a subset of `t₂`, then the set of all elements obtained by adding an element of `s₁` to an element of `s₂` is a subset of the set of all elements obtained by adding an element of `t₁` to an element of `t₂`. In mathematical terms, if $s₁ ⊆ t₁$ and $s₂ ⊆ t₂$, then $s₁ + s₂ ⊆ t₁ + t₂$.

If sets $s\_1$ and $s\_2$ are subsets of $t\_1$ and $t\_2$, respectively, then $s\_1 + s\_2 \subseteq t\_1 + t\_2$, where $+$ denotes addition of elements of a type with defined addition operation.


theorem ContinuousMap.coe_sub :
    ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] [inst_2 : Sub β]
      [inst_3 : ContinuousSub β] (f g : C(α, β)), ⇑(f - g) = ⇑f - ⇑g :=
  by sorry

This theorem states that for any two continuous functions `f` and `g` from a topological space `α` to a topological space `β` (where `β` also has a subtraction operation and the subtraction operation is continuous), the pointwise subtraction of `f` and `g` is the same as the subtraction of the continuous maps `f` and `g`. In mathematical terms, for all `x` in `α`, `(f - g)(x) = f(x) - g(x)`.

For any continuous functions `f` and `g` from a topological space `α` to a topological space `β` with a continuous subtraction operation, the pointwise subtraction `(f - g)(x)` equals the function subtraction `f(x) - g(x)` for all `x` in `α`.


theorem Algebra.FormallyEtale.iff_unramified_and_smooth :
    ∀ {R : Type u} [inst : CommSemiring R] {A : Type u} [inst_1 : Semiring A] [inst_2 : Algebra R A],
      Algebra.FormallyEtale R A ↔ Algebra.FormallyUnramified R A ∧ Algebra.FormallySmooth R A :=
  by sorry

This theorem states that for any commutative semiring R and any semiring A that is an algebra over R, A is formally etale (i.e., it satisfies certain smoothness and flatness conditions) if and only if A is both formally unramified (i.e., all of its derivations are trivial) and formally smooth (i.e., it can be locally deformed into a regular ring).

A commutative semiring A, which is an algebra over a commutative semiring R, is formally etale if and only if it is both formally unramified and formally smooth.


/-- **Alias** of the reverse direction of `sub_lt_self_iff`. -/
theorem sub_lt_self :
    ∀ {α : 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 : α}, 0 < b → a - b < a :=
  by sorry

This theorem, `sub_lt_self`, states that for any type `α` that is an additive group and has a less than (`<`) operation, if the operation is covariant, then for any element `a` in `α` and any `b` in `α` such that `b` is greater than 0, the difference of `a` and `b` is strictly less than `a`. In simpler terms, within a certain mathematical structure, subtracting a positive quantity from a number results in a value that's smaller than the original number.

For any additive group type `α` with a covariant `<` operation, for all `a` in `α` and positive `b` in `α`, `a - b` is strictly less than `a`.


theorem Fin.predAbove_of_castSucc_lt :
    ∀ {n : ℕ} (p : Fin n) (i : Fin (n + 1)) (h : Fin.castSucc p < i) (hi : optParam (i ≠ 0) ⋯),
      Fin.predAbove p i = Fin.pred i hi :=
  by sorry

This theorem, `Fin.predAbove_of_castSucc_lt`, states that for all natural numbers `n`, given a finite number `p` of order `n`, another finite number `i` of order `n+1`, and a proof `h` that `Fin.castSucc p` is less than `i`, and an optional parameter `hi` which defaults to the proof that `i ≠ 0`, then applying the function `Fin.predAbove` to `p` and `i` is equal to applying the function `Fin.pred` to `i` with the proof `hi`. Essentially, it's describing a specific condition under which the subtraction of one from `i` in the context of `Fin.predAbove` and `Fin.pred` will yield the same result.

For all natural numbers `n`, if `p` is a finite number of order `n`, `i` is a finite number of order `n+1`, and `Fin.castSucc p` is less than `i` with proof `h`, then `Fin.predAbove p i h` equals `Fin.pred i (option.some h)` (or `Fin.pred i h` if `i ≠ 0`).


theorem Complex.cos_ofReal_im : ∀ (x : ℝ), (Complex.cos ↑x).im = 0 := by sorry

This theorem states that for every real number `x`, the imaginary part of the complex cosine of `x` is zero. In other words, if you take any real number, convert it to a complex number (by treating it as the real part and adding zero as the imaginary part), and take the cosine of that complex number, the imaginary part of the result will always be zero. This is consistent with the usual definition of the cosine function on the real numbers, which always returns a real number.

For all real numbers x, the complex cosine of x has zero imaginary part.


theorem Cardinal.ord_le : ∀ {c : Cardinal.{u_3}} {o : Ordinal.{u_3}}, Cardinal.ord c ≤ o ↔ c ≤ Ordinal.card o := by
  sorry

This theorem, `Cardinal.ord_le`, states that for any cardinal `c` and any ordinal `o`, the ordinal corresponding to `c` (i.e., the least ordinal whose cardinal is `c`) is less than or equal to `o` if and only if `c` is less than or equal to the cardinal of `o` (i.e., the cardinality of any type on which a relation with order type `o` is defined). This connects the concepts of cardinal and ordinal numbers in a fundamental way, showing that their orders align under certain conditions.

The ordinal representing a cardinal is less than or equal to an ordinal `o` if and only if the cardinal is less than or equal to the cardinality of the type carrying `o`'s order structure.


theorem Mathlib.Algebra.Group.Basic._auxLemma.18 :
    ∀ {G : Type u_3} [inst : InvolutiveNeg G] {a b : G}, (-a = -b) = (a = b) := by sorry

This theorem, named `Mathlib.Algebra.Group.Basic._auxLemma.18`, states that for all types `G` that have an `InvolutiveNeg` structure (i.e., a type where the negation operation is its own inverse), if two elements `a` and `b` of type `G` exist, then the equality of the negations of `a` and `b` is equivalent to the equality of `a` and `b` themselves. In simpler terms, in such a group, if the negation of `a` equals the negation of `b`, then `a` must be equal to `b`, and vice versa.

In a group with an InvolutiveNeg structure, the negation of two elements are equal if and only if the elements are equal.


theorem Mathlib.Algebra.Group.Basic._auxLemma.10 :
    ∀ {M : Type u} [inst : AddRightCancelMonoid M] {a b : M}, (a + b = b) = (a = 0) := by sorry

This theorem, from the Mathlib library in the Algebra.Group.Basic module, is about right-cancellable monoids. Specifically, it states that for any type `M` which has the structure of a right-cancellable monoid (denoted by `AddRightCancelMonoid M`), and any two elements `a` and `b` of `M`, the equation `a + b = b` is true if and only if `a = 0`. In other words, adding `a` to `b` only results in `b` if `a` is the zero element in the monoid.

For any right-cancellable monoid `M`, the equation `a +b = b` holds if and only if `a = 0`.


IsIrreducible.closure

/-- **Alias** of the reverse direction of `isIrreducible_iff_closure`. -/
theorem IsIrreducible.closure :
    ∀ {X : Type u_1} [inst : TopologicalSpace X] {s : Set X}, IsIrreducible s → IsIrreducible (closure s) := by sorry

This theorem states that if a set `s` is irreducible in a topological space `X`, then the closure of `s` is also irreducible in `X`. Here, a set is said to be irreducible if it is nonempty and there is no non-trivial pair of disjoint open subsets within it. The closure of a set `s` is defined as the smallest closed set that contains `s`.

If a nonempty set `s` is irreducible in a topological space `X`, then the closure of `s` is also irreducible in `X`.


theorem Nat.factors_one : Nat.factors 1 = [] := by sorry

The theorem `Nat.factors_one` states that the prime factorization of 1 is an empty list. In other words, the number 1 does not have any prime factors.

The theorem `Nat.factors_one` asserts that the prime factorization of 1 is the empty list.


theorem Vector.ofFn_get : ∀ {n : ℕ} {α : Type u_1} (v : Vector α n), Vector.ofFn (Vector.get v) = v := by sorry

The theorem `Vector.ofFn_get` states that for any natural number `n` and any type `α`, given a vector `v` of length `n` with elements of type `α`, if we create a new vector by applying the function `Vector.get v` to each element of a `Fin n` type (essentially, this is a function that retrieves the elements of `v`), we get back the original vector `v`. In other words, this theorem says that retrieving all elements from a vector and constructing a new vector from them gives us the original vector.

For any natural number `n` and type `α`, the application of the `Vector.get` function to each element of a vector `v` of length `n` over `α` results in the original vector `v`. In mathematical notation: for all `n : ℕ` and `α`, `∀ i : Fin n, Vector.get v i = v.get i`.


theorem Filter.inter_mem_inf : ∀ {α : Type u} {f g : Filter α} {s t : Set α}, s ∈ f → t ∈ g → s ∩ t ∈ f ⊓ g := by sorry

The theorem `Filter.inter_mem_inf` states that for any given type `α`, and any given filters `f` and `g` over this type, if a set `s` is in filter `f` and another set `t` is in filter `g`, then the intersection of sets `s` and `t` is in the infimum (greatest lower bound) of filters `f` and `g`. In other words, the intersection of any two sets each belonging to different filters also belongs to the filter which is the infimum of the original two filters.

If filters $f$ and $g$ over type $\alpha$ have a common lower bound, then the intersection of any sets in $f$ and any sets in $g$ is in this lower bound.


theorem ENNReal.tsum_comm :
    ∀ {α : Type u_1} {β : Type u_2} {f : α → β → ENNReal}, ∑' (a : α) (b : β), f a b = ∑' (b : β) (a : α), f a b := by
  sorry

This theorem, `ENNReal.tsum_comm`, states that for any two types `α` and `β`, and any function `f` mapping from `α` to `β` to the extended nonnegative real numbers `ENNReal`, the sum over `α` first and then `β` is equal to the sum over `β` first and then `α`. In mathematical terms, the theorem asserts the commutativity of the double summation, i.e., $\sum'_{a} \sum'_{b} f(a, b) = \sum'_{b} \sum'_{a} f(a, b)$, where the summation is over all elements of the respective types.

The theorem asserts that for any function from two types to extended nonnegative real numbers, the order of double summation commutes: $\sum'_{a} \sum'_{b} f(a, b) = \sum'_{b} \sum'_{a} f(a, b)$.


theorem Rat.mul_def : ∀ (a b : ℚ), a * b = Rat.normalize (a.num * b.num) (a.den * b.den) ⋯ := by sorry

This theorem states that for any two rational numbers `a` and `b`, the product `a * b` is equal to the result of normalizing the rational number formed by multiplying the numerators of `a` and `b` as the new numerator and the denominators of `a` and `b` as the new denominator. The normalization process involves dividing the numerator and the denominator by their greatest common divisor (gcd) to ensure the resulting rational number is in its simplest form.

For any rational numbers `a` and `b`, `a * b` is equivalent to the rational number obtained by multiplying the numerators of `a` and `b` and then normalizing the result by dividing numerator and denominator by their greatest common divisor.


theorem Bool.sizeOf_eq_one : ∀ (b : Bool), sizeOf b = 1 := by sorry

This theorem states that the size of any Boolean value is 1. In other words, for every Boolean value 'b', when we calculate its size using the 'sizeOf' function, we will always get the result as 1.

For all Boolean values 'b' in Lean, the size is 1: size Lean.Bool b = 1.


theorem ContinuousMap.coe_neg :
    ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] [inst_2 : Neg β]
      [inst_3 : ContinuousNeg β] (f : C(α, β)), ⇑(-f) = -⇑f :=
  by sorry

This theorem states that for any continuous function `f` from a topological space `α` to another topological space `β` that has a negation operation and this negation operation is continuous, the negation of the function `f` is equal to the function that maps each point in `α` to the negation of its image under `f`. In other words, negating the function `f` is the same as applying the function `f` and then negating the result.

For any continuous function `f` from a topological space `α` to a topological space `β` with a continuous negation operation, the negation of `f` equals the function that maps each point in `α` to the negation of its image under `f`.


theorem MeasureTheory.AEFinStronglyMeasurable.finStronglyMeasurable_mk :
    ∀ {α : Type u_1} {β : Type u_2} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} [inst : TopologicalSpace β]
      {f : α → β} [inst_1 : Zero β] (hf : MeasureTheory.AEFinStronglyMeasurable f μ),
      MeasureTheory.FinStronglyMeasurable (MeasureTheory.AEFinStronglyMeasurable.mk f hf) μ :=
  by sorry

This theorem states that for any function `f` from type `α` to `β`, where `α` is a measurable space, `β` is a topological space with zero, and `μ` is a measure on `α`, if `f` is almost everywhere finitely strongly measurable with respect to `μ` (i.e., it almost everywhere equals to the limit of a sequence of simple functions with finite measure support), then the sequence of simple functions obtained by applying the `MeasureTheory.AEFinStronglyMeasurable.mk` method to `f` is also finitely strongly measurable with respect to `μ`. In other words, this sequence of simple functions converges to `f` and each simple function in the sequence has a finite measure support.

If a function `f` from a measurable space `α` to a topological space `β` with zero is almost everywhere finitely strongly measurable with respect to a measure `μ` on `α`, then the sequence of simple functions obtained by applying `MeasureTheory.AEFinStronglyMeasurable.mk` to `f` is also finitely strongly measurable with respect to `μ`.


theorem pow_mul' : ∀ {M : Type u} [inst : Monoid M] (a : M) (m n : ℕ), a ^ (m * n) = (a ^ n) ^ m := by sorry

This theorem states that for any given type `M` that forms a monoid, for any element `a` of type `M`, and any two natural numbers `m` and `n`, the power of `a` raised to the product of `m` and `n` is equal to the power of `a` raised to `n`, and then that result raised to `m`. In more mathematical terms, it's saying that \(a^{m*n} = (a^n)^m\) for any monoid element `a` and natural numbers `m` and `n`.

For any monoid `M` and element `a` in `M`, and natural numbers `m` and `n`, the equality `a^(mn) = (a^n)^m` holds.


theorem Ordinal.not_lt_zero : ∀ (o : Ordinal.{u_3}), ¬o < 0 := by sorry

This theorem states that for any ordinal 'o', it is not possible for 'o' to be less than zero. In other words, no ordinal number is less than zero.


theorem iff_false_iff : ∀ {a : Prop}, (a ↔ False) ↔ ¬a := by sorry

This theorem states that for any proposition 'a', the biconditional of 'a' and 'False' is equivalent to the negation of 'a'. In other words, 'a' is equivalent to 'False' if and only if 'a' is not true.

For all propositions 'a', 'a' is equivalent to False if and only if not 'a'.


Asymptotics.IsEquivalent.isBigO

theorem Asymptotics.IsEquivalent.isBigO :
    ∀ {α : Type u_1} {β : Type u_2} [inst : NormedAddCommGroup β] {u v : α → β} {l : Filter α},
      Asymptotics.IsEquivalent l u v → u =O[l] v :=
  by sorry

This theorem states that for any two functions `u` and `v` mapping from some type `α` to a normed add-commutative group `β`, and a filter `l` on `α`, if `u` and `v` are asymptotically equivalent along `l` (which means the difference between `u` and `v` is infinitesimal as `x` converges along `l`), then `u` is a big-O of `v` along `l`. In other words, `u` is bounded above by some constant multiple of `v` when `x` converges along `l`. This is a statement about the limiting behavior of functions when inputs approach specific values.

If functions `u` and `v` from type `α` to a normed add-commutative group `β` are asymptotically equivalent along filter `l`, then `u` is a big-O of `v` along `l`, i.e., there exists a constant `C` such that `∀ x (x ∈ l → ||u x - v x|| ≤ C * ||v x||` where `||.||` denotes the norm.


/-- A specialization of `iInter₂_subset`.  -/
theorem Set.biInter_subset_of_mem :
    ∀ {α : Type u_1} {β : Type u_2} {s : Set α} {t : α → Set β} {x : α}, x ∈ s → ⋂ x ∈ s, t x ⊆ t x := by sorry

The `Set.biInter_subset_of_mem` theorem states that for any types `α` and `β`, a set of elements of type `α` denoted by `s`, a function `t` mapping elements of `α` to sets of `β`, and an element `x` of type `α`, if `x` is an element of set `s`, then the intersection of all sets `t x` for each `x` in `s` is a subset of `t x`. In mathematical terms, it asserts that if $x \in s$, then $\bigcap_{x \in s} t(x) \subseteq t(x)$.

For any sets `s` of type `α` and function `t` mapping elements of `α` to sets of `β`, if `x` is an element of `s`, then `t x` is a subset of the intersection of all `t(y)` for `y` in `s`. In mathematical notation, $x \in s \implies t(x) \subseteq \bigcap\_{y \in s} t(y)$.


theorem AlgebraicGeometry.quasiCompact_eq_affineProperty :
    @AlgebraicGeometry.QuasiCompact =
      AlgebraicGeometry.targetAffineLocally AlgebraicGeometry.QuasiCompact.affineProperty :=
  by sorry

The theorem `AlgebraicGeometry.quasiCompact_eq_affineProperty` establishes an equivalence between the property of being quasi-compact and having the affine target morphism property. Specifically, it states that a geometric object (or scheme, in algebraic geometry terms) is quasi-compact if and only if for every affine open subset of that object, the restriction of the morphism function on that subset also has the property of being quasi-compact. This theorem is thus about connecting a global property (quasi-compactness of the whole scheme) with a local property (quasi-compactness on every affine open subset).

A geometric object is quasi-compact if and only if every its affine open subset is quasi-compact.


theorem Int.emod_lt : ∀ (a : ℤ) {b : ℤ}, b ≠ 0 → a % b < |b| := by sorry

This theorem states that for any integer `a` and any non-zero integer `b`, the remainder of `a` divided by `b` (denoted as `a % b`) is less than the absolute value of `b` (denoted as `|b|`). This is a formalization of the standard property of modulus in arithmetic, asserting that the remainder when a number is divided by another is always less than the divisor, in absolute value.

For any integers `a` and `b` with `b` non-zero, `|a % b| < |b|`.


theorem Polynomial.coeff_one :
    ∀ {R : Type u} [inst : Semiring R] {n : ℕ}, Polynomial.coeff 1 n = if n = 0 then 1 else 0 := by sorry

The theorem `Polynomial.coeff_one` states that for any semiring `R` and any natural number `n`, the coefficient of `X^n` in a polynomial equal to 1 is 1 if `n` equals 0, and is 0 otherwise. In other words, it says that a constant polynomial of 1 only has a non-zero coefficient for `X^0` (the constant term), and all other coefficients are zero.

For any semiring R and natural number n, the coefficient of X^n in the polynomial equal to 1 is 1 if n = 0, and 0 otherwise.


theorem Real.sqrt_mul_self : ∀ {x : ℝ}, 0 ≤ x → Real.sqrt (x * x) = x := by sorry

This theorem states that for any real number `x` that is greater than or equal to zero, the square root of the square of `x` is equal to `x`. In mathematical terms, for all real numbers `x` such that `x` is greater than or equal to zero, this is expressed as $\sqrt{x^2} = x$.

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


theorem IsPGroup.of_card :
    ∀ {p : ℕ} {G : Type u_1} [inst : Group G] [inst_1 : Fintype G] {n : ℕ}, Fintype.card G = p ^ n → IsPGroup p G := by
  sorry

This theorem states that for any natural number `p`, any type `G` equipped with a group structure, and any natural number `n`, if the number of elements in `G` (its cardinality) equals `p` raised to the `n`-th power, then `G` is a p-group. In other words, if the cardinality of a group is a power of a prime number `p`, then every element in the group can be expressed as `g` raised to the power of `p` raised to a natural number `k` equals the identity element of the group (or `g ^ p ^ k = 1` in Lean syntax).

If the cardinality of a group `G` is a power `p^n` of a prime number `p`, then every element in `G` is of the form `g^(p^k)` for some natural number `k`.


theorem Mathlib.GroupTheory.Subgroup.Basic._auxLemma.36 :
    ∀ {G : Type u_1} [inst : Group G] {x : G}, (x ∈ ⊥) = (x = 1) := by sorry

This theorem states that for any type `G` that has a group structure, and any element `x` of `G`, `x` belongs to the trivial subgroup (denoted by `⊥` in this context) if and only if `x` equals the identity element of the group (`1` in this context). In mathematical terms, it is saying that the trivial subgroup of a group is exactly the set containing just the identity element.

The trivial subgroup of a group is equal to the set of its identity element.


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

This theorem states that for any type `G` which is an additive group, and for any element `x` of `G`, `x` belongs to the trivial subgroup if and only if `x` is the additive identity (0) of the group. In mathematical terminology, this theorem asserts that an element belongs to the trivial subgroup of an additive group if and only if that element is the zero element.

An element of an additive group is in the trivial subgroup if and only if it is the additive identity.


theorem tendsto_pow_atTop_nhds_zero_of_lt_one :
    ∀ {𝕜 : Type u_4} [inst : LinearOrderedField 𝕜] [inst_1 : Archimedean 𝕜] [inst_2 : TopologicalSpace 𝕜]
      [inst_3 : OrderTopology 𝕜] {r : 𝕜}, 0 ≤ r → r < 1 → Filter.Tendsto (fun n => r ^ n) Filter.atTop (nhds 0) :=
  by sorry

This theorem, `tendsto_pow_atTop_nhds_zero_of_lt_one`, states that for any linearly ordered field `𝕜` (which also has the structures of an Archimedean ordered set and a topological space with an order topology), if we have a non-negative element `r` that is less than 1, the function which maps a number `n` to `r^n` converges to 0 as `n` tends to infinity. In other words, for any sequence where each term is `r` raised to the index of the term in the sequence (`r^n`), as the term index goes to infinity (`Filter.atTop`), the term values get arbitrarily close to zero (`nhds 0`).

For any Archimedean ordered field endowed with an order topology, if $0 < r < 1$, then $r^n$ converges to $0$ as $n$ approaches infinity.


/-- Proof used in definition of `Finset.noncommProd`  -/
theorem Finset.noncommProd_lemma :
    ∀ {α : Type u_3} {β : Type u_4} [inst : Monoid β] (s : Finset α) (f : α → β),
      (Set.Pairwise ↑s fun a b => Commute (f a) (f b)) → Set.Pairwise {x | x ∈ Multiset.map f s.val} Commute :=
  by sorry

The theorem `Finset.noncommProd_lemma` states that for any types α and β where β is a Monoid, given a finite set of elements of type α, `s`, and a function `f` mapping elements of α to β, if for every pair of distinct elements in set s, `f` applied to these elements commute (i.e., their order doesn't affect the result), then it is also true that Commute holds pairwise for the set of elements obtained by mapping `f` over the multiset derived from `s`. In other words, the theorem ensures that commutativity is preserved when applying the function `f` to all elements of the set `s`.

If `f : α -> β` is a function between types `α` and `β` where `β` is a monoid, and `s : Finset α` is a finite set such that `f (a1) * f (a2) = f (a2) * f (a1)` for all distinct `a1, a2 in s`, then `f''(s)` is a commutative multiset in `β`, where `f'' : Finset α -> Finset β` is the function that maps each set to the multiset of images under `f`.


theorem isClosed_biInter :
    ∀ {X : Type u} {α : Type u_1} [inst : TopologicalSpace X] {s : Set α} {f : α → Set X},
      (∀ i ∈ s, IsClosed (f i)) → IsClosed (⋂ i ∈ s, f i) :=
  by sorry

This theorem states that for any types `X` and `α`, given a topological space on `X`, a set `s` of elements of type `α`, and a function `f` from `α` to a set of `X`, if every set `f i` where `i` belongs to `s` is closed in the topological sense, then the intersection of all such sets `f i` is also a closed set. In other words, the intersection of an arbitrary collection of closed sets, indexed by a set `s`, remains closed.

Given a topological space `X`, any family of closed subsets `{f(i) | i ∈ s}`, where `s` is a set and `f : α -> X` is a function from a type `α` to `X`, their intersection is closed in `X`.


/-- The image of a dense set under a continuous map with dense range is a dense set.  -/
theorem DenseRange.dense_image :
    ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {s : Set X} {f : X → Y},
      DenseRange f → Continuous f → Dense s → Dense (f '' s) :=
  by sorry

The theorem `DenseRange.dense_image` asserts that, for any two topological spaces `X` and `Y` and a function `f` from `X` to `Y`, if `f` has dense range (meaning the set of its output values is dense in `Y`) and `f` is continuous, and if a set `s` in `X` is dense, then the image of `s` under `f` (denoted as `f '' s`) is also dense in `Y`. In other words, applying a continuous function with dense range to a dense set preserves the property of being dense.

If a continuous function with dense range maps a dense subset to a subset with the same density property in its domain.


theorem List.rotate_eq_rotate' : ∀ {α : Type u} (l : List α) (n : ℕ), List.rotate l n = List.rotate' l n := by sorry

This theorem states that for any list `l` of elements of an arbitrary type `α`, and for any natural number `n`, the function `List.rotate` applied to `l` and `n` returns the same result as the function `List.rotate'` applied to `l` and `n`. In other words, irrespective of the type of elements in the list and the number of times you wish to rotate the list, both `List.rotate` and `List.rotate'` yield the same output. This establishes the equivalence of `List.rotate` and `List.rotate'` for all lists and natural numbers.

For any list `l` of type `α` and natural number `n`, `List.rotate l n` equals `List.rotate' l n`.


theorem SetTheory.PGame.turnBound_of_right :
    ∀ {S : Type u} [inst : SetTheory.PGame.State S] {s t : S},
      t ∈ SetTheory.PGame.State.r s →
        ∀ (n : ℕ), SetTheory.PGame.State.turnBound s ≤ n + 1 → SetTheory.PGame.State.turnBound t ≤ n :=
  by sorry

This theorem, `SetTheory.PGame.turnBound_of_right`, states that for any type `S` that has an instance of `SetTheory.PGame.State`, and for any two states `s` and `t` of `S`, if `t` is in the successor relation of `s` (denoted by `SetTheory.PGame.State.r s`), then for any natural number `n`, if the turn-bound of `s` (denoted by `SetTheory.PGame.State.turnBound s`) is less than or equal to `n + 1`, it follows that the turn-bound of `t` (denoted by `SetTheory.PGame.State.turnBound t`) is less than or equal to `n`. In plain language, this means that if you consider a game where `s` and `t` are possible states, if `t` can be reached from `s` and the turn-bound of `s` is at most `n+1`, then the turn-bound of `t` will be at most `n`. This places an upper limit on the number of turns that the game can be in state `t` after moving from state `s`.

For any type `S` with `SetTheory.PGame.State`, if `s` and `t` are states in `S` with `t` being the successor of `s`, and the turn-bound of `s` is less than or equal to `n + 1`, then the turn-bound of `t` is less than or equal to `n`.


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

The theorem `MvPolynomial.coeff_monomial` states that for any commutative semiring `R`, types `σ` and `R`, and for any pair of natural number-valued functions `m` and `n` on `σ`, and any element `a` of `R`, the coefficient of the monomial `m` in the multi-variable polynomial obtained by applying the `MvPolynomial.monomial` function to `n` and `a`, is `a` if `n` equals `m`, and `0` otherwise. This theorem essentially captures how the coefficient function interacts with the construction of a monomial: if the monomial we're considering is the one we used to construct the polynomial, its coefficient is just the coefficient we used in the construction; if not, the coefficient is zero.

For any commutative semiring R, function m : σ -> Nat, and elements a in R and n in σ, the coefficient of the monomial MvPolynomial.monomial n in the polynomial obtained by applying MvPolynomial.coeff_monomial a m, is a if n equals m, and 0 otherwise.


theorem normalize_lcm :
    ∀ {α : Type u_1} [inst : CancelCommMonoidWithZero α] [inst_1 : NormalizedGCDMonoid α] (a b : α),
      normalize (lcm a b) = lcm a b :=
  by sorry

The theorem `normalize_lcm` states that for any type `α` that is a cancel commutative monoid with zero and a normalized GCD monoid, and for any elements `a` and `b` of `α`, the normalized least common multiple (LCM) of `a` and `b` is equal to the LCM of `a` and `b`. In other words, the operation of normalizing the LCM doesn't change its value in a normalized GCD monoid.

In a cancel commutative monoid with zero and a normalized GCD monoid, the normalized LCM of two elements is equal to the unnormalized LCM.


/-- A least element of a set is the infimum of this set.  -/
theorem IsLeast.csInf_eq :
    ∀ {α : Type u_1} [inst : ConditionallyCompleteLattice α] {s : Set α} {a : α}, IsLeast s a → sInf s = a := by sorry

This theorem states that for any type `α` that forms a conditionally complete lattice, and for any set `s` of elements of type `α`, if there exists a least element `a` in the set `s`, then the infimum (greatest lower bound) of the set `s` is equal to `a`. This means that `a` is the smallest element in `s` that is greater than or equal to all other elements in `s`.

For any conditionally complete lattice `α` and set `s` in `α` having a least element `a`, the infimum of `s` equals `a`. In other words, the least element of `s` is the greatest lower bound of `s`.


/-- The complex exponential is everywhere differentiable, with the derivative `exp x`.  -/
theorem Complex.hasDerivAt_exp : ∀ (x : ℂ), HasDerivAt Complex.exp (Complex.exp x) x := by sorry

The theorem `Complex.hasDerivAt_exp` states that the complex exponential function is differentiable at every point in the complex plane, and furthermore, the derivative of the complex exponential function at any point is the value of the complex exponential function at that point. In other words, for all complex numbers `x`, the derivative of `Complex.exp` at `x` is `Complex.exp x`.

The complex exponential function is complex differentiable, and its derivative equals the complex exponential function itself.


theorem Function.Commute.iterate_left :
    ∀ {α : Type u} {f g : α → α}, Function.Commute f g → ∀ (n : ℕ), Function.Commute f^[n] g := by sorry

This theorem states that for any types `α`, any two functions `f` and `g` from `α` to `α`, and any natural number `n`, if `f` and `g` commute (meaning `f (g x) = g (f x)` for all `x` in `α`), then `f` iterated `n` times and `g` also commute. In mathematical terms, if $f(g(x))=g(f(x))$ for all $x \in \alpha$, then $(f^n(g(x)))=g((f^n)(x))$ for any natural number $n$.

If functions `f` and `g` from type `α` to `α` commute (i.e., `f (g x) = g (f x)` for all `x` in `α`), then `(f^n (g x)) = g ((f^n) x)` for any natural number `n`.


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

The theorem `Order.lt_succ_iff_of_not_isMax` states that for any preorder type `α` that also has a defined successor operation, and for any two elements `a` and `b` of type `α`, if `a` is not a maximal element, then `b` is less than the successor of `a` if and only if `b` is less than or equal to `a`. In other words, if an element is not the greatest in the order, then any other element is less than the successor of the first element just when it is less than or equal to that first element itself.

For any preorder type `α` with a successor operation, if `a` is not the maximum element, then `b ≤ a` if and only if `b < succ a`.


theorem AlgebraicGeometry.IsOpenImmersion.lift_fac :
    ∀ {X Y Z : AlgebraicGeometry.Scheme} (f : X ⟶ Z) (g : Y ⟶ Z) [H : AlgebraicGeometry.IsOpenImmersion f]
      (H' : Set.range ⇑g.val.base ⊆ Set.range ⇑f.val.base),
      CategoryTheory.CategoryStruct.comp (AlgebraicGeometry.IsOpenImmersion.lift f g H') f = g :=
  by sorry

The theorem `AlgebraicGeometry.IsOpenImmersion.lift_fac` states that for any three algebraic geometrical schemes `X`, `Y`, and `Z`, and morphisms `f : X ⟶ Z` and `g : Y ⟶ Z`, if `f` is an open immersion and the range of `g` is a subset of the range of `f`, then the composition of the lift of `f` and `g` (under these conditions) followed by `f` is equal to `g`. In other words, this theorem is about the commutativity of a certain diagram in the category of algebraic geometric schemes, where the morphisms involved are open immersions.

If `f : X ⟶ Z` is an open immersion and `g : Y ⟶ Z` has image contained in that of `f`, then `(g ∘ f^(-1)) ∘ f = g`.


theorem add_halves' : ∀ {R : Type u_1} [inst : DivisionRing R] [inst_1 : CharZero R] (a : R), a / 2 + a / 2 = a := by
  sorry

This theorem states that for any division ring `R` that has characteristic zero, for any element `a` of `R`, the sum of `a` divided by 2 and `a` divided by 2 equals `a`. In simpler terms, it means that in any division ring with characteristic zero, adding half of a number to itself would yield the original number. The characteristic of a ring is zero if and only if the ring's additive identity (zero) is not reached by repeatedly adding the ring's multiplicative identity (one) to itself.

In any division ring of characteristic zero, the element `a` satisfies `(a : R) / 2 + (a : R) / 2 = a`.


IsUnit.dvd

/-- Units of a monoid divide any element of the monoid.  -/
theorem IsUnit.dvd : ∀ {α : Type u_1} [inst : Monoid α] {a u : α}, IsUnit u → u ∣ a := by sorry

The theorem `IsUnit.dvd` states that, for any type `α` that forms a Monoid, if an element `u` of this Monoid is a unit (i.e., it has a two-sided inverse), then `u` divides any element `a` of the Monoid. Here, "divides" means that there exists some element in the Monoid such that when it is multiplied by `u`, it results in `a`.

If `α` is a monoid and `u` is a unit in `α`, then for all `a` in `α`, there exists `x` in `α` such that `u * x = a` and `x * u = a`. (Equivalently, `u` divides `a` and `a` divides `u` in the monoid `α`. )


ContinuousLinearMap.hasFDerivAt

theorem ContinuousLinearMap.hasFDerivAt :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F]
      (e : E →L[𝕜] F) {x : E}, HasFDerivAt (⇑e) e x :=
  by sorry

This theorem states that for any nontrivially normed field `𝕜`, normed add commutative group `E`, and normed space `F` over `𝕜`, a continuous linear map `e` from `E` to `F` has itself as its derivative at any point `x` in `E`. It says that the map given by `e` satisfies the condition that `f x' = f x + f' (x' - x) + o (x' - x)` as `x'` tends to `x`, where `f` is the function defined by `e` and `f'` is the derivative function, which is also `e` in this case.

For any continuous linear map `e` from a normed additive group `E` to a normed space `F` over a nontrivially normed field `𝕜`, `e` is its own derivative at any point `x` in `E`, i.e., `e(x') = e(x) + e(x'-x) + o(x'-x)` as `x'` approaches `x`.


theorem Encodable.encode_injective : ∀ {α : Type u_1} [inst : Encodable α], Function.Injective Encodable.encode := by
  sorry

This theorem, `Encodable.encode_injective`, states that for any type `α` which has an `Encodable` instance, the `encode` function from this `Encodable` instance is injective. In mathematical terms, this means that if we have two elements `x` and `y` of type `α`, and if `Encodable.encode x = Encodable.encode y`, then `x = y`. That is, no two distinct elements of type `α` will be mapped to the same natural number by the `encode` function, ensuring the uniqueness of the encoding for each element.

For any type `α` with an `Encodable` instance, the `encode` function is a bijection from `α` to its image under `encode`. (In other words, `encode` is both injective and surjective.)


theorem Rat.divInt_eq_iff :
    ∀ {d₁ d₂ n₁ n₂ : ℤ}, d₁ ≠ 0 → d₂ ≠ 0 → (Rat.divInt n₁ d₁ = Rat.divInt n₂ d₂ ↔ n₁ * d₂ = n₂ * d₁) := by sorry

This theorem states that for any four integers `d₁`, `d₂`, `n₁`, and `n₂`, where `d₁` and `d₂` are not zero, the rational number formed by dividing `n₁` by `d₁` is equal to the rational number formed by dividing `n₂` by `d₂` if and only if the cross product of `n₁` and `d₂` is equal to the cross product of `n₂` and `d₁`. In other words, $\frac{n_1}{d_1} = \frac{n_2}{d_2}$ if and only if $n_1 \cdot d_2 = n_2 \cdot d_1$.

Two rational numbers $\frac{n\_1}{d\_1}$ and $\frac{n\_2}{d\_2}$ are equal if and only if their numerators have the same cross product with the denominators: $n\_1 \cdot d\_2 = n\_2 \cdot d\_1$.


theorem Nat.mod_eq_sub_mod : ∀ {a b : ℕ}, a ≥ b → a % b = (a - b) % b := by sorry

This theorem states that for any two natural numbers `a` and `b`, if `a` is greater than or equal to `b`, then the remainder of `a` divided by `b` is equal to the remainder of the difference of `a` and `b` divided by `b`. In mathematical notation, for all $a, b \in \mathbb{N}$ such that $a \geq b$, we have $a \mod b = (a - b) \mod b$.

For all natural numbers `a` and `b` with `a >= b`, the remainder of `a` divided by `b` equals the remainder of `(a - b)` divided by `b`.


theorem List.sublist_nil : ∀ {α : Type u_1} {l : List α}, List.Sublist l [] ↔ l = [] := by sorry

This theorem states that for all types `α` and any list `l` of type `α`, `l` is a sublist of an empty list if and only if `l` is also an empty list. In other words, non-empty lists cannot be sublists of an empty list.

For all types `α`, a list `l` of type `α` is a sublist of the empty list if and only if `l` is empty.


/-- **Monotone convergence theorem** -- sometimes called **Beppo-Levi convergence**.
See `lintegral_iSup_directed` for a more general form.  -/
theorem MeasureTheory.lintegral_iSup :
    ∀ {α : Type u_1} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} {f : ℕ → α → ENNReal},
      (∀ (n : ℕ), Measurable (f n)) → Monotone f → ∫⁻ (a : α), ⨆ n, f n a ∂μ = ⨆ n, ∫⁻ (a : α), f n a ∂μ :=
  by sorry

The Monotone Convergence Theorem, also known as Beppo-Levi Convergence, states that for any measurable space and measure, if we consider a sequence of measurable functions from the natural numbers to the extended nonnegative real numbers, then if every function in this sequence is measurable and the sequence is monotone, the integral over the supremum of the sequence of functions is equal to the supremum of the sequence of integrals of the functions. In mathematical notation, we could express this as: $$\int \bigvee_n f_n \, d\mu = \bigvee_n \int f_n \, d\mu$$ where the integral symbol ∫ denotes integration with respect to a measure µ, ⨆ denotes the supremum (least upper bound), and f_n represents the functions in the sequence.

For any measurable space and measure, if we have a sequence of measurable functions from the natural numbers to the extended nonnegative real numbers that are monotone increasing, then the integral of their supremum is equal to the supremum of their integrals: $\int \bigvee\_n f\_n \, d\mu = \bigvee\_n \int f\_n \, d\mu$.


theorem List.attach_map_val : ∀ {α : Type u} (l : List α), List.map Subtype.val (List.attach l) = l := by sorry

The theorem `List.attach_map_val` states that for any list `l` of any type `α`, when we "attach" to each element of `l` the proof that it belongs to `l` to produce a new list (using `List.attach`), and then apply the function `Subtype.val` (which retrieves the underlying element in the base type) to each element of this new list (using `List.map`), we recover the original list `l`. In other words, attaching and then retrieving the underlying elements is an identity operation on lists.

For any list `l` of type `α`, the application of `List.map (Subtype.val)` to `List.attach l id` equals `l`, where `id` is the identity function.


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

The theorem `Filter.map_bot` states that for any types `α` and `β`, and any function `m` from `α` to `β`, the result of applying the forward map of a filter on the function `m` and the bottom filter (represented as `⊥`) is the bottom filter itself. In other words, the forward map of the bottom filter under any function is the bottom filter.

For any function `m` from type `α` to type `β`, the forward map of the bottom filter on `α` is the bottom filter on `β`.


theorem List.sublistsLen_succ_cons :
    ∀ {α : Type u_1} (n : ℕ) (a : α) (l : List α),
      List.sublistsLen (n + 1) (a :: l) = List.sublistsLen (n + 1) l ++ List.map (List.cons a) (List.sublistsLen n l) :=
  by sorry

This theorem asserts that for any given type `α`, an integer `n`, an element `a` of type `α` and a list `l` of type `α`, the list of all sublists of length `n + 1` of the list formed by prepending `a` to `l` can be obtained by appending the result of mapping the function that prepends `a` to each sublist of length `n` of `l` to the list of all sublists of length `n + 1` from `l`. In other words, every sublist of length `n + 1` from the list formed by adding `a` to `l` is either a sublist of `l` of the same length or a sublist of `l` of length `n` with `a` added to it.

For any type `α`, list `l` of length `n` in `α`, and element `a` in `α`, the set of sublists of length `n+1` of the list `[a] ++ l` is the set of sublists of length `n+1` from `l` together with the sublists of length `n` from `l` with `a` appended.


theorem Ordinal.nadd_one : ∀ (a : Ordinal.{u}), Ordinal.nadd a 1 = Order.succ a := by sorry

This theorem states that for every ordinal `a`, the natural addition of `a` and the ordinal `1` is equivalent to the successor of `a`. In other words, it asserts that when you apply the Hessenberg sum operation (which is the specific form of addition defined for ordinals) with `a` and `1`, you get the next ordinal in the order, which is what `Order.succ a` represents. This holds true for all ordinals `a`.

For every ordinal `a`, the Hessenberg sum of `a` and `1` equals `Order.succ a`.


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

This theorem states that for any type `α`, any filter `f` on `α`, and any element `a` of `α`, if the filter `f` is not the bottom filter, then `f` being less than or equal to the pure filter of `a` is equivalent to `f` being equal to the pure filter of `a`. In the context of filters, the "less than or equal" relation can be understood as "is a subset of". Therefore, this theorem is saying that if the filter `f` isn't the bottom filter, then if `f` is a subset of the singleton set containing only `a`, it must be the same as that singleton set.

For any filter `f` on type `α` and element `a` of `α`, if `f` is not the bottom filter, then `f = {a}`. (Here, `{a}` denotes the pure filter of `a`.)


theorem PowerSeries.coeff_zero_eq_constantCoeff :
    ∀ {R : Type u_1} [inst : Semiring R], ⇑(PowerSeries.coeff R 0) = ⇑(PowerSeries.constantCoeff R) := by sorry

This theorem states that for any semiring `R`, the zeroth coefficient of a formal power series in `R` is equal to the constant coefficient of that power series in `R`. In other words, when we apply the `PowerSeries.coeff R 0` function or the `PowerSeries.constantCoeff R` function to a power series, we get the same result, which is the constant term of the power series. This theorem is valid in the context of any semiring, a type of algebraic structure that extends the concept of a ring by allowing multiplication to be commutative.

For any semiring `R`, the zeroth coefficient of a power series in `R` equals its constant coefficient.


theorem Set.encard_eq_zero : ∀ {α : Type u_1} {s : Set α}, Set.encard s = 0 ↔ s = ∅ := by sorry

This theorem states that for any set `s` of elements of some type `α`, the cardinality of the set `s` is zero if and only if the set `s` is the empty set. In other words, the only set with a cardinality of zero is the empty set. This is represented in Lean 4 as `Set.encard s = 0 ↔ s = ∅`, where `Set.encard s` denotes the cardinality of set `s` and `∅` represents the empty set.

The set `s` hascardinality zero if and only if `s` is the empty set.


theorem Finset.sum_eq_zero_iff_of_nonneg :
    ∀ {ι : Type u_1} {N : Type u_5} [inst : OrderedAddCommMonoid N] {f : ι → N} {s : Finset ι},
      (∀ i ∈ s, 0 ≤ f i) → ((Finset.sum s fun i => f i) = 0 ↔ ∀ i ∈ s, f i = 0) :=
  by sorry

The theorem `Finset.sum_eq_zero_iff_of_nonneg` states that for any type `ι`, any `OrderedAddCommMonoid` `N`, any function `f` from `ι` to `N`, and any finite set `s` of elements from type `ι`, if every element `i` in the set `s` is such that `f(i)` is non-negative (i.e., `0 ≤ f i`), then the sum of `f(i)` for all `i` in the set `s` (represented as `Finset.sum s f`) being zero is equivalent to each `f(i)` for all `i` in `s` being zero. In other words, if all the function values are non-negative, the sum is zero if and only if every function value is zero.

For any OrderedAddCommMonoid N, function f from ι to N, and finite set s of ι, if ∀ i ∈ s, 0 ≤ f i then Finset.sum s f = 0 if and only if ∀ i ∈ s, f i = 0.


theorem AlgHom.restrictNormal_commutes :
    ∀ {F : Type u_1} {K₁ : Type u_3} {K₂ : Type u_4} [inst : Field F] [inst_1 : Field K₁] [inst_2 : Field K₂]
      [inst_3 : Algebra F K₁] [inst_4 : Algebra F K₂] (ϕ : K₁ →ₐ[F] K₂) (E : Type u_6) [inst_5 : Field E]
      [inst_6 : Algebra F E] [inst_7 : Algebra E K₁] [inst_8 : Algebra E K₂] [inst_9 : IsScalarTower F E K₁]
      [inst_10 : IsScalarTower F E K₂] [inst_11 : Normal F E] (x : E),
      (algebraMap E K₂) ((AlgHom.restrictNormal ϕ E) x) = ϕ ((algebraMap E K₁) x) :=
  by sorry

This theorem states that for any fields `F`, `K₁`, `K₂`, and `E`, given that `F` is a base field and `K₁` and `K₂` are extension fields of `F`, with `E` being an intermediate field between `F` and `K₁`, then for any algebra homomorphism `ϕ` from `K₁` to `K₂` over `F`, and any element `x` from `E`, applying the algebra map from `E` to `K₂` to the result of restricting the homomorphism `ϕ` to `E` and applying it to `x`, is the same as applying `ϕ` directly to the result of applying the algebra map from `E` to `K₁` to `x`. In mathematical terms, it states that `(algebraMap E K₂) ((AlgHom.restrictNormal ϕ E) x) = ϕ ((algebraMap E K₁) x)`. This states a kind of 'commutativity' property of the restrictions of the algebra homomorphisms and the algebra maps.

For any algebra homomorphisms ϕ : K₁ -> K₂ over a base field F, and any intermediate field E between K₁ and K₂, the restriction of ϕ to E commutes with the algebra maps, i.e., algebraMap E K₂ (restrictNormal ϕ E x) = ϕ (algebraMap E K₁ x) for all x in E.


NonUnitalAlgHom.ext

theorem NonUnitalAlgHom.ext :
    ∀ {R : Type u} {A : Type v} {B : Type w} [inst : Monoid R] [inst_1 : NonUnitalNonAssocSemiring A]
      [inst_2 : DistribMulAction R A] [inst_3 : NonUnitalNonAssocSemiring B] [inst_4 : DistribMulAction R B]
      {f g : A →ₙₐ[R] B}, (∀ (x : A), f x = g x) → f = g :=
  by sorry

The theorem `NonUnitalAlgHom.ext` states that for any types `R`, `A`, and `B`, given that `R` is a monoid, `A` and `B` are non-unital non-associative semirings, and `A` and `B` are also both distributive mul-action over `R`, then for any two functions `f` and `g` from `A` to `B` that preserve the ring structure and scalar multiplication (`A →ₙₐ[R] B`), if `f` and `g` are equal for every element of `A`, then `f` and `g` are identical functions. In other words, two such ring homomorphisms `f` and `g` are determined by their action on the elements of `A`.

If `R` is a monoid, `A` and `B` are non-unital non-associative semirings, and `A` and `B` are distributive over `R`, then any two `R`-homomorphisms from `A` to `B` that agree on all elements of `A` are equal.


theorem MeasureTheory.Measure.AbsolutelyContinuous.trans :
    ∀ {α : Type u_1} {m0 : MeasurableSpace α} {μ₁ μ₂ μ₃ : MeasureTheory.Measure α},
      MeasureTheory.Measure.AbsolutelyContinuous μ₁ μ₂ →
        MeasureTheory.Measure.AbsolutelyContinuous μ₂ μ₃ → MeasureTheory.Measure.AbsolutelyContinuous μ₁ μ₃ :=
  by sorry

The theorem `MeasureTheory.Measure.AbsolutelyContinuous.trans` states that the property of being absolutely continuous is transitive. In more detail, for any measurable space `α` and any three measures `μ₁`, `μ₂`, and `μ₃` defined on this space, if `μ₁` is absolutely continuous with respect to `μ₂`, and `μ₂` is absolutely continuous with respect to `μ₃`, then `μ₁` is also absolutely continuous with respect to `μ₃`. In mathematical terms, if for any set `s` such that `μ₃(s) = 0` implies `μ₂(s) = 0` and `μ₂(s) = 0` implies `μ₁(s) = 0`, then `μ₃(s) = 0` directly implies `μ₁(s) = 0`. This establishes the transitivity of absolute continuity for measures.

If measures `μ₁` is absolutely continuous with respect to `μ₂`, and `μ₂` is absolutely continuous with respect to `μ₃`, then `μ₁` is absolutely continuous with respect to `μ₃`.


theorem Finset.coe_ssubset : ∀ {α : Type u_1} {s₁ s₂ : Finset α}, ↑s₁ ⊂ ↑s₂ ↔ s₁ ⊂ s₂ := by sorry

This theorem states that for all types `α` and for all finite sets `s₁` and `s₂` of this type `α`, the set `s₁` is a strict subset of set `s₂` if and only if the coercion of `s₁` to a set is a strict subset of the coercion of `s₂` to a set. In mathematical terms, it claims that the relation of a proper subset for finsets (`s₁ ⊂ s₂`) corresponds to the same relation for their set-theoretic counterparts (`↑s₁ ⊂ ↑s₂`).

For all types `α` and finite sets `s₁` and `s₂` of type `α`, `s₁ ⊂ s₂` if and only if `↑s₁ ⊂ ↑s₂`, where `↑` denotes the coercion from a finite set to a set.


Asymptotics.SuperpolynomialDecay.congr

theorem Asymptotics.SuperpolynomialDecay.congr :
    ∀ {α : Type u_1} {β : Type u_2} {l : Filter α} {k f g : α → β} [inst : TopologicalSpace β]
      [inst_1 : CommSemiring β],
      Asymptotics.SuperpolynomialDecay l k f → (∀ (x : α), f x = g x) → Asymptotics.SuperpolynomialDecay l k g :=
  by sorry

The theorem `Asymptotics.SuperpolynomialDecay.congr` states that for all types `α` and `β`, a given filter `l` over `α`, functions `k`, `f`, and `g` from `α` to `β`, and for a given topological space and a commutative semiring over `β`, if the function `f` has superpolynomial decay for the parameter `k` along the filter `l`, and for every `x` of type `α`, `f x` equals `g x`, then the function `g` also has superpolynomial decay for the parameter `k` along the filter `l`. In other words, if two functions are equal for every `x` in the domain, and if one of them has superpolynomial decay, then the other one also has superpolynomial decay.

If two functions are equal and one of them has superpolynomial decay along a filter, then the other function also has superpolynomial decay along that filter.


theorem PartialHomeomorph.eventually_right_inverse :
    ∀ {X : Type u_1} {Y : Type u_3} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y]
      (e : PartialHomeomorph X Y) {x : Y},
      x ∈ e.target → ∀ᶠ (y : Y) in nhds x, ↑e (↑(PartialHomeomorph.symm e) y) = y :=
  by sorry

This theorem states that for any type `X` and `Y` equipped with their respective topological spaces and for any partial homeomorphism `e` from `X` to `Y`, if a point `x` belongs to the target of `e`, then almost all points `y` in the neighborhood of `x` will satisfy the condition that applying `e` to the inverse of `e` applied to `y` gives back `y`. Essentially, it states that the inverse of the partial homeomorphism `e`, when composed with `e` itself, acts as an identity on a neighborhood of any point `x` in the target of `e`.

Given a partial homeomorphism `e` from topological spaces `X` to `Y`, if `x` is in the image of `e` and `y` is in a neighborhood of `x`, then `e(Inv(e(y))) = y`, where `Inv` denotes the inverse.


theorem Units.neg_smul :
    ∀ {R : Type u_2} {M : Type u_5} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] (u : Rˣ) (x : M),
      -u • x = -(u • x) :=
  by sorry

This theorem states that for any ring `R`, additive commutative group `M`, and `M` being a module over `R`, the negation of the scalar multiplication of a unit `u` in `R` and an element `x` in `M` is equal to the scalar multiplication of `u` and `x` followed by negation. In mathematical terms, `-u • x = -(u • x)`.

For any ring `R` with unity, module `M` over `R`, and `u` a unit in `R` and `x` an element in `M`, we have `-u * x = -(u * x)`.


/-- A measure on a product space equals the product measure of sigma-finite measures if they are
equal on rectangles.  -/
theorem MeasureTheory.Measure.prod_eq :
    ∀ {α : Type u_1} {β : Type u_3} [inst : MeasurableSpace α] [inst_1 : MeasurableSpace β]
      {μ : MeasureTheory.Measure α} [inst_2 : MeasureTheory.SigmaFinite μ] {ν : MeasureTheory.Measure β}
      [inst_3 : MeasureTheory.SigmaFinite ν] {μν : MeasureTheory.Measure (α × β)},
      (∀ (s : Set α) (t : Set β), MeasurableSet s → MeasurableSet t → ↑↑μν (s ×ˢ t) = ↑↑μ s * ↑↑ν t) →
        MeasureTheory.Measure.prod μ ν = μν :=
  by sorry

This theorem states that for any types `α` and `β` with given measurable spaces, if we have sigma-finite measures `μ` on `α` and `ν` on `β`, and another measure `μν` on the product space `α × β`, then if `μν` equals the product of `μ` and `ν` on all measurable rectangles (that is, for all measurable sets `s` of `α` and `t` of `β`, the measure of their Cartesian product under `μν` equals the product of their individual measures under `μ` and `ν` respectively), then the product measure of `μ` and `ν` is equal to `μν`. This theorem essentially provides a uniqueness condition for the product measure in the setting of sigma-finite measures.

If two sigma-finite measures on measurable spaces `α` and `β` have equal product measures on all measurable rectangles, then they are equal as measures on the product space `α × β`.


theorem OrderIso.map_sSup_eq_sSup_symm_preimage :
    ∀ {α : Type u_1} {β : Type u_2} [inst : CompleteLattice α] [inst_1 : CompleteLattice β] (f : α ≃o β) (s : Set α),
      f (sSup s) = sSup (⇑(OrderIso.symm f) ⁻¹' s) :=
  by sorry

The theorem `OrderIso.map_sSup_eq_sSup_symm_preimage` states that for any complete lattices `α` and `β`, and for any order isomorphism `f` from `α` to `β`, and for any set `s` of elements in `α`, the supremum (`sSup`) of `s` under the isomorphism `f` is equal to the supremum of the preimage of `s` under the inverse of the isomorphism `f`. In other words, applying the isomorphism `f` to the supremum of a set `s` in the domain lattice is the same as taking the supremum of the mapped set in the range lattice.

For any complete lattices α and β, and order isomorphism f between them, the supremum of the preimage of a subset under the inverse of f is equal to the image of the supremum under f.


theorem Set.nonempty_iff_univ_nonempty : ∀ {α : Type u}, Nonempty α ↔ Set.Nonempty Set.univ := by sorry

This theorem, `Set.nonempty_iff_univ_nonempty`, establishes an equivalence between two properties for any given type `α`. The first property, `Nonempty α`, states that there exists an instance of the type `α`, i.e., the type `α` is nonempty. The second property, `Set.Nonempty Set.univ`, asserts that the universal set over the type `α`, which contains all elements of `α`, is nonempty. In essence, it says that a type `α` has an instance if and only if its universal set is not empty.

A set is nonempty if and only if its universal set is nonempty.


theorem AbstractCompletion.uniformContinuous_coe :
    ∀ {α : Type u_1} [inst : UniformSpace α] (pkg : AbstractCompletion α), UniformContinuous pkg.coe := by sorry

This theorem states that for any type `α` equipped with a uniform space structure and any abstract completion `pkg` of `α`, the canonical mapping (denoted by `pkg.coe`) from `α` to the abstract completion `pkg` is uniformly continuous. In mathematical terms, this means that for any two points `x` and `y` in `α` that are sufficiently close to each other, their images under `pkg.coe` (i.e., `pkg.coe(x)` and `pkg.coe(y)`) are also close to each other, regardless of the specific locations of `x` and `y` in `α`.

For any uniform space `(α, δ)` and its abstract completion `(COMP α, δ')`, the canonical map `α →* COMP α` is a uniformly continuous function.


theorem MeasureTheory.indicatorConstLp_coeFn :
    ∀ {α : Type u_1} {E : Type u_2} {m0 : MeasurableSpace α} {p : ENNReal} {μ : MeasureTheory.Measure α}
      [inst : NormedAddCommGroup E] {s : Set α} {hs : MeasurableSet s} {hμs : ↑↑μ s ≠ ⊤} {c : E},
      ↑↑(MeasureTheory.indicatorConstLp p hs hμs c) =ᶠ[MeasureTheory.Measure.ae μ] Set.indicator s fun x => c :=
  by sorry

This theorem states that for any measurable set `s` in a measurable space `α`, and for any constant `c` of type `E` in a normed additive commutative group, the function equivalence of the indicator function that takes on the constant value `c` in the set `s` and zero elsewhere holds almost everywhere with respect to a measure `μ`, if the measure of the set `s` under `μ` is not infinity. This is implemented through the `MeasureTheory.indicatorConstLp` function, which returns an extended nonnegative real number `p`. In other words, the measure-theoretic `Lp` indicator function of a set is almost everywhere equal to the simple indicator function of the set.

For any measurable set `s` in a measurable space with finite measure `μ`, and for any constant `c`, the indicator function of `s` equals `c` almost everywhere if and only if the `Lp` norm of the difference between the indicator function and the constant function is finite.


/-- When `sInf s < b`, there is an element `a` in `s` with `a < b`, if `s` is nonempty and the order
is a linear order. -/
theorem exists_lt_of_csInf_lt :
    ∀ {α : Type u_1} [inst : ConditionallyCompleteLinearOrder α] {s : Set α} {b : α},
      Set.Nonempty s → sInf s < b → ∃ a ∈ s, a < b :=
  by sorry

The theorem `exists_lt_of_csInf_lt` states that for any type `α` with a conditionally complete linear order, and for any set `s` of `α` and arbitrary element `b` of `α`, if `s` is nonempty and the infimum of `s` is less than `b`, then there exists an element `a` in `s` such that `a` is less than `b`. In other words, if the greatest lower bound of a nonempty set is less than some value, there's an element in the set that's also less than that value.

For any nonempty set `s` with infimum in a conditionally complete linear order `α`, if the infimum of `s` is strictly less than some `b` in `α`, then there exists `a` in `s` with `a` strictly less than `b`.


theorem NormedSpace.exp_eq_tsum :
    ∀ {𝕂 : Type u_1} {𝔸 : Type u_2} [inst : Field 𝕂] [inst_1 : Ring 𝔸] [inst_2 : Algebra 𝕂 𝔸]
      [inst_3 : TopologicalSpace 𝔸] [inst_4 : TopologicalRing 𝔸],
      NormedSpace.exp 𝕂 = fun x => ∑' (n : ℕ), (↑(Nat.factorial n))⁻¹ • x ^ n :=
  by sorry

The theorem `NormedSpace.exp_eq_tsum` states that for any two types `𝕂` and `𝔸`, where `𝕂` is a field, `𝔸` is a ring, `𝔸` is an algebra over `𝕂`, `𝔸` has a topological structure, and the ring operations in `𝔸` are continuous (`𝔸` is a topological ring), the exponential function in the normed space over `𝕂` is equal to the infinite sum (`tsum`) of the terms `(↑(Nat.factorial n))⁻¹ • x ^ n` for all natural numbers `n`. Here, `↑(Nat.factorial n))⁻¹` is the inverse of the factorial of `n`, `•` is the scalar multiplication in the algebra, and `x ^ n` is `x` raised to the power `n`.

For any field `𝕂`, ring `𝔸` over `𝕂` that is a topological ring with continuous ring operations, the exponential function in the normed space over `𝕂` equals the infinite sum of the scaled power series of `x` in `𝔸`, where the scale factor is the reciprocal of the factorial for each natural number `n`.


PartitionOfUnity.locallyFinite

theorem PartitionOfUnity.locallyFinite :
    ∀ {ι : Type u} {X : Type v} [inst : TopologicalSpace X] {s : Set X} (f : PartitionOfUnity ι X s),
      LocallyFinite fun i => Function.support ⇑(f i) :=
  by sorry

The theorem `PartitionOfUnity.locallyFinite` states that for any type `ι`, any topological space `X`, and any set `s : Set X`, given a partition of unity `f` indexed by `ι` on the set `s`, the family of supports of the functions `(f i)`, where `i` ranges over the index set `ι`, is locally finite. In other words, for every point `x` in the topological space `X`, there exists a neighborhood of `x` that intersects the support of only finitely many functions in the partition of unity.

Given a topological space X, a type ι, a set s : Set X, and a partition of unity f indexed by ι on s, the family of supports of the functions (fi) has locally finite intersection with every neighborhood in X.


theorem not_subsingleton : ∀ (α : Type u_3) [inst : Nontrivial α], ¬Subsingleton α := by sorry

This theorem states that for any type `α` that is non-trivial - that is, it contains at least two distinct elements - `α` cannot be a subsingleton. In other words, in a non-trivial type, there exists at least a pair of distinct elements, hence it cannot be a subsingleton (a type with at most one element).

A non-trivial type cannot be a subsingleton. (In other words, a type with at least two distinct elements is not a subsingleton.)


theorem differentiable_id :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E], Differentiable 𝕜 id :=
  by sorry

The theorem `differentiable_id` states that the identity function is differentiable at any point, for all non-trivially normed fields `𝕜` and all normed additive commutative groups `E` which form a normed space over `𝕜`. In other words, no matter what point you choose from `E`, you can calculate the derivative of the identity function at that point. This aligns with the intuitive understanding of the identity function's derivative, which is constantly equal to 1.

The identity function is differentiable on any normed additive commutative group over any non-trivially normed field.


theorem AddSubmonoid.mul_le :
    ∀ {R : Type u_4} [inst : NonUnitalNonAssocSemiring R] {M N P : AddSubmonoid R},
      M * N ≤ P ↔ ∀ m ∈ M, ∀ n ∈ N, m * n ∈ P :=
  by sorry

This theorem establishes a condition for the product of two additive submonoids to be a subset of a third submonoid, in the context of a non-unital and non-associative semiring. Specifically, for any type `R` that forms a non-unital non-associative semiring, and any three additive submonoids `M`, `N` and `P` of `R`, it states that `M * N` is a subset of `P` if and only if for every element `m` in `M` and every element `n` in `N`, the product `m * n` is an element of `P`.

For any non-unital and non-associative semiring `R`, and additive submonoids `M`, `N`, and `P` of `R`, `M * N ⊆ P` if and only if for all `m ∈ M` and `n ∈ N`, `m * n ∈ P`.


theorem Multiset.singleton_add : ∀ {α : Type u_1} (a : α) (s : Multiset α), {a} + s = a ::ₘ s := by sorry

This theorem, `Multiset.singleton_add`, states that for all types `α` and for all elements `a` of type `α` and multisets `s` of type `α`, the addition of the singleton multiset containing `a` and the multiset `s` is equivalent to prepending `a` to `s`. Here, `a ::ₘ s` denotes the multiset obtained by adding the element `a` to the multiset `s`. The symbol `+` denotes the operation of combining two multisets into a single multiset.

For all types α and elements a of α, adding the singleton multiset {a} to a multiset s is equivalent to prepending a to s. In Lean notation, a ::ₘ s = s + {a}.


theorem CategoryTheory.ShortComplex.RightHomologyData.p_descQ :
    ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
      {S : CategoryTheory.ShortComplex C} (h : CategoryTheory.ShortComplex.RightHomologyData S) {A : C} (k : S.X₂ ⟶ A)
      (hk : CategoryTheory.CategoryStruct.comp S.f k = 0),
      CategoryTheory.CategoryStruct.comp h.p (CategoryTheory.ShortComplex.RightHomologyData.descQ h k hk) = k :=
  by sorry

The theorem `CategoryTheory.ShortComplex.RightHomologyData.p_descQ` states that for any category `C` with zero morphisms, and given a short complex `S` in `C`, and any `RightHomologyData` `h` for `S` and any object `A` in `C` with a morphism `k` from `S.X₂` to `A` such that the composition of `S.f` and `k` is the zero morphism, the composition of `h.p` and the `descQ` morphism derived from `h`, `k`, and `hk` equals `k`. This theorem is essentially formalizing a property of short complex diagrams in category theory in the context of homological algebra.

Given a short complex in a category with zero morphisms, the `p` morphism of its right homology data and the `descQ` morphism derived from a morphism from the second complex element to an object, commute if the composition of the complex morphism and the given morphism is zero.


/-- The image under a monotone function of a set which is bounded above is bounded above. See also
`BddAbove.image2`.  -/
theorem Monotone.map_bddAbove :
    ∀ {α : Type u} {β : Type v} [inst : Preorder α] [inst_1 : Preorder β] {f : α → β},
      Monotone f → ∀ {s : Set α}, BddAbove s → BddAbove (f '' s) :=
  by sorry

This theorem states that if a set, say 's', within a preordered type, 'α', is bounded above, then the image of this set under a monotone function, 'f', from 'α' to another preordered type, 'β', is also bounded above. In simpler terms, a monotone function won't be able to "break" an upper bound of a set, meaning if the original set is bounded above, its image after the function is applied will be bounded above as well.

If `s` is a bounded above subset of a preordered type `α` and `f` is a monotone function from `α` to a preordered type `β`, then the image `f''s` is also a bounded above subset of `β`.


theorem Submonoid.LocalizationMap.lift_eq :
    ∀ {M : Type u_1} [inst : CommMonoid M] {S : Submonoid M} {N : Type u_2} [inst_1 : CommMonoid N] {P : Type u_3}
      [inst_2 : CommMonoid P] (f : Submonoid.LocalizationMap S N) {g : M →* P} (hg : ∀ (y : ↥S), IsUnit (g ↑y)) (x : M),
      (Submonoid.LocalizationMap.lift f hg) ((Submonoid.LocalizationMap.toMap f) x) = g x :=
  by sorry

The theorem `Submonoid.LocalizationMap.lift_eq` states that for any commutative monoids `M`, `N`, and `P`, a submonoid `S` of `M`, a localization map `f` from the submonoid `S` of `M` to `N`, a monoid homomorphism `g` from `M` to `P` such that each element of `S` (when mapped by `g`) is a unit in `P`, and any element `x` of `M`, applying the function `lift` to the result of applying the function `toMap` of the localization map `f` to `x` is the same as applying the monoid homomorphism `g` to `x`. In other words, the lifted version of the localization map `f` is equal to the monoid homomorphism `g` when applied to elements of `M`.

For any commutative monoids M, N, and P, a submonoid S of M, a localization map f from S to N, a monoid homomorphism g from M to P with g(s) a unit in P for all s in S, the lifted function of f via g is equal to g.


theorem Function.Surjective.iSup_comp :
    ∀ {α : Type u_1} {ι : Sort u_5} {ι' : Sort u_6} [inst : SupSet α] {f : ι → ι'},
      Function.Surjective f → ∀ (g : ι' → α), ⨆ x, g (f x) = ⨆ y, g y :=
  by sorry

The theorem `Function.Surjective.iSup_comp` states that for any types `α`, `ι`, and `ι'`, given a supremum set on `α` and a function `f` from `ι` to `ι'` which is surjective (that is, every element of `ι'` is the image of some element of `ι` under `f`), then for any function `g` from `ι'` to `α`, the supremum of `g` composed with `f` over all `x` in `ι` is equal to the supremum of `g` over all `y` in `ι'`. In other words, surjectivity of the function `f` ensures that applying `f` to the elements of `ι` before taking the supremum does not change the final supremum value in the context of the function `g`.

For any types `α`, `ι`, `ι'`, a supremum `s` on `α` from `ι`, and a surjective function `f` from `ι` to `ι'`, the supremum of `g ∘ f` over `ι` equals the supremum of `g` over `ι'`.


/-- A non-unital subsemiring `S` includes `closure s` if and only if it includes `s`.  -/
theorem NonUnitalSubsemiring.closure_le :
    ∀ {R : Type u} [inst : NonUnitalNonAssocSemiring R] {s : Set R} {t : NonUnitalSubsemiring R},
      NonUnitalSubsemiring.closure s ≤ t ↔ s ⊆ ↑t :=
  by sorry

This theorem states that for any type `R` with a structure of a non-unital, non-associative semiring, and any set `s` of elements of `R` and any non-unital subsemiring `t` of `R`, the non-unital subsemiring generated by `s` (denoted by `NonUnitalSubsemiring.closure s`) is contained in `t` if and only if every element of `s` is an element of `t`. In other words, a non-unital subsemiring includes the closure of a set if and only if it includes the set itself. This theorem hence provides a characterization of the closure of a set in terms of inclusion into non-unital subsemirings.

For any non-unital semiring `R`, set `s` of its elements, and non-unital subsemiring `t`, `NonUnitalSubsemiring.closure s ⊆ t` if and only if `s ⊆ t`.


/-- **Alias** of `eq_or_gt_of_le`. -/
theorem LE.le.eq_or_gt : ∀ {α : Type u} [inst : PartialOrder α] {a b : α}, a ≤ b → b = a ∨ a < b := by sorry

This theorem, named `LE.le.eq_or_gt`, is an alias of the theorem `eq_or_gt_of_le`. It applies to any type `α` that has a `PartialOrder` relation. The theorem takes two elements `a` and `b` of this type and a proof that `a` is less than or equal to `b`. It then states that either `b` is equal to `a`, or `a` is strictly less than `b`. This is a fundamental property in order theory, asserting that for any two elements in a partially ordered set, if one element is not greater than the other, then either they are equal or the first is strictly less than the second.

If `a` is less than or equal to `b` in a partially ordered set, then either `a` is equal to `b` or `a` is strictly less than `b`.


theorem measurable_pi_lambda :
    ∀ {α : Type u_1} {δ : Type u_4} {π : δ → Type u_6} [inst : MeasurableSpace α]
      [inst_1 : (a : δ) → MeasurableSpace (π a)] (f : α → (a : δ) → π a),
      (∀ (a : δ), Measurable fun c => f c a) → Measurable f :=
  by sorry

This theorem, denoted as `measurable_pi_lambda`, states that for all types `α` and `δ`, and a type function `π : δ → Type`, given that `α` and `π a` (for each `a : δ`) are measurable spaces, if a function `f : α → (a : δ) → π a` has the property that for every `a : δ`, the function `fun c => f c a` is measurable, then the function `f` itself is measurable. In other words, if every "slice" of `f` along the `δ` direction is measurable, then `f` is measurable. Here, a function is defined as measurable if the preimage of every measurable set is also measurable.

If `f : α → δ → π a` is a function such that for all `a : δ`, the function `fun c => f c a` is measurable, then `f` is measurable with respect to the product measurable space `(α × δ, ℱα × ℱδ)`, where `ℱα` and `ℱδ` are the sigma-algebras on `α` and `δ` respectively.


theorem sup_eq_max : ∀ {α : Type u} [inst : LinearOrder α] {a b : α}, a ⊔ b = max a b := by sorry

This theorem, `sup_eq_max`, states that for all types `α` that have a linear order, the supremum (denoted as `a ⊔ b`) of any two elements `a` and `b` of that type is equal to the maximum of `a` and `b`. This essentially means that in a linearly ordered set, the supremum - the least upper bound - of two elements is simply the larger of the two elements.

For all types `α` with a linear order and for all `a, b` in `α`, `a ⊔ b = max a b`.


theorem inv_nonpos : ∀ {α : Type u_1} [inst : LinearOrderedSemifield α] {a : α}, a⁻¹ ≤ 0 ↔ a ≤ 0 := by sorry

This theorem named `inv_nonpos` states that for any type `α` which is a Linear Ordered Semifield, an element `a` of this type has a nonpositive inverse if and only if `a` itself is nonpositive. In other words, in such a field, an element and its inverse share the same sign, so if `a` is less than or equal to zero, then its inverse `a⁻¹` is also less than or equal to zero.

For any Linear Ordered Semifield type `α`, if `a` is an element of `α` with nonpositive inverse, then `a` is also nonpositive.


theorem Subgroup.relindex_mul_index :
    ∀ {G : Type u_1} [inst : Group G] {H K : Subgroup G},
      H ≤ K → Subgroup.relindex H K * Subgroup.index K = Subgroup.index H :=
  by sorry

This theorem states that for any given group `G` and two subgroups `H` and `K` of `G`, if `H` is a subgroup of `K`, then the product of the relative index of `H` in `K` and the index of `K` in `G` is equal to the index of `H` in `G`. The relative index of a subgroup is the natural number that represents the index of the subgroup in the larger group, and it returns 0 if the relative index is infinite. Similarly, the index of a subgroup is the size of the set of cosets of the subgroup in the group, represented as a natural number, and returns 0 if the index is infinite.

For any groups G, H, and K with H a subgroup of K, the product of the relative index of H in K and the index of K in G equals the index of H in G.


theorem Filter.map₂_assoc :
    ∀ {α : Type u_1} {β : Type u_3} {γ : Type u_5} {δ : Type u_7} {ε : Type u_9} {ε' : Type u_10} {f : Filter α}
      {g : Filter β} {m : δ → γ → ε} {n : α → β → δ} {m' : α → ε' → ε} {n' : β → γ → ε'} {h : Filter γ},
      (∀ (a : α) (b : β) (c : γ), m (n a b) c = m' a (n' b c)) →
        Filter.map₂ m (Filter.map₂ n f g) h = Filter.map₂ m' f (Filter.map₂ n' g h) :=
  by sorry

This theorem is about the association of binary function mappings over filters. It states that for all types `α`, `β`, `γ`, `δ`, `ε`, `ε'`, for filters `f` over type `α`, `g` over `β`, `h` over `γ`, for binary functions `m : δ → γ → ε`, `n : α → β → δ`, `m' : α → ε' → ε`, `n' : β → γ → ε'`, if for all `a` of type `α`, `b` of type `β`, `c` of type `γ`, the binary function `m` applied to the result of applying binary function `n` to `a` and `b`, and `c`, is equal to the application of binary function `m'` to `a` and the result of applying binary function `n'` to `b` and `c`, then the mapping of binary function `m` over the mapping of binary function `n` over filters `f` and `g`, and filter `h`, is equal to the mapping of binary function `m'` over filter `f` and the mapping of binary function `n'` over filters `g` and `h`. That is, the order in which these operations are performed does not affect the result.

If for all `a : α`, `b : β`, `c : γ`, `m : δ → γ → ε`, `n : α → β → δ`, `m' : α → ε' → ε`, `n' : β → γ → ε'`, `m(n(a, b), c) = m'(a, n'(b, c))` implies `(m ∘ n)_f = m'_f ∘ (n'_g ∘ h)`, then the association of binary function mappings over filters `f`, `g`, and `h` holds.


theorem isClosed_Icc :
    ∀ {α : Type u} [inst : TopologicalSpace α] [inst_1 : Preorder α] [t : OrderClosedTopology α] {a b : α},
      IsClosed (Set.Icc a b) :=
  by sorry

This theorem, `isClosed_Icc`, states that for any type `α` that is equipped with a topological space structure, a preorder structure, and an order-closed topology, the interval `[a, b]` (i.e., the set of all `x` such that `a ≤ x ≤ b`) is a closed set. Here, `a` and `b` are arbitrary elements of type `α`. An order-closed topology is a specific type of topology where any set that is closed under taking limits from the right and left is defined as a closed set.

In a topological space equipped with a preorder and an order-closed topology, the interval [a, b] is a closed set for all a ≤ b in the preorder.


/-- In any concrete category, injective morphisms are monomorphisms.  -/
theorem CategoryTheory.ConcreteCategory.mono_of_injective :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.ConcreteCategory C] {X Y : C}
      (f : X ⟶ Y), Function.Injective ⇑f → CategoryTheory.Mono f :=
  by sorry

In the context of category theory, this theorem states that for any concrete category `C`, if there is an injective morphism `f` from object `X` to object `Y`, then `f` is a monomorphism. In essence, if a function `f` (viewed as a morphism in the category) has the property that equal outputs imply equal inputs (i.e., it's injective), then `f` is a monomorphism, which in category theory means that it "preserves" the operation of "pre-composition".

In category theory, if `f` is an injective morphism in a concrete category `C` from object `X` to object `Y`, then `f` is a monomorphism.


theorem CategoryTheory.Preadditive.sum_comp :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C] {P Q R : C}
      {J : Type u_1} (s : Finset J) (f : J → (P ⟶ Q)) (g : Q ⟶ R),
      CategoryTheory.CategoryStruct.comp (Finset.sum s fun j => f j) g =
        Finset.sum s fun j => CategoryTheory.CategoryStruct.comp (f j) g :=
  by sorry

This theorem, named `CategoryTheory.Preadditive.sum_comp`, is related to the theory of categories and preadditive categories. Specifically, it states that for any category `C` that is also preadditive, given three objects `P`, `Q`, and `R` in `C`, a finite set `s` of type `J`, a function `f` mapping each element of `s` to a morphism from `P` to `Q`, and a morphism `g` from `Q` to `R`, the composition of the sum of the morphisms `f j` (where `j` ranges over all elements of `s`) with `g` is equal to the sum (taken over all `j` in `s`) of the compositions of `f j` with `g`. In other words, the sum of compositions is the same as the composition of sums in this context. This is an application of the distributivity property in preadditive categories.

For any preadditive category `C`, given objects `P`, `Q`, `R`, a set `s`, a function `f : s -> Hom(P, Q)`, and a morphism `g : Hom(Q, R)`, the sum of `f j` over `j` in `s` and `g` is equal to the sum of `g ∘ f j` over `j` in `s`.