theorem ENNReal.toReal_le_of_le_ofReal : ∀ {a : ENNReal} {b : ℝ}, 0 ≤ b → a ≤ ENNReal.ofReal b → a.toReal ≤ b := by
  sorry

This theorem asserts that for any extended nonnegative real number 'a' and any real number 'b', if 'b' is nonnegative and 'a' is less than or equal to the extended nonnegative real number that represents 'b' (as produced by the 'ENNReal.ofReal' function), then the real number representation of 'a' (which we get by using the 'toReal' function) is less than or equal to 'b'. In other words, if 'b' is nonnegative and 'a' is not bigger than the nonnegative real version of 'b', then 'a' interpreted as a real number is not bigger than 'b'.

For all extended non-negative real numbers 'a' and real numbers 'b' with 'b' non-negative, if 'a' ≤ ENNReal.ofReal 'b' then a.toReal ≤ b.


theorem Basis.flag_succ :
    ∀ {R : Type u_1} {M : Type u_2} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {n : ℕ}
      (b : Basis (Fin n) R M) (k : Fin n),
      Basis.flag b (Fin.succ k) = Submodule.span R {b k} ⊔ Basis.flag b (Fin.castSucc k) :=
  by sorry

This theorem, `Basis.flag_succ`, states that for any semiring `R`, an additive commutative monoid `M`, a module `M` over `R`, and a natural number `n`, given a basis `b` of `M` indexed by the finite set `Fin n` and an element `k` of `Fin n`, the subspace spanned by the first `k+1` vectors of the basis `b` (denoted as `Basis.flag b (Fin.succ k)`) is equal to the subspace generated by the union of the set containing the `k`-th basis vector and the subspace spanned by the first `k` vectors of the basis `b` (denoted as `Submodule.span R {b k} ⊔ Basis.flag b (Fin.castSucc k)`). Here, `⊔` represents the join operation in the lattice of submodules, which roughly corresponds to the union of sets.

For any semiring `R`, additive commutative monoid `M` with `R`-module structure, and finite index set `Fin n`, the subspace spanned by the first `k+1` basis vectors of a basis `b` of `M` is equal to the subspace generated by the `k`-th basis vector and the subspace spanned by the first `k` basis vectors.


theorem Finset.truncatedSup_of_mem :
    ∀ {α : Type u_1} [inst : SemilatticeSup α] [inst_1 : OrderTop α] [inst_2 : DecidableRel fun x x_1 => x ≤ x_1]
      {s : Finset α} {a : α} (h : a ∈ lowerClosure ↑s),
      Finset.truncatedSup s a = Finset.sup' (Finset.filter (fun b => a ≤ b) s) ⋯ id :=
  by sorry

This theorem, `Finset.truncatedSup_of_mem`, states that for any given type `α` that has a semilattice sup operation, a top order, and a decidable relation for `≤`, given a finite set `s` of type `α`, and an element `a` of type `α` that belongs to the lower closure of `s`, the truncated sup of `s` and `a` is equal to the supremum of the set obtained by filtering `s` to only keep elements `b` such that `a ≤ b`.

For any semilattice `α` with top element, a finite set `s �rivial subset α`, and `a ∈ cl_≤(s)`, we have `sup (s ∩ {b : α | a ≤ b}) = truncated_sup s a`.


theorem Mathlib.Data.Polynomial.RingDivision._auxLemma.2 : ∀ {α : Type u} [inst : Preorder α] (a : α), (a ≤ a) = True :=
  by sorry

This theorem asserts that for any type `α` equipped with a preorder relation (a relation that is reflexive and transitive), any element `a` of type `α` is less than or equal to itself. This is essentially enforcing the reflexivity property of the preorder, which states that for any element, the relation to itself is always true. In mathematical terms, this theorem states that for all `a` in a preordered set `α` , `a ≤ a` is always true.

In any preordered type `α`, every element `a` satisfies `a ≤ a`.


theorem Mathlib.Data.Polynomial.RingDivision._auxLemma.8 :
    ∀ {M₀ : Type u_1} [inst : MulZeroClass M₀] [inst_1 : NoZeroDivisors M₀] {a b : M₀}, (a * b = 0) = (a = 0 ∨ b = 0) :=
  by sorry

This theorem states that for any type `M₀` that has a multiplication operation and a zero element, and in which no nonzero elements multiply to give zero (i.e., there are no zero divisors), then for any two elements `a` and `b` of `M₀`, the statement "`a` times `b` equals zero" is equivalent to the statement "either `a` equals zero, or `b` equals zero". In other words, in such a structure, a product can be zero only if at least one of the factors is zero. This is a fundamental property of fields and integral domains in algebra.

In any type with multiplication and a zero element, lacking zero divisors, the product of two non-zero elements is non-zero.


theorem Int.neg_mul_eq_neg_mul : ∀ (a b : ℤ), -(a * b) = -a * b := by sorry

This theorem states that for all integers `a` and `b`, the negation of the product of `a` and `b` is equal to the product of the negation of `a` and `b`. In other words, if we take any two integers, multiply them together, and then take the negation of the result, we will get the same value as if we had taken the negation of the first integer and then multiplied by the second integer. This theorem is a property of integer multiplication and follows from the well known fact that the multiplication of an integer by -1 results in the negation of the integer.

For all integers `a` and `b`, the negation of `a * b` is equivalent to `(-a) * b` or `a * (-b)`.


theorem Mathlib.RingTheory.Polynomial.Pochhammer._auxLemma.1 :
    ∀ (S : Type u) [inst : Semiring S] (n k : ℕ),
      Polynomial.eval (↑k) (ascPochhammer S n) = ↑(Polynomial.eval k (ascPochhammer ℕ n)) :=
  by sorry

The theorem states that for any semiring `S` and any natural numbers `n` and `k`, the evaluation of the ascending Pochhammer polynomial `ascPochhammer S n` at `k` is equal to the evaluation of the ascending Pochhammer polynomial `ascPochhammer ℕ n` at `k`, when the result of the latter evaluation is coerced to `S`.

In more mathematical terms, this theorem states that evaluating the ascending Pochhammer polynomial of degree `n` at `k` is consistent across any semiring `S` and the semiring of natural numbers, `ℕ`, given that we proper cast the types.

For any semiring `S` and natural numbers `n` and `k`, the evaluation of the ascending Pochhammer polynomial `ascPochhammer S n` at `k` equals the coerced evaluation of `ascPochhammer ℕ n` at `k`.


theorem Nat.mod_mod : ∀ (a n : ℕ), a % n % n = a % n := by sorry

This theorem states that for any two natural numbers 'a' and 'n', taking the modulus of 'a' with 'n' twice in succession is equal to taking the modulus just once. In other words, if you calculate 'a' % 'n' and then apply the modulus operation with 'n' again, the result will be the same as 'a' % 'n'. This is represented in Lean 4 as `a % n % n = a % n`.

For all natural numbers a and n, the repeated modulus operation a % n % n equals the single modulus operation a % n.


/-- The `Fin.val_zero` in `Std` only applies in `Fin (n+1)`.
This one instead uses a `NeZero n` typeclass hypothesis.
 -/
theorem Fin.val_zero' : ∀ (n : ℕ) [inst : NeZero n], ↑0 = 0 := by sorry

This theorem, `Fin.val_zero'`, states that for all natural numbers `n` with a non-zero typeclass instance, the value of zero casted into the `Fin n` type is equal to zero. This is a generalization of the `Fin.val_zero` theorem in the `Std` library, which only applies when `n` is equal to `n+1`. Here, we instead require a `NeZero n` typeclass hypothesis, which essentially insists that `n` is not equal to zero.

For all natural numbers `n` with `NeZero n`, the zero value in the type `Fin n` equals the natural number zero.


theorem Mathlib.RingTheory.NonUnitalSubsemiring.Basic._auxLemma.6 :
    ∀ {R : Type u} [inst : NonUnitalNonAssocSemiring R] (x : R), (x ∈ ⊤) = True := by sorry

This theorem, which is part of the Ring Theory in Mathlib and relates to Non-Unital Subsemiring, states that for any type `R` that is a `NonUnitalNonAssocSemiring`, any element `x` of `R` is an element of the top (`⊤`) element, which represents the whole set in this context. This is always true, regardless of the specific `x` or `R`. In mathematical terms, this means if `R` is a non-unital, non-associative semiring, then any `x` in `R` is also in the universal set.

In any non-unital, non-associative semiring `R`, every element `x` belongs to the universal set `⊤`.


IsConj.trans

theorem IsConj.trans : ∀ {α : Type u} [inst : Monoid α] {a b c : α}, IsConj a b → IsConj b c → IsConj a c := by sorry

The theorem `IsConj.trans` states that for any type `α` that forms a monoid, the conjugacy relationship is transitive. In other words, if for any three elements `a`, `b`, and `c` of the monoid `α`, if `a` is conjugate to `b` and `b` is conjugate to `c`, then `a` is conjugate to `c`. In the language of group theory, if there exists a unit `d` such that `d * a * d⁻¹ = b` and a unit `e` such that `e * b * e⁻¹ = c`, then there must exist a unit `f` such that `f * a * f⁻¹ = c`.

If `α` is a monoid and `a`, `b`, and `c` are elements of `α` such that there exist units `d` and `e` in `α` with `d * a * d⁻¹ = b` and `e * b * e⁻¹ = c`, then there exists a unit `f` in `α` with `f * a * f⁻¹ = c`.


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

This is a theorem in the context of Heyting Algebras, which are a kind of algebraic structure used in logic and computer science. The theorem states that for any two elements (`a` and `b`) of some Heyting Algebra, `a` is less than or equal to the complement of `b` if and only if `b` is less than or equal to the complement of `a`. This is a kind of 'commutativity' property for the order relation and the complement operation in a Heyting Algebra.

In a Heyting Algebra, elements `a` and `b` have the same order relation to their complements, that is, `a ≤ ¬b` if and only if `b ≤ ¬a`.


WellFounded.recursion

theorem WellFounded.recursion {α : Sort u} {r : α → α → Prop} :
    WellFounded r → {C : α → Sort v} → (a : α) → ((x : α) → ((y : α) → r y x → C y) → C x) → C a := by sorry

This theorem states that for any well-founded relation `r` on a type `α`, we can define a recursion over the elements of `α` ordered by `r`. Specifically, given a well-founded relation `r` on a type `α`, a type-valued function `C` from `α`, and a function `f` that assigns to each `x` in `α` a value `C x`, using values `C y` for `y` such that `r y x`, we can compute a value of `C a` for any `a` in `α`. The recursion follows the order of the relation `r`, i.e., it computes `C y` before `C x` if `r y x` holds.

Given a well-founded relation `r` on type `α` and a function `C : α → Type`, if for all `x ∈ α`, `C x` can be defined using only previously computed values `C y` with `y r x`, then `C` has a unique fixed point in `α`.


theorem continuous_id_iff_le : ∀ {α : Type u} {t t' : TopologicalSpace α}, Continuous id ↔ t ≤ t' := by sorry

This theorem states that for all types `α` and for any two topological spaces `t` and `t'` over `α`, the identity function is continuous if and only if the topological space `t` is a subspace of the topological space `t'`. In other words, it says that the continuity of the identity function is equivalent to the ordering of the two topological spaces.

The identity function is continuous from a topological space (t) to another (t') if and only if t is a subspace of t'.


theorem CategoryTheory.Pretriangulated.Triangle.isZero₂_iff :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroObject C]
      [inst_2 : CategoryTheory.HasShift C ℤ] [inst_3 : CategoryTheory.Preadditive C]
      [inst_4 : ∀ (n : ℤ), CategoryTheory.Functor.Additive (CategoryTheory.shiftFunctor C n)]
      [hC : CategoryTheory.Pretriangulated C],
      ∀ T ∈ CategoryTheory.Pretriangulated.distinguishedTriangles,
        CategoryTheory.Limits.IsZero T.obj₂ ↔ T.mor₁ = 0 ∧ T.mor₂ = 0 :=
  by sorry

This theorem states that for any category `C` with some specific properties (it must be a category, have a zero object, have a shift operation defined on it, be preadditive, have additive shift functors for all integers, and be pretriangulated) and for any distinguished triangle `T` in `C`, the second object of the triangle `T` is a zero object if and only if the first and the second morphisms of `T` are zero.

Here, a distinguished triangle is a concept in the theory of triangulated categories, which are a kind of category that have been used to investigate a wide range of problems in mathematics. A zero object in a category is an object that is both a initial object and a terminal object. A morphism being zero means that it is the same as the unique morphism to the zero object from the domain of the morphism. Preadditive categories are categories in which the hom-sets are abelian groups and composition of morphisms is bilinear. Shift functors are a kind of functor used in the context of triangulated categories to understand the shifts in the morphisms.

In a pretriangulated preadditive category with shift functors and a zero object, a distinguished triangle with zero first and second morphisms has a zero second object.


theorem cauchySeq_finset_of_norm_bounded :
    ∀ {ι : Type u_1} {E : Type u_3} [inst : SeminormedAddCommGroup E] {f : ι → E} (g : ι → ℝ),
      Summable g → (∀ (i : ι), ‖f i‖ ≤ g i) → CauchySeq fun s => Finset.sum s fun i => f i :=
  by sorry

This theorem states that for any types `ι` and `E`, where `E` is a semi-normed additive commutative group, and any two functions `f : ι → E` and `g : ι → ℝ`, if `g` is summable and the norm of `f i` is less than or equal to `g i` for every `i` in `ι`, then the sequence of finite sums of `f` over any given set `s` is a Cauchy sequence. In other words, if we have a sequence of vectors (represented by the function `f`) such that their norms are bounded by a summable sequence (represented by the function `g`), the sequence of partial sums of these vectors is Cauchy, which implies it converges in the limit.

If `ι` is any index type, `E` is a semi-normed additive commutative group, `f : ι → E`, and `g : ι → ℝ` is summable with `||f i|| ≤ g i` for all `i`, then the sequence of finite sums of `f` over any set `s` is a Cauchy sequence.


theorem Filter.disjoint_iff : ∀ {α : Type u} {f g : Filter α}, Disjoint f g ↔ ∃ s ∈ f, ∃ t ∈ g, Disjoint s t := by sorry

The theorem `Filter.disjoint_iff` states that for any type `α` and any two filters `f` and `g` on that type, `f` and `g` are disjoint if and only if there exist sets `s` and `t` such that `s` is in `f`, `t` is in `g`, and `s` and `t` are disjoint. Here, 'disjoint' in the context of two elements of a lattice means that their infimum (or greatest lower bound) is the bottom element of the lattice. This is a generalization of the notion of disjoint sets.

Two filters `f` and `g` on a type `α` are disjoint if and only if there exist sets `s` in `f` and `t` in `g` such that `s ∩ t = ⊥`, where `⊥` denotes the bottom element of the lattice.


theorem sSup_range : ∀ {α : Type u_1} {ι : Sort u_5} [inst : SupSet α] {f : ι → α}, sSup (Set.range f) = iSup f := by
  sorry

The theorem `sSup_range` states that for any given type `α` that has a supremum (`SupSet α`), and any function `f` from a sort `ι` to `α`, the supremum of the range of `f` (`sSup (Set.range f)`) is equal to the indexed supremum of `f` (`iSup f`). In other words, the supremum of the set of all outputs of `f` is the same as the supremum found by considering `f` as an indexed family.

For any type `α` with a supremum and any function `f` from a sort `ι` to `α`, the supremum of the range of `f` equals the indexed supremum of `f`. In other words, `sSup (Set.range f) = iSup f`.


theorem closure_Ici :
    ∀ {α : Type u} [inst : TopologicalSpace α] [inst_1 : Preorder α] [inst_2 : ClosedIciTopology α] (a : α),
      closure (Set.Ici a) = Set.Ici a :=
  by sorry

This theorem is a statement about sets and topologies in a mathematical context. Specifically, it states that for any type `α`, which is a topological space and a preorder (that is, it has a relation that is reflexive and transitive), and also has a topology where all left-closed right-infinite intervals are closed sets (`ClosedIciTopology α`), the closure of a left-closed right-infinite interval starting from a point `a` (`Set.Ici a`) is equal to the interval itself. In other words, the smallest closed set containing the interval `[a, ∞)` is the interval `[a, ∞)` itself.

For any topological space and preorder type `α` with `ClosedIciTopology α`, the closure of a left-closed right-infinite interval `[a, ∞)` equals the interval itself.


theorem Set.powerset_univ : ∀ {α : Type u}, 𝒫 Set.univ = Set.univ := by sorry

The theorem `Set.powerset_univ` states that for any type `α`, the powerset of the universal set of `α` is equal to the universal set itself. In terms of set theory, this can be understood as saying that the collection of all possible subsets of a given set (which is the universal set of `α` in this context), is as large as the universal set itself. Here, `𝒫 Set.univ` represents the powerset of the universal set, in other words, the set of all subsets of the universal set.

For any type `α`, the powerset of its universal set is equal to the universal set itself. In set theory, this is expressed as `𝒫 Set.univ = Set.univ`.


theorem Int.ceil_eq_on_Ioc :
    ∀ {α : Type u_2} [inst : LinearOrderedRing α] [inst_1 : FloorRing α] (z : ℤ), ∀ a ∈ Set.Ioc (↑z - 1) ↑z, ⌈a⌉ = z :=
  by sorry

The theorem `Int.ceil_eq_on_Ioc` states that for any integer `z` and any element `a` belonging to the set `Set.Ioc` (an interval open on the left and closed on the right), where the interval is between `z - 1` and `z` inclusive (after coercing `z` and `z-1` to the same type as `a`), the ceiling of `a` (`⌈a⌉`) is equal to `z`. This is true in the context of a `LinearOrderedRing` (a ring with a total ordering compatible with ring operations) and a `FloorRing` (a ring with a floor function).

For any integer `z` and any `x` in the open interval `(z-1, z]`, the ceiling of `x` equals `z`.


/-- The closure of the interval `(a, b]` is the closed interval `[a, b]`.  -/
theorem closure_Ioc :
    ∀ {α : Type u} [inst : TopologicalSpace α] [inst_1 : LinearOrder α] [inst_2 : OrderTopology α]
      [inst_3 : DenselyOrdered α] {a b : α}, a ≠ b → closure (Set.Ioc a b) = Set.Icc a b :=
  by sorry

The theorem `closure_Ioc` states that for any type `α` that is a topological space, has a linear order, an order topology, and is densely ordered, and for any two distinct elements `a` and `b` of `α`, the closure of the half-open interval `(a, b]` is the closed interval `[a, b]`. Here, the closure of a set is defined as the smallest closed set containing that set, the half-open interval `(a, b]` includes all elements that are greater than `a` and less than or equal to `b`, and the closed interval `[a, b]` includes all elements that are greater than or equal to `a` and less than or equal to `b`.

For any densely ordered topological space `α` with order topology, the closure of the half-open interval `(a, b]` equals the closed interval `[a, b]` for all distinct elements `a` and `b` in `α`.


theorem PiNat.mem_cylinder_comm :
    ∀ {E : ℕ → Type u_1} (x y : (n : ℕ) → E n) (n : ℕ), y ∈ PiNat.cylinder x n ↔ x ∈ PiNat.cylinder y n := by sorry

This theorem states that, for any given function `E` from natural numbers to some types, and any two sequences `x` and `y` in the product space of `E`, along with a natural number `n`, the sequence `y` is in the `n`-length cylinder set around `x` if and only if the sequence `x` is in the `n`-length cylinder set around `y`. In other words, `y` coincides with `x` for the first `n` terms if and only if `x` coincides with `y` for the first `n` terms.

For any function `E` from natural numbers to types and sequences `x` and `y` in the product space of `E^N`, where `N` is the natural numbers, the sequences `x` and `y` belong to each other's `n`-length cylinder sets if and only if they coincide for the first `n` terms.


theorem Polynomial.leadingCoeff_comp :
    ∀ {R : Type u} [inst : Semiring R] [inst_1 : NoZeroDivisors R] {p q : Polynomial R},
      Polynomial.natDegree q ≠ 0 →
        Polynomial.leadingCoeff (Polynomial.comp p q) =
          Polynomial.leadingCoeff p * Polynomial.leadingCoeff q ^ Polynomial.natDegree p :=
  by sorry

This theorem states that for any semiring `R` that does not permit zero divisors, and for any polynomials `p` and `q` over `R`, if the natural degree of polynomial `q` is not zero, then the leading coefficient of the composition of `p` and `q` is equal to the product of the leading coefficient of `p` and the leading coefficient of `q` raised to the power of the natural degree of `p`. In other words, if we compose `p` and `q`, the coefficient of the highest power term in the resulting polynomial is determined by the leading coefficients and the degree of the original polynomials. This theorem essentially gives a rule for the leading coefficient of the polynomial resulting from the composition of two other polynomials.

For any semirings without zero divisors, the leading coefficient of the product of polynomials `p` and `q` is equal to the product of their leading coefficients raised to the power of the degrees of `p` and `q`, respectively.


/-- The closure of the interval `(-∞, a)` is the interval `(-∞, a]`.  -/
theorem closure_Iio :
    ∀ {α : Type u} [inst : TopologicalSpace α] [inst_1 : LinearOrder α] [inst_2 : OrderTopology α]
      [inst_3 : DenselyOrdered α] (a : α) [inst_4 : NoMinOrder α], closure (Set.Iio a) = Set.Iic a :=
  by sorry

The theorem `closure_Iio` states that for any type `α` that is equipped with a topological space structure, linear order, order topology, and the property of being densely ordered and without a minimum element, the closure of the left-infinite right-open interval `(-∞, a)` is the left-infinite right-closed interval `(-∞, a]`. In mathematical terms, this means that when you take the closure of the set of all elements less than `a`, you get the set of all elements less than or equal to `a`. This highlights that the boundary value `a` is included in the closure of the open interval.

For a densely ordered and without-minimum-element type `α` with topology, the closure of the left-infinite right-open interval `(-∞, a)` equals the left-infinite right-closed interval `(-∞, a]`.


theorem closure_Iic :
    ∀ {α : Type u} [inst : TopologicalSpace α] [inst_1 : Preorder α] [inst_2 : ClosedIicTopology α] (a : α),
      closure (Set.Iic a) = Set.Iic a :=
  by sorry

This theorem states that for any type `α` that is a topological space and has a preorder, and if this type also has a topology where all left-infinite right-closed intervals are closed sets, then the closure of any left-infinite right-closed interval `Set.Iic a` is the interval itself. In mathematical terms, given any `a` in `α`, the closure of the set of all elements `x` such that `x ≤ a` is that same set.

The closure of any left-infinite, right-closed interval in a topological preorder space is equal to the interval itself.


theorem AlgebraicGeometry.PresheafedSpace.IsOpenImmersion.lift_fac :
    ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_3, u_1} C] {X Y Z : AlgebraicGeometry.PresheafedSpace C}
      (f : X ⟶ Z) [hf : AlgebraicGeometry.PresheafedSpace.IsOpenImmersion f] (g : Y ⟶ Z)
      (H : Set.range ⇑g.base ⊆ Set.range ⇑f.base),
      CategoryTheory.CategoryStruct.comp (AlgebraicGeometry.PresheafedSpace.IsOpenImmersion.lift f g H) f = g :=
  by sorry

This theorem, `AlgebraicGeometry.PresheafedSpace.IsOpenImmersion.lift_fac`, states that for any category `C`, any presheafed spaces `X`, `Y`, and `Z` over `C`, a morphism `f` from `X` to `Z`, where `f` is an open immersion, and a morphism `g` from `Y` to `Z`, given that the image of the base of `g` is a subset of the image of the base of `f`, the composition of the lift of `g` along `f` and `f` is `g`.

In simpler terms, the theorem states that if you have two maps where one (`f`) is an open immersion and the image of the other (`g`) is contained within the image of the first, then you can "lift" the second map along the first so that they compose to give the second map again. This is a fundamental property in the theory of algebraic geometry.

Given presheafed spaces X, Y, Z over a category C, an open immersion f : X -> Z, and a morphism g : Y -> Z with image(base g) subset image(base f), the lift of g along f and f equals g.


theorem CategoryTheory.ShortComplex.HomologyMapData.homologyMap'_eq :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
      {S₁ S₂ : CategoryTheory.ShortComplex C} {φ : S₁ ⟶ S₂} {h₁ : CategoryTheory.ShortComplex.HomologyData S₁}
      {h₂ : CategoryTheory.ShortComplex.HomologyData S₂} (γ : CategoryTheory.ShortComplex.HomologyMapData φ h₁ h₂),
      CategoryTheory.ShortComplex.homologyMap' φ h₁ h₂ = γ.left.φH :=
  by sorry

The theorem `CategoryTheory.ShortComplex.HomologyMapData.homologyMap'_eq` states that for any category `C` with zero morphisms, given two objects `S₁` and `S₂` in the category of short complexes over `C`, a morphism `φ` from `S₁` to `S₂`, homology data `h₁` and `h₂` for `S₁` and `S₂` respectively, and a homology map data `γ` for the morphism `φ` with respect to `h₁` and `h₂`, the homology map derived from `φ`, `h₁` and `h₂` is equal to the left part of the homology map in `γ`.

For any short complexes $S\_1$ and $S\_2$ over a category $C$ with zero morphisms, given homology data $h\_1$ for $S\_1$, $h\_2$ for $S\_2$, a morphism $\varphi$ from $S\_1$ to $S\_2$, and homology map data $\gamma$ for $\varphi$ and $h\_1$, $h\_2$: the homology map of $\varphi$ derived from $h\_1$ and $h\_2$ equals the left part of the homology map in $\gamma$.


theorem Filter.mem_sets : ∀ {α : Type u} {f : Filter α} {s : Set α}, s ∈ f.sets ↔ s ∈ f := by sorry

This theorem states that for any type `α`, any filter `f` of type `α`, and any set `s` of type `α`, the set `s` is a member of the sets of the filter `f` if and only if `s` is a member of the filter `f`. That is, the membership of a set in the sets of a filter is equivalent to the membership of the set in the filter itself.

For any filter `f` on type `α`, a set `s` belongs to the sets in `f` if and only if `s` belongs to `f`.


/-- Alias of `Nat.cast_le`, specialized to `Ordinal` - -/
theorem Ordinal.nat_cast_le : ∀ {m n : ℕ}, ↑m ≤ ↑n ↔ m ≤ n := by sorry

This theorem, `Ordinal.nat_cast_le`, states that for any two natural numbers `m` and `n`, the condition of `m` being less than or equal to `n` is equivalent to the ordinal casting of `m` being less than or equal to the ordinal casting of `n`. In other words, the theorem shows the preservation of the less-than-or-equal-to relationship under the transformation of natural numbers to ordinal numbers.

For all natural numbers m and n, m <= n if and only if Ordinal.toOrdinal m <= Ordinal.toOrdinal n.


theorem Cardinal.ord_zero : Cardinal.ord 0 = 0 := by sorry

The theorem `Cardinal.ord_zero` states that the ordinal corresponding to the cardinal number 0 is also 0. In other words, the least ordinal number whose cardinal is 0 is 0 itself.

The ordinal 0 is the cardinality of the empty set, and hence is itself a zero ordinal.


theorem Fintype.prod_sum_type :
    ∀ {α₁ : Type u_4} {α₂ : Type u_5} {M : Type u_6} [inst : Fintype α₁] [inst_1 : Fintype α₂] [inst_2 : CommMonoid M]
      (f : α₁ ⊕ α₂ → M),
      (Finset.prod Finset.univ fun x => f x) =
        (Finset.prod Finset.univ fun a₁ => f (Sum.inl a₁)) * Finset.prod Finset.univ fun a₂ => f (Sum.inr a₂) :=
  by sorry

The theorem `Fintype.prod_sum_type` states that for any types `α₁` and `α₂` with finite instances and any commutative monoid `M`, given a function `f` from the sum type of `α₁` and `α₂` to `M`, the product of `f` applied to each element of the universal finite set (which includes all elements from `α₁` and `α₂`) is equal to the product of applying `f` to each element of `α₁` and `α₂` separately and then multiplying these two results together. In mathematical terms, for all `f: α₁ ⊕ α₂ → M`, we have `∏ x in univ, f(x) = (∏ a₁ in univ, f(a₁)) * (∏ a₂ in univ, f(a₂))` when `f` is applied to the left summand a₁ or the right summand a₂ respectively.

For any commutative monoid M and finite types α₁ and α₂, the product of a function from α₁ ⊕ α₂ to M over the universal set is equal to the product of applying the function to each element of α₁ and α₂ separately and multiplying the results.


theorem Subgroup.isOpen_of_mem_nhds :
    ∀ {G : Type u_1} [inst : Group G] [inst_1 : TopologicalSpace G] [inst_2 : ContinuousMul G] (H : Subgroup G) {g : G},
      ↑H ∈ nhds g → IsOpen ↑H :=
  by sorry

This theorem states that for any type `G` which has a group structure, a topological space structure, and where the multiplication operation is continuous, if `H` is a subgroup of `G` and `H` belongs to the neighborhood filter of an element `g` in `G`, then `H` is an open set in the topological space `G`. In other words, if a subgroup is in the neighborhood of a group element, then that subgroup is an open set.

If `G` is a topological group and `H` is a subgroup of `G` such that `H` is in the neighborhood filter of some element in `G`, then `H` is open in `G`.


theorem hasSum_single :
    ∀ {α : Type u_1} {β : Type u_2} [inst : AddCommMonoid α] [inst_1 : TopologicalSpace α] {f : β → α} (b : β),
      (∀ (b' : β), b' ≠ b → f b' = 0) → HasSum f (f b) :=
  by sorry

This theorem states that for any two types `α` and `β`, given that `α` is an additive commutative monoid and a topological space, and `f` is a function from `β` to `α`, if for any element `b'` of `β` that is not equal to a certain element `b`, the function `f` returns `0`, then the sum of the function `f` over all `b` has a sum equal to `f(b)`. In essence, this theorem tells us that the sum of a function applied to all elements of a type is equal to the function applied to a single specific element, provided that the function returns zero for all other elements.

If `f : β → α` is a function from a commutative monoid and topological space `β` to an abelian group `α`, such that `∀b₁ ≠ b, f b₁ = 0`, then `∑b : β, f b = f (summation binding b)`.


theorem Filter.tendsto_atTop' :
    ∀ {α : Type u_3} {β : Type u_4} [inst : Nonempty α] [inst : SemilatticeSup α] {f : α → β} {l : Filter β},
      Filter.Tendsto f Filter.atTop l ↔ ∀ s ∈ l, ∃ a, ∀ b ≥ a, f b ∈ s :=
  by sorry

The theorem `Filter.tendsto_atTop'` states that for any types `α` and `β`, given `α` is nonempty and a semilattice with supremum, a function `f` from `α` to `β`, and a filter `l` on `β`, the function `f` has the property of `Filter.Tendsto` with respect to the filter `Filter.atTop` on `α` and the filter `l` on `β` if and only if for every set `s` in the filter `l`, there exists an element `a` in `α` such that for all `b` in `α` greater than or equal to `a`, the image of `b` under `f` is in `s`. In simpler terms, `f` approaches a limit in the filter `l` as the input approaches infinity if and only if for every set around the limit, we can find a threshold beyond which the function's values are always within that set.

For a function from a nonempty semilattice with supremum to another type, the function tends to a limit in a filter if and only if for every set in the filter, there exists an element such that the images of all larger elements are contained in the set.


theorem t2_iff_isClosed_diagonal :
    ∀ {X : Type u_1} [inst : TopologicalSpace X], T2Space X ↔ IsClosed (Set.diagonal X) := by sorry

The theorem `t2_iff_isClosed_diagonal` states that for any type `X` equipped with a topology (given by the instance `TopologicalSpace X`), `X` is a T2 space if and only if the diagonal set of `X` (which contains all pairs of the form `(a, a)`) is a closed set in the product topology on `X × X`. Here, a T2 space or Hausdorff space is a topological space in which distinct points have disjoint neighborhoods.

A topological space X equipped with a topology is a T2 space if and only if the diagonal set in X × X is a closed set in the product topology.


theorem Polynomial.coeff_hermite_of_lt : ∀ {n k : ℕ}, n < k → Polynomial.coeff (Polynomial.hermite n) k = 0 := by sorry

The theorem `Polynomial.coeff_hermite_of_lt` asserts that for any two natural numbers `n` and `k`, if `n` is less than `k`, then the coefficient of `X^k` in the Hermite polynomial of degree `n` is equal to zero. In other words, in the Hermite polynomial represented as a sum of terms with the form `a_i * X^i`, if `i` is greater than the polynomial's degree, then `a_i` is zero.

For any natural numbers `n` and `k` with `n < k`, the coefficient of `X^k` in the Hermite polynomial of degree `n` is zero.


theorem NormedAddGroupHom.mem_ker :
    ∀ {V₁ : Type u_3} {V₂ : Type u_4} [inst : SeminormedAddCommGroup V₁] [inst_1 : SeminormedAddCommGroup V₂]
      (f : NormedAddGroupHom V₁ V₂) (v : V₁), v ∈ NormedAddGroupHom.ker f ↔ f v = 0 :=
  by sorry

This theorem in Lean 4 is stating that, for any two types `V₁` and `V₂` which are instances of the typeclass `SeminormedAddCommGroup`, and given a Bounded Group homomorphism `f` from `V₁` to `V₂` and an element `v` from `V₁`, `v` is in the kernel of `f` if and only if applying `f` to `v` results in the zero element of `V₂`. In other words, the kernel of a Bounded Group homomorphism consists of all elements from the source group that are mapped to the zero element in the target group.

A Bounded Group homomorphism maps elements in its source group to the zero element in the target group if and only if those elements are in the kernel of the homomorphism.


theorem IsAntichain.image_relEmbedding_iff :
    ∀ {α : Type u_1} {β : Type u_2} {r : α → α → Prop} {r' : β → β → Prop} {s : Set α} {φ : r ↪r r'},
      IsAntichain r' (⇑φ '' s) ↔ IsAntichain r s :=
  by sorry

This theorem states that for any two types `α` and `β`, and two relations `r` on `α` and `r'` on `β`, along with a set `s` of type `α` and a relation-embedding `φ` from `r` to `r'`, the image of the set `s` under the map `φ` is an antichain with respect to `r'` if and only if the set `s` is an antichain with respect to `r`. In simpler terms, it means that mapping an antichain through a relation-embedding preserves the property of being an antichain.

For any relations `r` on type `α` and `r'` on type `β`, set `s` of type `α`, and relation-embedding `φ` from `r` to `r'`, if `s` is an antichain with respect to `r`, then the image of `s` under `φ` is an antichain with respect to `r'`.


theorem Hyperreal.infiniteNeg_mul_of_infiniteNeg_not_infinitesimal_pos :
    ∀ {x y : ℝ*}, Hyperreal.InfiniteNeg x → ¬Hyperreal.Infinitesimal y → 0 < y → Hyperreal.InfiniteNeg (x * y) := by
  sorry

The theorem `Hyperreal.infiniteNeg_mul_of_infiniteNeg_not_infinitesimal_pos` asserts that for all hyperreal numbers 'x' and 'y', if 'x' is negative infinite (i.e., it is smaller than all real numbers) and 'y' is not infinitesimal (i.e., its standard part is not zero) with 'y' being positive, then the product of 'x' and 'y' is also negative infinite.

If x is negative infinite and y is a positive hyperreal number that is not infinitesimal, then x * y is negative infinite.


theorem Ordinal.IsNormal.limit_le :
    ∀ {f : Ordinal.{u_4} → Ordinal.{u_5}},
      Ordinal.IsNormal f →
        ∀ {o : Ordinal.{u_4}}, Ordinal.IsLimit o → ∀ {a : Ordinal.{u_5}}, f o ≤ a ↔ ∀ b < o, f b ≤ a :=
  by sorry

This theorem states that for any normal ordinal function `f` and any limit ordinal `o`, the value of `f` at `o` is less than or equal to an ordinal `a` if and only if for all ordinals `b` less than `o`, `f(b)` is less than or equal to `a`. In other words, the value of a normal ordinal function at a limit ordinal is the least upper bound of its values at smaller ordinals.

For any normal ordinal function `f` and limit ordinal `o`, `f(o)` is the least upper bound of `{f(x) | x < o}` if and only if `f(o)` is less than or equal to `a` for all ordinals `a` less than `o`.


theorem CategoryTheory.ShortComplex.homologyMap'_id :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
      {S : CategoryTheory.ShortComplex C} (h : CategoryTheory.ShortComplex.HomologyData S),
      CategoryTheory.ShortComplex.homologyMap' (CategoryTheory.CategoryStruct.id S) h h =
        CategoryTheory.CategoryStruct.id h.left.H :=
  by sorry

The theorem `CategoryTheory.ShortComplex.homologyMap'_id` states that for any category `C` with zero morphisms, and any short complex `S` in `C`, if `h` is a homology data of `S`, then the homology map of the identity morphism on `S` from `h` to `h` is the identity morphism on the left homology object of `h`. In simpler terms, it says that the homology map of the identity on a short complex is the identity on the homology. This is a fundamental property expected of any homological functor.

For any short complex in a category with zero morphisms, the homology map of the identity morphism is the identity on the homology object.


theorem PartialEquiv.symm_mapsTo :
    ∀ {α : Type u_1} {β : Type u_2} (e : PartialEquiv α β), Set.MapsTo (↑(PartialEquiv.symm e)) e.target e.source := by
  sorry

This theorem states that for any partial equivalence `e` between types `α` and `β`, the function represented by the inverse of `e` maps the target set of `e` into its source set. In other words, if `e` is a partial equivalence from a subset of `α` to a subset of `β`, then the inverse of `e` will take any element in the targeted subset of `β` and map it back into the source subset of `α`.

For any partial equivalence relation `e` between types `α` and `β`, the inverse of `e` maps the domain of `e` in `β` back to `α`.


Finpartition.ext

theorem Finpartition.ext :
    ∀ {α : Type u_1} {inst : Lattice α} {inst_1 : OrderBot α} {a : α} (x y : Finpartition a),
      x.parts = y.parts → x = y :=
  by sorry

This theorem, `Finpartition.ext`, states that for any type `α` equipped with a lattice structure and a bottom element, and for any given element `a` of `α`, if we have two finite partitions `x` and `y` of `a`, then `x` is equal to `y` if and only if their parts are equal. In simpler terms, it asserts that two finite partitions of a given element are completely determined by their parts.

For any lattice type `α` with bottom element, two finite partitions `x` and `y` of an element `a` are equal if and only if their parts are equal.


/-- If `f.op` is an isomorphism `f` must be too.
(This cannot be an instance as it would immediately loop!)
 -/
theorem CategoryTheory.isIso_of_op :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X Y : C} (f : X ⟶ Y)
      [inst_1 : CategoryTheory.IsIso f.op], CategoryTheory.IsIso f :=
  by sorry

This theorem states that, within the context of category theory, if the opposite `f.op` of a morphism `f` from object `X` to object `Y` in a category `C` is an isomorphism, then the original morphism `f` must also be an isomorphism. The caveat mentioned in the comment suggests that this theorem cannot be made into an instance, as it would cause a loop in the instance resolution process.

If the opposite morphism of `f` is an isomorphism in a category `C`, then `f` is an isomorphism.


theorem lp.isLUB_norm :
    ∀ {α : Type u_1} {E : α → Type u_2} [inst : (i : α) → NormedAddCommGroup (E i)] [inst_1 : Nonempty α]
      (f : ↥(lp E ⊤)), IsLUB (Set.range fun i => ‖↑f i‖) ‖f‖ :=
  by sorry

The theorem `lp.isLUB_norm` states that for any type `α` and a type `E` which is a function from `α` to a normed additive commutative group, given the condition that `α` is nonempty, for any element `f` of the lp space with `E` and `⊤` (`lp E ⊤`), the least upper bound (supremum) of the set of norms of elements `i` in `f` (`Set.range fun i => ‖↑f i‖`) is the norm of `f` itself (`‖f‖`). In simpler terms, this theorem asserts that the norm of `f` is the supremum of the norms of its elements.

The norm of a vector in an lp space with respect to a function mapping elements to a normed additive commutative group is the supremum of the norms of its components.


theorem Ordinal.limitRecOn_succ :
    ∀ {C : Ordinal.{u_4} → Sort u_5} (o : Ordinal.{u_4}) (H₁ : C 0) (H₂ : (o : Ordinal.{u_4}) → C o → C (Order.succ o))
      (H₃ : (o : Ordinal.{u_4}) → Ordinal.IsLimit o → ((o' : Ordinal.{u_4}) → o' < o → C o') → C o),
      Ordinal.limitRecOn (Order.succ o) H₁ H₂ H₃ = H₂ o (Ordinal.limitRecOn o H₁ H₂ H₃) :=
  by sorry

The theorem `Ordinal.limitRecOn_succ` states that for any type constructor `C` mapping an ordinal to a type, any ordinal `o`, and three hypotheses, the limit recursion on the successor of `o` is equivalent to the application of the second hypothesis on `o` and the limit recursion on `o`. The three hypotheses are: `H₁` which is a type `C` for the ordinal `0`, `H₂` which maps an ordinal `o` and a type `C o` to another type `C (Order.succ o)`, and `H₃` which applies to a limit ordinal `o` and a function that maps any ordinal smaller than `o` to a type `C o'`. Limit recursion is a method to define a value or function on all ordinals by specifying its value at `0`, at successors, and at limit ordinals.

For any type constructor `C` and ordinal `o`, the limit recursion on `succ(o)` using hypotheses `H₁`, `H₂`, and `H₃` is equivalent to applying `H₂` on `o` and `C o` and then using `H₃` on `o` and the limit recursion on `o`.


theorem Bornology.isBounded_image_fst_and_snd :
    ∀ {α : Type u_1} {β : Type u_2} [inst : Bornology α] [inst_1 : Bornology β] {s : Set (α × β)},
      Bornology.IsBounded (Prod.fst '' s) ∧ Bornology.IsBounded (Prod.snd '' s) ↔ Bornology.IsBounded s :=
  by sorry

The theorem `Bornology.isBounded_image_fst_and_snd` states that for any sets `s` of pairs from two types `α` and `β` with bornologies, the set `s` is bounded if and only if the images of `s` under the first (`Prod.fst`) and second (`Prod.snd`) projection functions are both bounded. In other words, `s` is bounded in the product bornology precisely when its projections onto each factor are bounded in their respective bornologies.

A set of pairs in the product of two types with bornologies is bounded if and only if the images of the set under the first and second projection functions are both boundedly covered.


theorem Ideal.sup_mul_eq_of_coprime_left :
    ∀ {R : Type u} [inst : CommSemiring R] {I J K : Ideal R}, I ⊔ J = ⊤ → I ⊔ J * K = I ⊔ K := by sorry

This theorem states that for any commutative semiring `R` and any ideals `I`, `J`, and `K` of `R`, if the supremum of `I` and `J` equals the whole ring (denoted by `⊤`), then the supremum of `I` and the product of `J` and `K` would be the same as the supremum of `I` and `K`. In other words, if `I` and `J` together generate the entire ring `R`, then the same is true for `I` and `J * K` where `J * K` is the ideal generated by all products of elements from `J` and `K`.

If `I`, `J`, and `K` are ideals of a commutative semiring `R`, and `I ⋃ J = ⊤`, then `I ⋃ (J × K) = I ⋃ K`, where `×` denotes ideal generation by products and `⋃` denotes ideal join.


theorem AddSubgroup.range_mem_rightTransversals :
    ∀ {G : Type u_1} [inst : AddGroup G] {H : AddSubgroup G} {f : Quotient (QuotientAddGroup.rightRel H) → G},
      (∀ (q : Quotient (QuotientAddGroup.rightRel H)), Quotient.mk'' (f q) = q) →
        Set.range f ∈ AddSubgroup.rightTransversals ↑H :=
  by sorry

The theorem `AddSubgroup.range_mem_rightTransversals` states that for any given type `G` that has an additive group structure, a subgroup `H` of `G`, and a function `f` from the quotient group of `G` by `H` to `G` satisfying the property that for all elements `q` of the quotient group, applying `f` to `q` and then taking the equivalence class (using `Quotient.mk''`) results in `q` itself, then the range of function `f` is a right transversal of the subgroup `H`. In other words, every additive group element in `G` can be expressed uniquely as an element of `H` plus an element from the range of `f`.

If `f` is a function from the quotient group of an additive group `G` by a subgroup `H` such that `Quotient.mk'' (q) = f(q)` for all `q` in the quotient group, then the range of `f` is a right transversal of `H` in `G`.


theorem mem_lowerBounds_image2 :
    ∀ {α : Type u} {β : Type v} {γ : Type w} [inst : Preorder α] [inst_1 : Preorder β] [inst_2 : Preorder γ]
      {f : α → β → γ} {s : Set α} {t : Set β} {a : α} {b : β},
      (∀ (b : β), Monotone (Function.swap f b)) →
        (∀ (a : α), Monotone (f a)) → a ∈ lowerBounds s → b ∈ lowerBounds t → f a b ∈ lowerBounds (Set.image2 f s t) :=
  by sorry

This theorem states that for any types `α`, `β`, and `γ` that are preordered, given a binary function `f` from `α` and `β` to `γ`, and two sets `s` of type `α` and `t` of type `β`, if the function `f` is monotone when the second argument is fixed (as expressed by `∀ (b : β), Monotone (Function.swap f b)`) and is also monotone when the first argument is fixed (as expressed by `∀ (a : α), Monotone (f a)`), then for any `a` in the lower bounds of `s` and any `b` in the lower bounds of `t`, `f a b` is in the lower bounds of the image of the function `f` from `s` to `t` (denoted by `Set.image2 f s t`). In simpler terms, this theorem demonstrates the preservation of lower bounds under the image of a binary monotone function.

If `f` is a binary monotone function from preordered types `α`, `β`, and `γ`, then for any sets `s` of type `α` and `t` of type `β` with lower bounds `a` in `s` and `b` in `t`, `f a b` is in the lower bounds of `Set.image2 f s t`.


theorem Matrix.one_mulVec :
    ∀ {m : Type u_2} {α : Type v} [inst : NonAssocSemiring α] [inst_1 : Fintype m] [inst_2 : DecidableEq m] (v : m → α),
      Matrix.mulVec 1 v = v :=
  by sorry

This theorem states that for any type `m` and any type `α` that is a non-associative semiring, given a finite type `m` and the assertion that equality for `m` is decidable, multiplying the identity matrix (represented by `1`) with a vector `v` (which is a function from `m` to `α`) results in the vector `v` itself. In other words, in this mathematical setting, the identity matrix acts as the multiplicative identity for vector multiplication.

For any non-associative semiring type `α`, if equality on the finite type `m` is decidable, then multiplication of the identity matrix (as a function from `m` to `α`) with any vector `v` (as a function from `m` to `α`) results in `v` itself.


/-- `-1` is a square in `ZMod p` iff `p` is not congruent to `3` mod `4`.  -/
theorem ZMod.exists_sq_eq_neg_one_iff : ∀ {p : ℕ} [inst : Fact (Nat.Prime p)], IsSquare (-1) ↔ p % 4 ≠ 3 := by sorry

The theorem `ZMod.exists_sq_eq_neg_one_iff` states that for any prime number `p`, `-1` is a square in the integers modulo `p` if and only if `p` is not congruent to `3` modulo `4`. In other words, there exists an element in the ring of integers modulo `p` whose square equals `-1` if and only if `p` does not leave a remainder of `3` when divided by `4`.

For a prime number p in Z, there exists an integer x such that x^2 ≡ -1 (mod p) if and only if p ≡ 1 (mod 4).


theorem IsOfFinAddOrder.mem_multiples_iff_mem_zmultiples :
    ∀ {G : Type u_1} [inst : AddGroup G] {x y : G},
      IsOfFinAddOrder x → (y ∈ AddSubmonoid.multiples x ↔ y ∈ AddSubgroup.zmultiples x) :=
  by sorry

This theorem states that for any additive group `G` and any two elements `x` and `y` of `G`, if `x` has a finite additive order (meaning that there exists a non-zero integer `n` such that `n * x = 0`), then `y` is in the additive submonoid generated by `x` if and only if `y` is in the additive subgroup generated by `x`. In other words, when `x` has finite order, the set of all multiples of `x` that form a submonoid is exactly the same as the set of all multiples of `x` that form a subgroup.

For any additive group `G` and elements `x` and `y` of `G` with `x` having finite additive order, `y` is in the additive submonoid generated by `x` if and only if `y` is in the additive subgroup generated by `x`.


theorem AffineMap.lineMap_mem :
    ∀ {k : Type u_1} {V : Type u_2} {P : Type u_3} [inst : Ring k] [inst_1 : AddCommGroup V] [inst_2 : Module k V]
      [inst_3 : AddTorsor V P] {Q : AffineSubspace k P} {p₀ p₁ : P} (c : k),
      p₀ ∈ Q → p₁ ∈ Q → (AffineMap.lineMap p₀ p₁) c ∈ Q :=
  by sorry

This theorem states that for any types `k`, `V`, and `P`, where `k` is a ring, `V` is an abelian (or commutative) group, `V` is a module over `k`, and `P` is a torsor for `V`, for any affine subspace `Q` of `P`, two points `p₀` and `p₁` in `P`, and any scalar `c` from `k`, if `p₀` and `p₁` are in `Q`, then the point resulting from the affine map `lineMap`, which maps from `k` to `P` sending `0` to `p₀` and `1` to `p₁`, applied to `c`, is also in `Q`. In simpler terms, if `p₀` and `p₁` are points in an affine subspace, then any point on the line segment between `p₀` and `p₁` (defined by `c`) is also in the subspace.

Given any affine subspace Q of a V-torsor P over a ring k, if two points p₀ and p₁ in P lie in Q, then the point on the line segment between p₀ and p₁ defined by the scalar c is also in Q.


theorem BoxIntegral.Box.mem_splitCenterBox :
    ∀ {ι : Type u_1} {I : BoxIntegral.Box ι} {s : Set ι} {y : ι → ℝ},
      y ∈ BoxIntegral.Box.splitCenterBox I s ↔ y ∈ I ∧ ∀ (i : ι), (I.lower i + I.upper i) / 2 < y i ↔ i ∈ s :=
  by sorry

The theorem `BoxIntegral.Box.mem_splitCenterBox` states that for any type `ι`, any box `I` of type `BoxIntegral.Box ι`, any set `s` of type `Set ι`, and any function `y : ι → ℝ`, `y` belongs to the box resulting from splitting `I` at the center by the hyperplanes defined by `s` if and only if `y` belongs to `I` and for each `i` in `ι`, the average of the lower and upper limit of `i` in `I` is less than `y i` if and only if `i` belongs to `s`. This theorem connects the concept of membership in a split box with conditions on coordinates of a box and membership in a defining set.

A function belongs to the split box obtained by dividing another box using hyperplanes defined by a set if and only if the function belongs to the original box and the average of the lower and upper limits of the function on each element in the set is strictly less than the function value at that element.


SatisfiesM.seq

/-- `SatisfiesM` distributes over `<*>`, general version.  -/
theorem SatisfiesM.seq :
    ∀ {m : Type u_1 → Type u_2} {α α_1 : Type u_1} {p₁ : (α → α_1) → Prop} {f : m (α → α_1)} {p₂ : α → Prop}
      {q : α_1 → Prop} [inst : Applicative m] [inst_1 : LawfulApplicative m] {x : m α},
      SatisfiesM p₁ f →
        SatisfiesM p₂ x → (∀ {f : α → α_1} {a : α}, p₁ f → p₂ a → q (f a)) → SatisfiesM q (Seq.seq f fun x_1 => x) :=
  by sorry

The theorem `SatisfiesM.seq` states that, given any applicative functor `m` and types `α`, `α_1`, if `f` is a monadic value of type `m (α → α_1)` that satisfies a property `p₁`, and `x` is a monadic value of type `m α` that satisfies another property `p₂`, then the result of sequencing `f` and `x` (i.e., `Seq.seq f fun _ => x`) satisfies a third property `q`, assuming that for any function `f` from `α` to `α_1` and any value `a` of type `α`, if `f` satisfies `p₁` and `a` satisfies `p₂`, then `f a` satisfies `q`. This theorem essentially states that the `SatisfiesM` property distributes over the sequencing operation `<*>` in a lawful applicative functor.

Given an applicative functor `m`, if functions `f : α -> α_1` of type `m (α -> α_1)` satisfying `p₁` and values `x : m α` satisfying `p₂` imply that `f (x)` satisfies `q`, then `Seq.seq f fun _ => x` is a value of type `m α_1` satisfying property `q`.


theorem AddSubgroup.isOpen_mono :
    ∀ {G : Type u_1} [inst : AddGroup G] [inst_1 : TopologicalSpace G] [inst_2 : ContinuousAdd G]
      {H₁ H₂ : AddSubgroup G}, H₁ ≤ H₂ → IsOpen ↑H₁ → IsOpen ↑H₂ :=
  by sorry

The theorem `AddSubgroup.isOpen_mono` states that for any type `G` that has both an additive group structure and a topology (with the addition operation being continuous) and given two additive subgroups `H₁` and `H₂` of `G`, if `H₁` is a subset of (or equal to) `H₂` and `H₁` is an open set in the topological space, then `H₂` is also an open set. The symbol `↑` is used to denote the coercion from an additive subgroup to the underlying set.

If `H₁` is an open additive subgroup of `G` and `H₁ ⊆ H₂`, then `H₂` is an open subgroup of `G`.


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

This theorem, `sup_sdiff_left_self`, applies to a generalized co-heyting algebra of any type `α`. It states that for any two elements `a` and `b` of this algebra, the supremum (or join) of `a` and `b` subtracted by `a` (often written in mathematical notation as `(a ⊔ b) \ a`) is equal to `b` subtracted by `a` (`b \ a`). This theorem captures one of the fundamental properties of generalized co-heyting algebras.

In a generalized co-Heyting algebra, the join of two elements and their difference are equal: (a ⊔ b) \ a = b \ a.


theorem SetTheory.PGame.toLeftMovesNim.proof_1 :
    ∀ {o : Ordinal.{u_1}}, (Quotient.out o).α = SetTheory.PGame.LeftMoves (SetTheory.PGame.nim o) := by sorry

This theorem, named `SetTheory.PGame.toLeftMovesNim.proof_1`, states that for every ordinal `o`, the set of elements in the equivalence class represented by `o` (denoted as `(Quotient.out o).α`) is identical to the set of valid moves for the left player in the game of Nim with a heap size corresponding to the ordinal `o` (denoted as `SetTheory.PGame.LeftMoves (SetTheory.PGame.nim o)`). In other words, in the game of Nim, the valid moves for the left player are in one-to-one correspondence with the elements of the equivalence class defined by the ordinal number representing the size of the heap.

For every ordinal `o`, the set of elements in the equivalence class represented by `o` is equal to the set of valid moves for the left player in the Nim game with heap size `o`.


theorem MeasureTheory.FiniteMeasure.toMeasure_smul :
    ∀ {Ω : Type u_1} [inst : MeasurableSpace Ω] {R : Type u_2} [inst_1 : SMul R NNReal] [inst_2 : SMul R ENNReal]
      [inst_3 : IsScalarTower R NNReal ENNReal] [inst_4 : IsScalarTower R ENNReal ENNReal] (c : R)
      (μ : MeasureTheory.FiniteMeasure Ω), ↑(c • μ) = c • ↑μ :=
  by sorry

This theorem, `MeasureTheory.FiniteMeasure.toMeasure_smul`, states that for any measure space Ω and any scalar `c` of a type `R` that can perform scalar multiplication on nonnegative real numbers (`NNReal`) and extended nonnegative real numbers (`ENNReal`), and where `R`, `NNReal`, and `ENNReal` form two scalar towers (meaning scalar multiplication respects associative law across these types), the scalar multiplication of `c` and a finite measure `μ` on Ω gets lifted to the finite measure space, and is equal to the scalar multiplication of `c` and the embedding of `μ` into an extended nonnegative real number (abbreviated as `c • ↑μ` in Lean). In other words, scalar multiplication commutes with the embedding of finite measures into the extended nonnegative real numbers.

For any measure space Ω, scalar `c` of type `R` with scalar multiplication on nonnegative and extended nonnegative real numbers, and finite measure `μ` on Ω, `c • μ` equals `c • ↑μ`, where `↑μ` is the embedding of `μ` into an extended nonnegative real number.


theorem MeasureTheory.measure_preimage_add_right :
    ∀ {G : Type u_2} [inst : MeasurableSpace G] [inst_1 : AddGroup G] [inst_2 : MeasurableAdd G]
      (μ : MeasureTheory.Measure G) [inst_3 : MeasureTheory.Measure.IsAddRightInvariant μ] (g : G) (A : Set G),
      ↑↑μ ((fun h => h + g) ⁻¹' A) = ↑↑μ A :=
  by sorry

This theorem, named `MeasureTheory.measure_preimage_add_right`, is a statement in the field of measure theory regarding the invariance of a measure under the action of addition from the right. Specifically, for any type `G` that has a measurable space structure, an add group structure, and a measurable addition operation, any measure `μ` on `G` that is right-addition invariant, any element `g` of `G`, and any set `A` of `G`, the measure of the preimage of `A` under the function that adds `g` to every element is equal to the measure of `A` itself. This theorem asserts that if you shift each point in a set by some fixed amount, the measure of the set does not change.

For any right-addition invariant measure μ on the measurable add group G, the measure of the preimage of a measurable set A under the right shift by g is equal to the measure of A.


theorem FractionalIdeal.div_nonzero :
    ∀ {R₁ : Type u_3} [inst : CommRing R₁] {K : Type u_4} [inst_1 : Field K] [inst_2 : Algebra R₁ K]
      [frac : IsFractionRing R₁ K] [inst_3 : IsDomain R₁] {I J : FractionalIdeal (nonZeroDivisors R₁) K} (h : J ≠ 0),
      I / J = { val := ↑I / ↑J, property := ⋯ } :=
  by sorry

This theorem states that for any given Commutative Ring `R₁`, Field `K` (where `K` is the field of fractions of `R₁`), along with an Algebra structure over `R₁` and `K`, and given that `R₁` is an integral domain, for any two non-zero fractional ideals `I` and `J` of `R₁` in `K` (where `J` is not equal to zero), the quotient of `I` by `J` equals a fractional ideal formed from the quotient of the carriers of `I` and `J`. In more mathematical terms, if `I` and `J` are fractional ideals of `R₁` in `K`, then `I / J = { val := ↑I / ↑J, property := ⋯ }`, where the property ensures the resulting set is a fractional ideal.

For any commutative ring `R₁` that is an integral domain, two non-zero fractional ideals `I` and `J` of `R₁` in its field of fractions `K` have the same quotient as the fractional ideal generated by the quotient of their carrier ideals in `R₁`.


theorem Equiv.Perm.apply_mem_support :
    ∀ {α : Type u_1} [inst : DecidableEq α] [inst_1 : Fintype α] {f : Equiv.Perm α} {x : α},
      f x ∈ Equiv.Perm.support f ↔ x ∈ Equiv.Perm.support f :=
  by sorry

This theorem, `Equiv.Perm.apply_mem_support`, states that for any type `α` with decidable equality and is a finite type, for any permutation `f` on `α`, and any `x` of type `α`, `x` is in the support of `f` if and only if the image of `x` under `f` is in the support of `f`.

In other words, it asserts that a point and its image under a permutation have the same status with regards to being a fixed point of the permutation: either both are fixed points, or neither is. The support of a permutation is the set of its non-fixed points.

For any finite type `α` with decidable equality and permutation `f` on `α`, the element `x` is in the support of `f` if and only if `f(x)` is in the support of `f`.


theorem Multiset.count_sub :
    ∀ {α : Type u_1} [inst : DecidableEq α] (a : α) (s t : Multiset α),
      Multiset.count a (s - t) = Multiset.count a s - Multiset.count a t :=
  by sorry

The theorem `Multiset.count_sub` states that for any given type `α` that has decidable equality, and any elements `a` of type `α` and multisets `s` and `t` of type `α`, the multiplicity of `a` in the difference of `s` and `t` (i.e., `s - t`) is equal to the difference of the multiplicity of `a` in `s` and the multiplicity of `a` in `t`. Here, a multiset is a finite set that allows duplicates, and the multiplicity of an element in a multiset is the count of how many times it appears in the set. The difference of two multisets is a multiset that contains every element of the first multiset that is not also an element of the second multiset.

For any type `α` with decidable equality, the multiplicity of an element `a` in the difference of multisets `s` and `t` equals the multiplicity of `a` in `s` minus the multiplicity of `a` in `t`.


theorem borel_comap :
    ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {t : TopologicalSpace β}, borel α = MeasurableSpace.comap f (borel β) :=
  by sorry

The theorem `borel_comap` states that for any types `α` and `β`, any function `f` mapping from `α` to `β`, and any topological space on `β`, the Borel measurable space on `α` is equal to the preimage under `f` of the Borel measurable space on `β`. In other words, the set of all measurable subsets of `α` is exactly the set of all preimages under `f` of measurable subsets of `β` that are open in the given topology on `β`. This theorem bridges the gap between the concepts of measurability and topology, showing that the Borel measurable space is precisely the one obtained by considering the preimages of open sets via a function.

The Borel measurable subsets of a type `α` are exactly the preimages under a function `f` from `α` to a topological space `β` of Borel measurable and open subsets of `β`.


theorem HasFDerivAt.const_smul :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {f : E → F}
      {f' : E →L[𝕜] F} {x : E} {R : Type u_6} [inst_5 : Semiring R] [inst_6 : Module R F] [inst_7 : SMulCommClass 𝕜 R F]
      [inst_8 : ContinuousConstSMul R F], HasFDerivAt f f' x → ∀ (c : R), HasFDerivAt (fun x => c • f x) (c • f') x :=
  by sorry

The theorem `HasFDerivAt.const_smul` establishes that the derivative of a function scaled by a constant is just the derivative of the original function scaled by the same constant. More formally, given a function `f` that has a derivative `f'` at a point `x` in a normed field `𝕜` and a semiring `R` such that `F` is an `R`-module and scalar multiplication by `𝕜` commutes with scalar multiplication by `R`, the derivative at `x` of the function `c • f`, where `c` is a constant from `R`, is `c • f'`. Here `•` denotes scalar multiplication. This is a generalization of the familiar rule from single-variable calculus that the derivative of a constant times a function is the constant times the derivative of the function.

Given a function `f` with derivative `f'` at `x` in a normed field `𝕜`, and an `R`-module `F` over a semiring `R` with commuting scalar multiplications, the derivative at `x` of the constant `c` times the function `f` is `c` times the derivative `f'`.


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

This theorem states that for any measure space `α` with measure `μ` and for any function `f` from `α` to the extended nonnegative real numbers (`ENNReal`), if `f` is almost everywhere measurable and `f` is finite almost everywhere, then the integral of the real part of `f` with respect to `μ` is equal to the real part of the integral of `f` with respect to `μ`. In other words, we can interchange the operation of taking the real part of a function with the operation of integrating that function, under certain conditions.

If `f` is an almost everywhere finite and measurable function from a measure space `(α, μ)` to the extended nonnegative real numbers `ENNReal`, then the real parts of `∫(f dμ)` and `∫(Re(f) dμ)` are equal.


theorem Mathlib.Order.SupIndep._auxLemma.25 :
    ∀ {α : Type u_1} {ι : Type u_3} [inst : Lattice α] [inst_1 : OrderBot α] {s : Finset ι} {f : ι → α}
      [inst_2 : DecidableEq ι], Finset.SupIndep s f = ∀ i ∈ s, Disjoint (f i) (Finset.sup (Finset.erase s i) f) :=
  by sorry

This theorem states that for any types `α` and `ι`, given a lattice structure and a bottom element for `α`, a finite set `s` of type `ι`, and a function `f` mapping `ι` to `α`, if we have decidable equality for `ι`, then `s` is supremum independent with respect to `f` if and only if for every element `i` in `s`, `f(i)` is disjoint with the supremum of the set obtained by applying `f` to each element of `s` after erasing `i`. Here, two elements `a` and `b` are said to be disjoint if for any `x` that is lesser than or equal to both `a` and `b`, `x` is also less than or equal to the bottom element. The supremum of a finite set is the maximum value obtained by applying `f` to each element of the set.

For any lattice with a bottom element, a function from a finite set to the lattice, and decidable equality, a set is supremum independent if and only if the image of each element under the function is disjoint with the supremum of the images of all elements after removing that element.


theorem ENNReal.mul_rpow_eq_ite :
    ∀ (x y : ENNReal) (z : ℝ), (x * y) ^ z = if (x = 0 ∧ y = ⊤ ∨ x = ⊤ ∧ y = 0) ∧ z < 0 then ⊤ else x ^ z * y ^ z := by
  sorry

This theorem states that for any extended nonnegative real numbers `x` and `y`, and any real number `z`, the value of the expression `(x * y) ^ z` is equivalent to `∞` (denoted by `⊤` in Lean) if either `x` is `0` and `y` is `∞` or `x` is `∞` and `y` is `0` and `z` is less than `0`. Otherwise, the result is `x ^ z * y ^ z`. In other words, it gives a formula for exponentiation involving multiplication in the context of extended nonnegative real numbers, taking into account the special behavior at `0` and `∞`.

For any extended nonnegative real numbers `x` and `y` and real number `z`, if `x = 0` and `y = ∞` or `x = ∞` and `y = 0` and `z < 0`, then `(x * y) ^ z = ⊤`, otherwise, `(x * y) ^ z = x ^ z * y ^ z`.


theorem Mathlib.Computability.TMToPartrec._auxLemma.34 :
    ∀ {α : Type u_1} [inst : DecidableEq α] {s t u : Finset α}, (s ∪ t ⊆ u) = (s ⊆ u ∧ t ⊆ u) := by sorry

This theorem, `Mathlib.Computability.TMToPartrec._auxLemma.34`, states that for any type `α` that has decidable equality, and any three finite sets `s`, `t`, and `u` of `α`, the set union of `s` and `t` is a subset of `u` if and only if both `s` and `t` are individually subsets of `u`. This theorem is a formalisation of a basic set theory property.

For any type `α` with decidable equality, sets `s`, `t`, and `u` of `α` are such that `s ∪ t ⊆ u` if and only if `s ⊆ u` and `t ⊆ u`.


/-- At `0` the Gamma function is undefined; by convention we assign it the value `0`.  -/
theorem Complex.Gamma_zero : Complex.Gamma 0 = 0 := by sorry

This theorem states that the Gamma function, when evaluated at zero, is undefined. However, by convention, we assign it the value zero. This is expressed in Lean 4 using the `Complex.Gamma` function, which computes the Gamma function for complex numbers. In the theorem `Complex.Gamma_zero`, it is asserted that `Complex.Gamma 0` equals zero.

The Gamma function, usually undefined at 0, is conventionally assigned the value 0 in Lean 4. (Or equivalently, the theorem `Complex.Gamma_zero` asserts that `Complex.Gamma 0 = 0`.)


/-- Uniform converence implies pointwise convergence.  -/
theorem TendstoUniformlyOnFilter.tendsto_at :
    ∀ {α : Type u} {β : Type v} {ι : Type x} [inst : UniformSpace β] {F : ι → α → β} {f : α → β} {x : α} {p : Filter ι}
      {p' : Filter α},
      TendstoUniformlyOnFilter F f p p' → Filter.principal {x} ≤ p' → Filter.Tendsto (fun n => F n x) p (nhds (f x)) :=
  by sorry

This theorem, titled "Uniform convergence implies pointwise convergence," states that for any given types `α`, `β`, and `ι` with `β` being a uniform space, along with functions `F : ι → α → β` and `f : α → β`, an element `x : α`, and filters `p : Filter ι` and `p' : Filter α`. If the sequence of functions `F` converges uniformly on the filter `p'` to the limiting function `f` with respect to the filter `p`, and the principal filter of the set containing only `x` is less than or equal to `p'`, then the function mapping each element of `ι` to `F n x` (the image of `x` under the `n`th function in the sequence) tends under the filter `p` towards the neighborhood filter at `f(x)`. In other words, if a sequence of functions converges uniformly, then the sequence of its function values at any given point will also converge to the function value of the limit function at that point.

If a sequence of functions converges uniformly to a limit function on a filter, then the sequence of function values at any point in the domain converges to the limit value of the function at that point.


TopCat.Presheaf.ext

theorem TopCat.Presheaf.ext :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X : TopCat} {P Q : TopCat.Presheaf C X} {f g : P ⟶ Q},
      (∀ (U : TopologicalSpace.Opens ↑X), f.app (Opposite.op U) = g.app (Opposite.op U)) → f = g :=
  by sorry

The theorem `TopCat.Presheaf.ext` states that for any category `C`, any topological space `X`, and any two `C`-valued presheaves `P` and `Q` on `X`, if two natural transformations `f` and `g` from `P` to `Q` have the property that for every open set `U` in `X`, the application of `f` to the opposite of `U` equals the application of `g` to the opposite of `U`, then `f` and `g` are the same natural transformation.
In other words, two natural transformations between presheaves are equal if and only if their corresponding applications are equal for each open set.

For any category `C`, topological space `X`, and `C`-valued presheaves `P` and `Q` on `X`, if two natural transformations `f` and `g` from `P` to `Q` satisfy `f(U) = g(U)` for all open sets `U` in `X`, then `f` is equal to `g`.


theorem sbtw_comm :
    ∀ {R : Type u_1} {V : Type u_2} {P : Type u_4} [inst : OrderedRing R] [inst_1 : AddCommGroup V]
      [inst_2 : Module R V] [inst_3 : AddTorsor V P] {x y z : P}, Sbtw R x y z ↔ Sbtw R z y x :=
  by sorry

This theorem, `sbtw_comm`, states that for any ordered ring `R`, additive commutative group `V`, module `R` over `V`, and an additive torsor `V` over `P`, the strict betweenness relation `Sbtw` is symmetric with respect to its endpoints. In other words, given any three points `x`, `y`, and `z` from `P`, the point `y` is strictly between `x` and `z` if and only if `y` is strictly between `z` and `x`.

For any ordered ring R, additive commutative group V, R-module V, and additive torsor V over P, the strict betweenness relation Sbtw on P is a symmetric relation.


theorem Part.Fix.approx_mono' :
    ∀ {α : Type u_1} {β : α → Type u_2} (f : ((a : α) → Part (β a)) →o (a : α) → Part (β a)) {i : ℕ},
      Part.Fix.approx (⇑f) i ≤ Part.Fix.approx (⇑f) (Nat.succ i) :=
  by sorry

The theorem `Part.Fix.approx_mono'` states that for any type `α`, any type function `β` mapping `α` to another type, and any function `f` that is a monotone function from partial functions from `α` to `β` to another such partial function, then for any natural number `i`, the `i`-th step in the approximation chain of the fixed point of `f` is less than or equal to the `(i+1)`-th step in the approximation chain. In other words, the series of approximations to the fixed point of `f` is non-decreasing.

For any monotone function `f` from partial functions on a type `α` to partial functions on another type `β`, the approximation chain of `f`'s fixed point is non-decreasing.


IsMetricSeparated.symm

theorem IsMetricSeparated.symm :
    ∀ {X : Type u_1} [inst : EMetricSpace X] {s t : Set X}, IsMetricSeparated s t → IsMetricSeparated t s := by sorry

This theorem states that if two sets in an extended metric space are metric separated, this property is symmetric. In other words, if for every pair of points with the first point from the first set and the second point from the second set there exists a non-zero lower bound for their distance, then the same holds true if the roles of the two sets are swapped. This means that the concept of metric separation between two sets is independent from the order in which we consider the sets.

If sets A and B are metric separated in an extended metric space, then B and A are also metric separated.


theorem List.pairwise_sublists :
    ∀ {α : Type u} {R : α → α → Prop} {l : List α},
      List.Pairwise R l →
        List.Pairwise (fun l₁ l₂ => List.Lex R (List.reverse l₁) (List.reverse l₂)) (List.sublists l) :=
  by sorry

The theorem `List.pairwise_sublists` states that for all types `α` and a binary relation `R` on `α`, given a list `l` of type `α`, if `l` is pairwise related under `R`, then all sublists of `l` are pairwise related under a new relation. This new relation is defined as the lexicographic order `List.Lex R` of the reverse of any two sublists. Being pairwise related under `R` means that for every pair of distinct elements in the list, the relation `R` holds. The lexicographic order of two lists is the order determined by the first position where the lists differ. In other words, the theorem ensures that the order property is preserved even after reversing and taking all possible non-contiguous sublists.

If a list of pairwise related elements under a relation R, then all its non-contiguous sublists are pairwise related under the lexicographic order List.Lex(R) of their reversals.


/-- The closed ball of radius `δ` centered at a point of `E` is included in the closed
thickening of `E`.  -/
theorem Metric.closedBall_subset_cthickening :
    ∀ {α : Type u_2} [inst : PseudoMetricSpace α] {x : α} {E : Set α},
      x ∈ E → ∀ (δ : ℝ), Metric.closedBall x δ ⊆ Metric.cthickening δ E :=
  by sorry

The theorem `Metric.closedBall_subset_cthickening` states that for any type `α` with a `PseudoMetricSpace` structure, any point `x` from a set `E` and any real number `δ`, the closed ball of radius `δ` centered at `x` is a subset of the closed δ-thickening of `E`. In other words, every point that lies within the closed ball, which includes all points with distance from `x` less than or equal to `δ`, also lies within the closed δ-thickening of `E`, a set which includes all points whose minimum distance from `E` is less than or equal to `δ`.

For any pseudo-metric space (α, d), and point x in α and real number δ, the closed ball B(x, δ) is contained in the closed δ-thickening Thick(E, δ) of any set E in α.


theorem Dioph.le_dioph : ∀ {α : Type} {f g : (α → ℕ) → ℕ}, Dioph.DiophFn f → Dioph.DiophFn g → Dioph {v | f v ≤ g v} :=
  by sorry

The theorem `Dioph.le_dioph` states that for any type `α` and any two functions `f` and `g` from `α → ℕ` to `ℕ`, if both `f` and `g` are Diophantine functions (i.e., the graph of the function is Diophantine), then the set of all `v` such that `f v` is less than or equal to `g v` is also Diophantine. In other words, the inequality `f v ≤ g v` is Diophantine whenever `f` and `g` are Diophantine functions.

If `f` and `g` are Diophantine functions from a type `α` to `ℕ`, then the set {`v` | `f v` ≤ `g v`} is Diophantine.


theorem Polynomial.smeval_add :
    ∀ (R : Type u_1) [inst : Semiring R] (p q : Polynomial R) {S : Type u_2} [inst_1 : AddCommMonoid S]
      [inst_2 : Pow S ℕ] [inst_3 : Module R S] (x : S),
      Polynomial.smeval (p + q) x = Polynomial.smeval p x + Polynomial.smeval q x :=
  by sorry

The theorem `Polynomial.smeval_add` states that for any semiring `R`, given two polynomials `p` and `q` over `R`, and a scalar `x` from a type `S` that has an additive commutative monoid structure, a power operation, and is a module over `R`, the evaluation of the sum of `p` and `q` at `x` is equal to the sum of the evaluations of `p` and `q` at `x`. In mathematical terms, if we denote the `Polynomial.smeval` operation as $f$, this theorem is stating that $f(p + q, x) = f(p, x) + f(q, x)$ for all polynomials $p, q$ and scalars $x$.

For any semiring `R`, given polynomials `p` and `q` over `R` and a scalar `x` from an additive commutative monoid with power operation and `R`-module structure, `Polynomial.smeval (p + q) x = Polynomial.smeval p x + Polynomial.smeval q x`.


/-- The submonoid generated by an element of a monoid equals the set of natural number powers of
the element.  -/
theorem Submonoid.mem_closure_singleton :
    ∀ {M : Type u_1} [inst : Monoid M] {x y : M}, y ∈ Submonoid.closure {x} ↔ ∃ n, x ^ n = y := by sorry

This theorem states that for any type `M` which has a Monoid structure and for any elements `x` and `y` of `M`, `y` is in the submonoid generated by `{x}` if and only if there exists a natural number `n` such that `x` to the power of `n` equals `y`. In other words, the submonoid generated by a single element in a monoid is exactly the set of all natural number powers of that element.

For any monoid `M` and element `x` in `M`, the submonoid generated by `{x}` equals the set of all powers of `x` in `M`.


theorem Function.minimalPeriod_pos_iff_mem_periodicPts :
    ∀ {α : Type u_1} {f : α → α} {x : α}, 0 < Function.minimalPeriod f x ↔ x ∈ Function.periodicPts f := by sorry

This theorem states that for any domain type `α`, endomorphism `f` and point `x`, the minimal period of `x` under `f` is positive if and only if `x` is a periodic point of `f`. In other words, a point `x` in the domain of a function `f` has a nonzero minimal period under `f` if and only if there exists some positive natural number `n` such that `f` applied `n` times to `x` returns `x` (i.e., `x` is in the set of periodic points of `f`).

For any endomorphism `f` over a domain `α` and point `x`, the minimal period of `x` under `f` is positive if and only if `x` is a periodic point of `f` with some positive period.


theorem CategoryTheory.MonoidalCategory.whiskerRight_iff :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.MonoidalCategory C] {X Y : C}
      (f g : X ⟶ Y),
      CategoryTheory.MonoidalCategory.whiskerRight f (𝟙_ C) = CategoryTheory.MonoidalCategory.whiskerRight g (𝟙_ C) ↔
        f = g :=
  by sorry

This theorem states that for any category `C` that is also a monoidal category, and for any two morphisms `f` and `g` from object `X` to `Y` in `C`, the equality of the results of "whiskering" `f` and `g` on the right by the identity morphism of `C` implies the equality of `f` and `g` themselves. In other words, if whiskering `f` and `g` on the right with the identity morphism yields the same result, then `f` and `g` must be identical. This theorem provides a condition for testing the equivalence of morphisms in a monoidal category, using the concept of whiskering - a form of "shaping" or "manipulating" morphisms in a category.

In a monoidal category `C`, if for any morphisms `f` and `g` from object `X` to `Y`, the equality of `(f ⊠ id_Y) = (g ⊠ id_Y)` implies `f = g`, where `⊠` is the whiskering operation, then `C` satisfies the equality of whiskering and identity morphisms.


theorem AntilipschitzWith.isBounded_preimage :
    ∀ {α : Type u_1} {β : Type u_2} [inst : PseudoMetricSpace α] [inst_1 : PseudoMetricSpace β] {K : NNReal}
      {f : α → β}, AntilipschitzWith K f → ∀ {s : Set β}, Bornology.IsBounded s → Bornology.IsBounded (f ⁻¹' s) :=
  by sorry

The theorem `AntilipschitzWith.isBounded_preimage` states that for any two types `α` and `β` equipped with pseudo metric spaces, a nonnegative real number `K`, and a function `f` from `α` to `β` that is Anti-lipschitz with `K`, if a set `s` of type `β` is bounded relative to the ambient bornology on `β`, then the preimage of `s` under the function `f` is also bounded relative to the ambient bornology on `α`.

In simpler terms, this theorem asserts that if a function doesn't stretch distances by more than a factor of `K` (it's Anti-lipschitz), and if a set in the target space is bounded, then the set of points in the source space that map into this bounded set is also bounded.

If `f` is an Anti-lipschitz function from a pseudo metric space `(α, d₁)` to another pseudo metric space `(β, d₂)` with constant `K`, and `s ⊆ β` is a bounded set, then the preimage `f⁻¹(s) ⊆ α` is also a bounded set.


theorem OrderHom.nextFixed_le :
    ∀ {α : Type u} [inst : CompleteLattice α] (f : α →o α) {x : α} (hx : x ≤ f x) {y : ↑(Function.fixedPoints ⇑f)},
      x ≤ ↑y → OrderHom.nextFixed f x hx ≤ y :=
  by sorry

This theorem states that for all types `α` forming a complete lattice, and for any monotone function `f` from `α` to `α`, given `x` in `α` such that `x` is less than or equal to `f(x)`, and a fixed point `y` of `f`, if `x` is less than or equal to `y`, then the next fixed point of `f` that is greater than or equal to `x` is less than or equal to `y`. In other words, if `x` is less than or equal to a fixed point `y`, then the smallest fixed point of `f` that is greater than or equal to `x` is also less than or equal to `y`.

Given a complete lattice `α`, a monotone function `f` from `α` to `α`, a fixed point `y` of `f`, and `x` in `α` with `x ≤ y` and `x ≤ f(x)`, the next fixed point of `f` greater than or equal to `x` is less than or equal to `y`.


theorem catalan_succ : ∀ (n : ℕ), catalan (n + 1) = Finset.sum Finset.univ fun i => catalan ↑i * catalan (n - ↑i) := by
  sorry

The theorem `catalan_succ` states that for any given natural number `n`, the `(n + 1)`th Catalan number is equal to the sum of the product of the `i`th Catalan number and the `(n - i)`th Catalan number, where `i` ranges over all elements in the universal finite set (`Finset.univ`). In mathematical notation, this is represented as `catalan (n + 1) = ∑ i in Finset.univ, catalan i * catalan (n - i)`.

The `(n + 1)`th Catalan number is the sum of the products of the `i`th Catalan number and the `(n - i)`th Catalan number, for all `i` in the universal finite set. In mathematical notation, `catalan (n + 1) = ∑ i in Finset.univ, catalan i * catalan (n - i)`.


ContinuousMap.Homotopic.trans

theorem ContinuousMap.Homotopic.trans :
    ∀ {X : Type u} {Y : Type v} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] ⦃f g h : C(X, Y)⦄,
      ContinuousMap.Homotopic f g → ContinuousMap.Homotopic g h → ContinuousMap.Homotopic f h :=
  by sorry

The theorem `ContinuousMap.Homotopic.trans` states that, for any topological spaces `X` and `Y`, if there exists a homotopy between two continuous maps `f` and `g` from `X` to `Y`, and there exists a homotopy between `g` and another continuous map `h` from `X` to `Y`, then there also exists a homotopy between `f` and `h`. This establishes transitivity for the relation of being homotopic in the context of continuous maps between topological spaces.

If two continuous maps between topological spaces are homotopic to each other, and each is homotopic to a third map, then the first two maps are homotopic to each other through the third map.


/-- The order of the monomial `a*X^n` is `n` if `a ≠ 0`. -/
theorem PowerSeries.order_monomial_of_ne_zero :
    ∀ {R : Type u_1} [inst : Semiring R] (n : ℕ) (a : R),
      a ≠ 0 → PowerSeries.order ((PowerSeries.monomial R n) a) = ↑n :=
  by sorry

The theorem states that for any semiring `R`, given a non-zero coefficient `a` from `R` and a natural number `n`, the order of the monomial `a*X^n` (interpreted as a formal power series), is `n`. This means that the highest power `n` such that `X^n` divides the formal power series `a*X^n` (which is `n` itself) if the coefficient `a` is non-zero.

For any semiring `R` and non-zero `a` in `R` and natural number `n`, the order of the monomial `a*X^n` as a formal power series is equal to `n`.


/-- The **extreme value theorem**: a continuous function realizes its minimum on a compact set.  -/
theorem IsCompact.exists_forall_le :
    ∀ {α : Type u_2} {β : Type u_3} [inst : LinearOrder α] [inst_1 : TopologicalSpace α] [inst_2 : TopologicalSpace β]
      [inst_3 : ClosedIicTopology α] {s : Set β},
      IsCompact s → Set.Nonempty s → ∀ {f : β → α}, ContinuousOn f s → ∃ x ∈ s, ∀ y ∈ s, f x ≤ f y :=
  by sorry

The **extreme value theorem** states that, for any given continuous function `f` mapping from a compact set `s` in a topological space to a linearly ordered topological space, there always exists a point `x` in `s` such that the value of `f` at `x` is less than or equal to the value of `f` at any other point in `s`. In other words, a continuous function always attains its minimum value at some point in a compact set. This theorem assumes the set `s` is non-empty and the function `f` is continuous on this set.

A continuous function on a compact set attains its minimum value.


theorem eq_of_mem_minimals :
    ∀ {α : Type u_1} {r : α → α → Prop} {s : Set α} {a b : α} [inst : IsAntisymm α r],
      a ∈ minimals r s → b ∈ s → r b a → a = b :=
  by sorry

The theorem `eq_of_mem_minimals` states that for any type `α`, any relation `r` on `α`, any set `s` of type `α`, and any two elements `a` and `b` of type `α`, if `r` is an antisymmetric relation, `a` belongs to the set of minimal elements of `s` with respect to `r`, `b` belongs to `s`, and `r` holds between `b` and `a`, then `a` must be equal to `b`. In essence, this theorem captures the idea that if `a` is a minimal element and `b` is any element such that `b` is related to `a` by `r`, then `a` and `b` must be the same element, highlighting the unique characteristic of the minimal elements in an antisymmetric relation.

If `r` is an antisymmetric relation on `α`, `a` is a minimal element of `s` with respect to `r`, `b` is in `s`, and `r(a, b)` holds, then `a = b`.


theorem Filter.disjoint_atBot_atTop :
    ∀ {α : Type u_3} [inst : PartialOrder α] [inst_1 : Nontrivial α], Disjoint Filter.atBot Filter.atTop := by sorry

The theorem `Filter.disjoint_atBot_atTop` states that for any non-trivial partially ordered type `α`, the filters `Filter.atBot` and `Filter.atTop` are disjoint. In other words, there is no element in `α` that is both arbitrarily close to negative infinity (`Filter.atBot`) and positive infinity (`Filter.atTop`) at the same time. Disjointness of filters here is defined as their infimum being the bottom element of the set, which generalizes the concept of disjoint sets.

For any non-trivial partially ordered type `α`, the filters `Filter.atBot` and `Filter.atTop` have no common elements.


Subgroup.IsComplement'.symm

theorem Subgroup.IsComplement'.symm :
    ∀ {G : Type u_1} [inst : Group G] {H K : Subgroup G}, Subgroup.IsComplement' H K → Subgroup.IsComplement' K H := by
  sorry

The theorem states that for any type `G` with a group structure, and any subgroups `H` and `K` of `G`, if `H` and `K` are complements of each other, meaning the operation `(*) : H × K → G` is a bijection, then `K` and `H` are also complements of each other. This is the symmetry property of the subclass of group complements which says that the order of the subgroups does not matter in the definition of complement.

If two subgroups `H` and `K` of a group `G` are complements of each other, i.e., their product is bijective, then they are mutual complements, i.e., each is the subgroup of `G` whose complement is the other.


theorem Quaternion.coe_re : ∀ {R : Type u_3} [inst : CommRing R] (x : R), (↑x).re = x := by sorry

This theorem states that for any commutative ring `R` and any element `x` from `R`, when `x` is cast to a quaternion, the real part of this quaternion is equal to `x`. In other words, it states that the real part of a quaternion, created by lifting an element from a commutative ring, is exactly that element.

For any commutative ring `R` and its element `x`, the real part of the quaternion obtained from `x` equals `x`.


theorem ModularGroup.re_T_zpow_smul :
    ∀ (z : UpperHalfPlane) (n : ℤ), UpperHalfPlane.re (ModularGroup.T ^ n • z) = UpperHalfPlane.re z + ↑n := by sorry

The theorem `ModularGroup.re_T_zpow_smul` states that for any point `z` in the open upper half plane, and for any integer `n`, the real part of the result of scaling `z` by the `n`-th power of the matrix `T` (which is defined as a 2x2 matrix with entries [[1, 1], [0, 1]] in `SL(2, ℤ)`) is equal to the real part of `z` plus the integer `n`. In other words, multiplying `z` by the `n`-th power of `T` and taking the real part shifts the real part of `z` by `n` units.

For any integer `n` and point `z` in the open upper half plane, the real part of `z` multiplied by the `n`-th power of the matrix `T` in `SL(2, ℤ)` equals the real part of `z` plus `n`.


theorem ENat.coe_toNat_eq_self : ∀ {n : ℕ∞}, ↑(ENat.toNat n) = n ↔ n ≠ ⊤ := by sorry

The theorem `ENat.coe_toNat_eq_self` states that for any natural number `n` extended to include infinity (`ℕ∞`), the natural number obtained by applying the function `ENat.toNat` to `n` and then coercing it to `ℕ∞` again, is equal to `n` if and only if `n` is not equal to infinity (`⊤`). Essentially, this is saying that the `ENat.toNat` function correctly converts any finite extended natural number to a natural number and back, but it sends infinity to zero.

For any extended natural number `n`, `ENat.toNat n = n` if and only if `n` is finite.


FreeGroup.Red.exact

theorem FreeGroup.Red.exact :
    ∀ {α : Type u} {L₁ L₂ : List (α × Bool)}, FreeGroup.mk L₁ = FreeGroup.mk L₂ ↔ Relation.Join FreeGroup.Red L₁ L₂ :=
  by sorry

This theorem, named `FreeGroup.Red.exact`, is about free groups and certain relations between them. For every type `α` and any two lists `L₁` and `L₂` of pairs of `α` and `Bool`, it states that the canonical map to the free group on `α` (denoted by `FreeGroup.mk`) applied to `L₁` is equal to `FreeGroup.mk` applied to `L₂` if and only if `L₁` and `L₂` are related by the join of the reflexive-transitive closure of `Red.Step` (denoted by `Relation.Join FreeGroup.Red`). In other words, two lists are identified in the free group if and only if there exists a common list they can both be transformed into by series of `Red.Step` operations.

For any type `α` and lists `L₁` and `L₂` of pairs of `α` and `Bool`, the canonical maps from `L₁` and `L₂` to the free group on `α` are equal if and only if `L₁` and `L₂` are related by the reflexive-transitive closure of `Red.Step` in the free group on `α`.


theorem CategoryTheory.MorphismProperty.IsInvertedBy.of_subset :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {D : Type u_1}
      [inst_1 : CategoryTheory.Category.{u_2, u_1} D] (P Q : CategoryTheory.MorphismProperty C)
      (F : CategoryTheory.Functor C D),
      CategoryTheory.MorphismProperty.IsInvertedBy Q F → P ⊆ Q → CategoryTheory.MorphismProperty.IsInvertedBy P F :=
  by sorry

This theorem states that if we have two morphism properties `P` and `Q` in a category `C`, and a functor `F` from `C` to another category `D`, then if `Q` is inverted by `F` and `P` is a subset of `Q`, then `P` is also inverted by `F`. In other words, if `F` maps all morphisms in `Q` to isomorphisms in `D` and all morphisms in `P` are also in `Q`, then `F` also maps all morphisms in `P` to isomorphisms in `D`. This theorem is a statement about the preservation of morphism properties under functors in category theory.

If `F` is a functor from category `C` to `D`, `P` and `Q` are morphism properties with `P` a subset of `Q`, and all morphisms in `Q` are mapped to isomorphisms in `D` by `F`, then all morphisms in `P` are also mapped to isomorphisms in `D` by `F`.


theorem lowerCentralSeries_eq_bot_iff_nilpotencyClass_le :
    ∀ {G : Type u_1} [inst : Group G] [hG : Group.IsNilpotent G] {n : ℕ},
      lowerCentralSeries G n = ⊥ ↔ Group.nilpotencyClass G ≤ n :=
  by sorry

The theorem `lowerCentralSeries_eq_bot_iff_nilpotencyClass_le` states that for any group `G` that is nilpotent, the `n`th term of its lower central series is the trivial subgroup if and only if the nilpotency class of `G` is less than or equal to `n`. In other words, if we reach the bottom of the lower central series at step `n`, then the nilpotency class of the group (the minimum natural number at which the upper central series reaches the entire group) must be at most `n`.

For any nilpotent group G, the n-th term of its lower central series is the trivial subgroup if and only if the nilpotency class of G is less than or equal to n.


theorem Finset.sort_eq :
    ∀ {α : Type u_1} (r : α → α → Prop) [inst : DecidableRel r] [inst_1 : IsTrans α r] [inst_2 : IsAntisymm α r]
      [inst_3 : IsTotal α r] (s : Finset α), ↑(Finset.sort r s) = s.val :=
  by sorry

The theorem `Finset.sort_eq` states that for any type `α`, given a relation `r` on `α` that is decidable, transitive, antisymmetric, and total, and any finite set `s` of type `α`, the list of elements obtained by sorting the set `s` using `r` is exactly the multiset value of `s`. In other words, sorting a finite set under these conditions does not alter the underlying elements, it merely arranges them according to the relation `r`.

For any decidable, transitive, antisymmetric, and total relation `r` on type `α` and finite set `s` of type `α`, the sorted list obtained using `r` is equal to the multiset of `s`.


theorem FreeAddGroup.toWord_injective : ∀ {α : Type u} [inst : DecidableEq α], Function.Injective FreeAddGroup.toWord :=
  by sorry

The theorem `FreeAddGroup.toWord_injective` states that for all types `α` with decidable equality, the function `FreeAddGroup.toWord` is injective. In other words, for any two elements of the additive free group, if their maximal reductions (computed by `FreeAddGroup.toWord`) are equal, then the two original elements themselves must be equal. This property is essential in situations where we need to ensure that different elements map to different reductions, thus preserving uniqueness.

The function `FreeAddGroup.toWord` from the additive free group to its quotient by the equivalence relation of commutativity and associativity maps equal elements to equal words.


theorem MeasureTheory.Measure.measurePreserving_neg :
    ∀ {G : Type u_2} [inst : MeasurableSpace G] [inst_1 : Neg G] [inst_2 : MeasurableNeg G]
      (μ : MeasureTheory.Measure G) [inst_3 : MeasureTheory.Measure.IsNegInvariant μ],
      MeasureTheory.MeasurePreserving Neg.neg μ μ :=
  by sorry

The theorem `MeasureTheory.Measure.measurePreserving_neg` states that for any type `G` which has a `MeasurableSpace` and `Neg` structure, any `MeasurableNeg` function `Neg.neg` and a measure `μ` in the `MeasureTheory.Measure` class that is invariant under negation (`MeasureTheory.Measure.IsNegInvariant μ`), the `Neg.neg` function is measure-preserving (denoted by `MeasureTheory.MeasurePreserving Neg.neg μ μ`). This means that the measure of a set and the measure of its image under negation are the same. The `Neg.neg` function computes the negative or opposite of a given number in `G`, and "measure-preserving" means that the measure of a set remains the same after the transformation.

For any measure-preserving negation function and invariant-under-negation measure on a measurable space, the negation function is measure-preserving.


theorem Commute.inv_left₀ : ∀ {G₀ : Type u_3} [inst : GroupWithZero G₀] {a b : G₀}, Commute a b → Commute a⁻¹ b := by
  sorry

This theorem states that for any type `G₀` that forms a group with zero (a group that has an identity element and an inverse for every nonzero element), if two elements `a` and `b` commute (i.e., `a * b = b * a`), then the inverse of `a` and `b` also commute. In mathematical terms, if `a * b = b * a` then `(a⁻¹) * b = b * (a⁻¹)`. This essentially states that commutativity is preserved under the operation of taking inverses.

If `a` and `b` are elements of a group with inverses such that `a * b = b * a`, then `(a⁻¹) * b = b * (a⁻¹)`.


theorem isQuasiSeparated_univ_iff :
    ∀ {α : Type u_3} [inst : TopologicalSpace α], IsQuasiSeparated Set.univ ↔ QuasiSeparatedSpace α := by sorry

This theorem states that for any type α that has a topological space structure, the universal set of α (i.e., the set of all elements of α) is quasi-separated if and only if α is a quasi-separated space. Here, a set is described as quasi-separated if the intersection of any pair of compact open subsets of that set remains compact. The universal set is quasi-separated means that for any two compact open subsets, their intersection is also compact. Conversely, a quasi-separated space means the entire space has this property, so it is a generalization of the concept to the whole topological space.

A topological space α is quasi-separated if and only if its universal set, i.e., the set of all elements in α, is quasi-separated.


theorem Finset.univ_nonempty_iff : ∀ {α : Type u_1} [inst : Fintype α], Finset.univ.Nonempty ↔ Nonempty α := by sorry

This theorem, `Finset.univ_nonempty_iff`, states that for any type `α` that has an instance of `Fintype α`, the universal finite set of that type (denoted as `Finset.univ`) is nonempty if and only if `α` is nonempty. In other words, there exists at least one element in the universal finite set of the type `α` if and only if there exists at least one element of the type `α`. This theorem provides an equivalence relationship between the nonemptiness of `Finset.univ` and the nonemptiness of `α`.

The universal finite set of a nonempty type is nonempty.


theorem RingSubgroupsBasis.hasBasis_nhds_zero :
    ∀ {A : Type u_1} {ι : Type u_2} [inst : Ring A] [inst_1 : Nonempty ι] {B : ι → AddSubgroup A}
      (hB : RingSubgroupsBasis B), Filter.HasBasis (nhds 0) (fun x => True) fun i => ↑(B i) :=
  by sorry

The theorem `RingSubgroupsBasis.hasBasis_nhds_zero` states that for any type `A` with a ring structure and any index type `ι`, given a family `B` of additive subgroups of `A` indexed by `ι` and assuming `B` forms a ring subgroups basis, the neighborhood filter at zero in `A` has a basis consisting of the carrier sets of the members of `B`. Here, a basis of a filter in topology is a collection of sets such that every set in the filter can be written as a union of sets from this collection.

For any ring `A` and indexed family `B` of additive subgroups of `A` forming a ring subgroup basis, the neighborhood filter at zero in `A` has a basis consisting of the carrier sets of members of `B`.


HasStrictFDerivAt.add

theorem HasStrictFDerivAt.add :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {f g : E → F}
      {f' g' : E →L[𝕜] F} {x : E},
      HasStrictFDerivAt f f' x → HasStrictFDerivAt g g' x → HasStrictFDerivAt (fun y => f y + g y) (f' + g') x :=
  by sorry

The theorem `HasStrictFDerivAt.add` states that if we have two functions `f` and `g` from a normed add commutative group `E` to another normed add commutative group `F`, over a nontrivially normed field `𝕜`, and if both `f` and `g` have strict Frechet derivatives (`f'` and `g'` respectively) at a point `x` in `E`, then the sum of the functions `f` and `g` also has a strict Frechet derivative at `x`, and its derivative is the sum of `f'` and `g'`.

If functions `f` and `g` from a normed add commutative group `E` to another normed add commutative group `F` over a nontrivially normed field have strict Frechet derivatives `f'` and `g'` at a point `x` in `E`, then the function `f + g` has a strict Frechet derivative `f' + g'` at `x`.


NNReal.IsConjExponent.pos

theorem NNReal.IsConjExponent.pos : ∀ {p q : NNReal}, p.IsConjExponent q → 0 < p := by sorry

This theorem states that for any two nonnegative real numbers `p` and `q`, if `p` is the conjugate exponent of `q`, then `p` is strictly greater than zero.

For any nonnegative real number `q` with conjugate exponent `p`, `p` strictly exceeds zero.