theorem Mathlib.Data.ENNReal.Basic._auxLemma.32 : (2 = ⊤) = False := by sorry

This theorem states that the number 2 is not equal to infinity. In Lean, "⊤" is used to represent infinity, usually in the context of extended non-negative real numbers (where real numbers are extended by adding infinity as a value). The proof, which is not shown here, establishes that 2 cannot be the same as infinity, which is intuitively obvious in the realm of real numbers.

The theorem asserts that 2 is not equal to infinity (2 ≠ ⊤) in the context of extended non-negative real numbers.


theorem minpoly.eq_zero :
    ∀ {A : Type u_1} {B : Type u_2} [inst : CommRing A] [inst_1 : Ring B] [inst_2 : Algebra A B] {x : B},
      ¬IsIntegral A x → minpoly A x = 0 :=
  by sorry

The theorem `minpoly.eq_zero` is stating that for all types `A` and `B`, where `A` is a commutative ring and `B` is a ring, and there is an algebraic structure from `A` to `B`, then for any element `x` of `B`, if `x` is not integral over `A` -- that is, `x` is not a root of any monic polynomial with coefficients in `A` -- then the minimal polynomial of `x` over `A` is the zero polynomial.

If `x` is an element of a ring `B` that is not integral over a commutative ring `A`, then the minimal polynomial of `x` over `A` is the zero polynomial.


/-- Abbreviation for `single_eq_of_ne h.symm`, for ease of use by `simp`. -/
theorem Pi.single_eq_of_ne' :
    ∀ {I : Type u} {f : I → Type v₁} [inst : DecidableEq I] [inst_1 : (i : I) → Zero (f i)] {i i' : I},
      i ≠ i' → ∀ (x : f i), Pi.single i x i' = 0 :=
  by sorry

This theorem, `Pi.single_eq_of_ne'`, states that for any type `I`, a function `f` from `I` to some type `v₁`, given that equality is decidable on `I` and for every `i` in `I` there exists a zero in `f i`, if `i` is not equal to `i'`, then for any `x` from `f i`, the function `Pi.single i x i'` is equal to zero. In simpler words, this theorem asserts that for a function defined at a specific point `i` with value `x` and `0` elsewhere, if we evaluate this function at a different point `i'`, the value will be `0`.

Given a function from type `I` to some type, if equality is decidable on `I` and for every `i ≠ i'` in `I`, there exists a zero in the function's value at `i`, then for all `x` in the function's value at `i`, the function's value at `i'` is equal to zero.


theorem iInf_Prop_eq : ∀ {ι : Sort u_5} {p : ι → Prop}, ⨅ i, p i = ∀ (i : ι), p i := by sorry

This theorem states that for any type `ι` and for any predicate `p` that takes an instance of type `ι` and returns a proposition, the infimum (`⨅ i`) of the predicate `p` over all `i` is equivalent to the statement that the predicate `p` holds for all `i`. In other words, it says that the infimum of a set of propositions is true if and only if all propositions in the set are true.

The infimum of a set of propositions is equivalent to their conjunction.


PSet.Mem.mk

theorem PSet.Mem.mk : ∀ {α : Type u} (A : α → PSet) (a : α), A a ∈ PSet.mk α A := by sorry

This theorem, `PSet.Mem.mk`, asserts that, given any type `α`, any function `A` from `α` to `PSet` (the set of all sets), and any element `a` of `α`, `A a` is an element of the set `PSet.mk α A`. This essentially means that any application of the function `A` to an element of its domain `α` results in an element of the set defined by `α` and `A`.

For any type `α` and function `A` from `α` to sets, `A a` is an element of the set `PSet.mk α A` for all `a` in `α`.


AnalyticAt.comp

/-- If two functions `g` and `f` are analytic respectively at `f x` and `x`, then `g ∘ f` is
analytic at `x`.  -/
theorem AnalyticAt.comp :
    ∀ {𝕜 : Type u_1} {E : Type u_2} {F : Type u_3} {G : Type u_4} [inst : NontriviallyNormedField 𝕜]
      [inst_1 : NormedAddCommGroup E] [inst_2 : NormedSpace 𝕜 E] [inst_3 : NormedAddCommGroup F]
      [inst_4 : NormedSpace 𝕜 F] [inst_5 : NormedAddCommGroup G] [inst_6 : NormedSpace 𝕜 G] {g : F → G} {f : E → F}
      {x : E}, AnalyticAt 𝕜 g (f x) → AnalyticAt 𝕜 f x → AnalyticAt 𝕜 (g ∘ f) x :=
  by sorry

The theorem `AnalyticAt.comp` states that if we have two functions `g` and `f` which are analytic at the points `f(x)` and `x` respectively, then the composition of `g` and `f` (denoted by `g ∘ f`) is also analytic at the point `x`. Here, a function is said to be analytic at a point if it can be written as a convergent power series around that point. This theorem is defined over a non-trivially normed field `𝕜`, and the function `f` maps from a normed vector space `E` over `𝕜` to another normed vector space `F` over `𝕜`, while `g` maps from `F` to yet another normed vector space `G` over `𝕜`.

If functions `f: E → F` and `g: F → G` are analytic at points `x` and `f(x)` respectively over a non-trivially normed field `𝕜`, then their composition `g ∘ f` is analytic at point `x`.


theorem compl_bot : ∀ {α : Type u_2} [inst : HeytingAlgebra α], ⊥ᶜ = ⊤ := by sorry

This theorem states that for all types `α` that form a Heyting algebra, the complement of the bottom element, denoted as `⊥` (such equivalent to false in boolean algebra), is equal to the top element, denoted as `⊤` (such equivalent to true in boolean algebra). This is analogous to the law in classical logic where the negation of false is true.

In a Heyting algebra, the complement of the bottom element is equal to the top element.


theorem iSup_image :
    ∀ {α : Type u_1} {β : Type u_2} [inst : CompleteLattice α] {γ : Type u_9} {f : β → γ} {g : γ → α} {t : Set β},
      ⨆ c ∈ f '' t, g c = ⨆ b ∈ t, g (f b) :=
  by sorry

The theorem `iSup_image` states that for any types `α`, `β`, `γ`, where `α` is a complete lattice, and any functions `f` from `β` to `γ` and `g` from `γ` to `α`, and a set `t` of type `β`, the supremum (denoted by `⨆`) of the image of `t` under `f`, after applying `g`, is equal to the supremum of `t`, after applying `g` composed with `f`. In other words, it shows that the order of taking supremum and applying the function composition `g ∘ f` can be swapped.

For any complete lattice α, functions f : β → γ and g : γ → α, and set t ⊆ β, the image of the supremum of t under g ∘ f is equal to the supremum of the image of t under f, then applied to the supremum of the resulting values under g.


/-- See `zero_lt_one` for a version with the type implicit.  -/
theorem zero_lt_one' :
    ∀ (α : Type u_1) [inst : Zero α] [inst_1 : One α] [inst_2 : PartialOrder α] [inst_3 : ZeroLEOneClass α]
      [inst_4 : NeZero 1], 0 < 1 :=
  by sorry

This theorem, `zero_lt_one'`, states that for any type `α` which has the operations of zero and one defined, and also has a partial order and a `ZeroLEOneClass`, which asserts that zero is less than or equal to one, we always have that zero is strictly less than one, given an additional constraint that one is not equal to zero.

For any type with zero, one, a partial order, and `ZeroLEOneClass` where one is non-zero, zero is strictly less than one.


theorem integral_pow : ∀ {a b : ℝ} (n : ℕ), ∫ (x : ℝ) in a..b, x ^ n = (b ^ (n + 1) - a ^ (n + 1)) / (↑n + 1) := by
  sorry

This theorem, `integral_pow`, states that for any real numbers `a` and `b`, and any natural number `n`, the definite integral of `x^n` with respect to `x` from `a` to `b` is equal to `(b^(n+1) - a^(n+1))/(n+1)`. In mathematical notation, this would be written as `∫_a^b x^n dx = (b^(n+1) - a^(n+1)) / (n+1)`.

The definite integral of `x^n` from `a` to `b` equals `(b^(n+1) - a^(n+1)) / (n+1)`.


ContMDiffAt.contMDiffWithinAt

theorem ContMDiffAt.contMDiffWithinAt :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {H : Type u_3} [inst_3 : TopologicalSpace H] {I : ModelWithCorners 𝕜 E H}
      {M : Type u_4} [inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] {E' : Type u_5}
      [inst_6 : NormedAddCommGroup E'] [inst_7 : NormedSpace 𝕜 E'] {H' : Type u_6} [inst_8 : TopologicalSpace H']
      {I' : ModelWithCorners 𝕜 E' H'} {M' : Type u_7} [inst_9 : TopologicalSpace M'] [inst_10 : ChartedSpace H' M']
      {f : M → M'} {s : Set M} {x : M} {n : ℕ∞}, ContMDiffAt I I' n f x → ContMDiffWithinAt I I' n f s x :=
  by sorry

The theorem `ContMDiffAt.contMDiffWithinAt` states that for any non-trivially normed field `𝕜`, given normed add commutative groups `E` and `E'` with normed spaces over `𝕜`, topological spaces `H`, `M`, `H'`, and `M'`, model structures `I` and `I'` with corners from `𝕜` and `E` to `H` and from `𝕜` and `E'` to `H'` respectively, a charted space structure over `M` with model `I` and chart `H`, a charted space structure over `M'` with model `I'` and chart `H'`, a function `f` from `M` to `M'`, a set `s` of elements of `M`, a point `x` in `M`, and a natural number `n`, if the function `f` is continuously differentiable at the point `x` to the `n`-th order, then it is also continuously differentiable within the set `s` at the point `x` to the `n`-th order.

If `f: M → M'` is a function continuously differentiable to order `n` at `x ∈ M` between charted spaces over normed groups `E` and `E'` with normed spaces over a non-trivially normed field `𝕜`, then `f` is continuously differentiable to order `n` within any set `s ∈ M` at `x`.


/-- **Alias** of `eqRec_heq`. -/
theorem eq_rec_heq : ∀ {α : Sort u} {φ : α → Sort v} {a a' : α} (h : a = a') (p : φ a), HEq (Eq.recOn h p) p := by sorry

The theorem `eq_rec_heq` states that for any type `α`, any function `φ` from `α` to some other type, and any two elements `a` and `a'` of `α` such that `a` equals `a'`, the heterogeneous equality (`HEq`) between an application of `Eq.recOn` with arguments `h` (the proof of `a = a'`) and `p` (an element of the type φ `a`), and `p` itself, holds. Essentially, the theorem is stating that `Eq.recOn` does not change the given element `p` when the equality proof `h` is used.

For any type `α`, function `φ : α →Type _, elements `a` and `a'` of `α` with `a = a'`, and `p : φ a`, `Eq.recOn h p = p`, where `h : a = a'` is a proof of equality.


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

The theorem `CategoryTheory.Limits.prod.lift_snd` states that for a category `C`, and objects `W`, `X`, and `Y` in `C`, if `X` and `Y` have a binary product, then for any two morphisms `f : W ⟶ X` and `g : W ⟶ Y`, the composition of the morphism induced by `prod.lift f g` and the projection to the second component of the product (`CategoryTheory.Limits.prod.snd`) is equal to `g`. In other words, given any two morphisms from `W` to `X` and `W` to `Y`, the diagram commutes, i.e., the path via the product and then projection to `Y` is the same as the direct path to `Y` via `g`.

Given a category with binary products, for any two morphisms from a object W to X and Y, where X and Y have a product, the diagram commuting from the product and the projections holds, that is, `prod.snd (prod.lift f g) = g`.


/-- Corresponds to `dist_comm`.  -/
theorem hammingDist_comm :
    ∀ {ι : Type u_2} {β : ι → Type u_3} [inst : Fintype ι] [inst_1 : (i : ι) → DecidableEq (β i)] (x y : (i : ι) → β i),
      hammingDist x y = hammingDist y x :=
  by sorry

The theorem `hammingDist_comm` states that the Hamming distance between two vectors `x` and `y` over a finite type `ι` is commutative. In other words, for any two vectors `x` and `y` from the space indexed by type `ι`, where each element of the space has a decidable equality, the Hamming distance from `x` to `y` is the same as the Hamming distance from `y` to `x`. The Hamming distance is calculated as the number of positions at which the corresponding values are different.

For any two vectors `x` and `y` of equal length over a finite type `ι` with decidable equality, the Hamming distance between `x` and `y` equals the Hamming distance between `y` and `x`.


theorem Matrix.zpow_coe_nat :
    ∀ {n' : Type u_1} [inst : DecidableEq n'] [inst_1 : Fintype n'] {R : Type u_2} [inst_2 : CommRing R]
      (A : Matrix n' n' R) (n : ℕ), A ^ ↑n = A ^ n :=
  by sorry

This theorem, `Matrix.zpow_coe_nat`, states that for a square matrix `A` with entries in a commutative ring `R`, rows and columns indexed by a type `n'` which has decidable equality and is a finite type, the power of `A` raised to the natural number `n` cast to an integer (`A ^ ↑n`) is the same as the power of `A` raised to `n` (`A ^ n`). In other words, raising a matrix to a natural number power is the same whether we treat the exponent as a natural number or an integer.

For a square matrix over a commutative ring with decidable equality and finite index type, raising it to a natural number power and then casting the power to an integer equals raising it directly to that natural number power.


theorem Concept.snd_subset_snd_iff :
    ∀ {α : Type u_2} {β : Type u_3} {r : α → β → Prop} {c d : Concept α β r}, c.toProd.2 ⊆ d.toProd.2 ↔ d ≤ c := by
  sorry

This theorem states that for any two concepts `c` and `d` (of types α and β respectively, related by a property `r`), the second component of the product representation of `c` is a subset of the second component of `d` if and only if `d` is less than or equal to `c`. The less than or equal to relation here is referring to the order defined on concepts, which can be different depending on the specific definition of concepts in the context.

For concepts `c` and `d` of types `α` and `β` with a relation `r` between them, the second components of their product representations satisfy `second c ≤ second d` if and only if `d ≤ c` in the concept order.


Function.IsFixedPt.iterate

/-- If `x` is a fixed point of `f`, then it is a fixed point of `f^[n]`.  -/
theorem Function.IsFixedPt.iterate :
    ∀ {α : Type u} {f : α → α} {x : α}, Function.IsFixedPt f x → ∀ (n : ℕ), Function.IsFixedPt f^[n] x := by sorry

This theorem states that if a point `x` is a fixed point of a function `f` (meaning that applying `f` to `x` yields `x`), then `x` is also a fixed point of the `n`th iterate of `f`. In mathematical terms, if `f(x) = x`, then `f^n(x) = x` for all natural numbers `n`, where `f^n` denotes the function `f` applied `n` times.

If `x` is a fixed point of the function `f`, then `x` is also a fixed point of `f^n` for all natural numbers `n`.


theorem WithTop.mul_top :
    ∀ {α : Type u_1} [inst : DecidableEq α] [inst_1 : MulZeroClass α] {a : WithTop α}, a ≠ 0 → a * ⊤ = ⊤ := by sorry

This theorem states that for any type `α` which has decidable equality and a multiplication operation that includes a zero element, a non-zero element `a` of the extended type 'WithTop α' (which includes the original type `α` and an additional top element `⊤`), the product of `a` and `⊤` is `⊤`. The result `⊤` can be thought of as an "infinity" or "undefined" value, thus, this theorem essentially states that any non-zero number multiplied by infinity equals infinity.

For any type `α` with decidable equality and a multiplicative identity `⊤`, the product of a non-zero element `a` in `α` and the top element `⊤` in `WithTop α` equals the top element `⊤`.


theorem Fin.lt_def : ∀ {n : ℕ} {a b : Fin n}, a < b ↔ ↑a < ↑b := by sorry

This theorem, `Fin.lt_def`, states that for any natural number `n` and any two elements `a` and `b` of the finite set `Fin n`, the statement "a is less than b" is equivalent to the statement "the natural number corresponding to a is less than the natural number corresponding to b". Here, the `↑` operator is used to cast (or "lift") elements of `Fin n` into the natural numbers.

For any natural number `n` and `a`, `b` in `Fin n`, `a < b` if and only if `↑a < ↑b`.


DifferentiableAt.fderivWithin

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

The theorem `DifferentiableAt.fderivWithin` states that for any nontrivially normed field `𝕜`, any normed vector spaces `E` and `F` over `𝕜`, any function `f` from `E` to `F`, any point `x` in `E`, and any set `s` of elements in `E`, if the function `f` is differentiable at point `x` and the tangent space to `s` at `x` is unique (`UniqueDiffWithinAt 𝕜 s x`), then the derivative of `f` at `x` within `s` (`fderivWithin 𝕜 f s x`) equals the derivative of `f` at `x` (`fderiv 𝕜 f x`). In mathematical terms, this theorem states that if a function's derivative exists at a point and the tangent space at that point is unique, then the derivative within a subset is the same as the derivative over the entire space.

If a function is differentiable at a point x in a normed vector space, and the tangent space to any set s at x is unique, then the derivative of the function within s at x equals the derivative of the function at x.


theorem Ideal.le_jacobson : ∀ {R : Type u} [inst : Ring R] {I : Ideal R}, I ≤ Ideal.jacobson I := by sorry

This theorem states that for any ring `R` and any ideal `I` in `R`, `I` is a subset of or equal to the Jacobson radical of `I`. In other words, given any ring `R` and an ideal `I` of that ring, every element of `I` is also included in its Jacobson radical. Here, the Jacobson radical of an ideal is defined as the infimum or the greatest lower bound of all maximal left ideals containing `I`.

For any ring `R` and ideal `I` in `R`, `I` is contained in the Jacobson radical of `I`.


Embedding.discreteTopology

/-- The topology induced under an inclusion `f : X → Y` from a discrete topological space `Y`
is the discrete topology on `X`.

See also `DiscreteTopology.of_continuous_injective`.  -/
theorem Embedding.discreteTopology :
    ∀ {X : Type u_1} {Y : Type u_2} {f : X → Y} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y]
      [inst_2 : DiscreteTopology Y], Embedding f → DiscreteTopology X :=
  by sorry

This theorem states that for any two types `X` and `Y`, and a function `f` from `X` to `Y`, if `Y` is a discrete topological space, and if `f` is an embedding (i.e., a function that is injective and has its image being a topologically identical subset of `Y`), then `X` must also be a discrete topological space. This is also related to `DiscreteTopology.of_continuous_injective`, another theorem in the context of discrete topologies.

If `X` is a type, `Y` is a discrete topological space, and `f : X → Y` is an injective function whose image is a topologically identical subset of `Y`, then `X` is a discrete topological space.


/-- A subfield is closed under inverses.  -/
theorem Subfield.inv_mem : ∀ {K : Type u} [inst : DivisionRing K] (s : Subfield K) {x : K}, x ∈ s → x⁻¹ ∈ s := by sorry

This theorem states that a subfield is closed under the operation of taking inverses. Specifically, for any type 'K' that has a structure of a division ring, any subfield 's' of 'K', and any element 'x' of 'K', if 'x' is in 's', then the inverse of 'x' is also in 's'.

In a division ring 'K', the subfield 's' is closed under taking inverses, i.e., if 'x' is an element of 's', then the multiplicative inverse of 'x' is also an element of 's'.


theorem Rat.le_iff_Nonneg : ∀ (a b : ℚ), a ≤ b ↔ Rat.Nonneg (b - a) := by sorry

The theorem `Rat.le_iff_Nonneg` states that for any two rational numbers `a` and `b`, `a` is less than or equal to `b` if and only if the difference `(b - a)` is a nonnegative rational number. Here, a rational number is considered nonnegative if its numerator is nonnegative.

A rational number `a` is less than or equal to another rational number `b` if and only if the difference `b - a` is a non-negative rational number.


theorem dvd_sub : ∀ {α : Type u_1} [inst : NonUnitalRing α] {a b c : α}, a ∣ b → a ∣ c → a ∣ b - c := by sorry

This theorem named `dvd_sub` is a universal statement in the context of a non-unital ring `α`. For any elements `a`, `b`, and `c` in this ring, if `a` divides `b` and `a` divides `c`, then `a` also divides the difference between `b` and `c`. In mathematical terms, it's stating that in a non-unital ring, the divisibility relation is preserved under subtraction.

In a non-unital ring, if `a` divides both `b` and `c`, then `a` divides the difference `b - c`.


theorem Stream'.Seq.map_cons :
    ∀ {α : Type u} {β : Type v} (f : α → β) (a : α) (s : Stream'.Seq α),
      Stream'.Seq.map f (Stream'.Seq.cons a s) = Stream'.Seq.cons (f a) (Stream'.Seq.map f s) :=
  by sorry

This theorem, named `Stream'.Seq.map_cons`, states that for any types `α` and `β`, any function `f` from `α` to `β`, any element `a` of type `α`, and any sequence `s` of type `α`, mapping function `f` over the sequence obtained by prepending `a` to `s` is equivalent to prepending `f(a)` to the sequence obtained by mapping `f` over `s`. In essence, this theorem describes the property of the function `Stream'.Seq.map` commuting with the function `Stream'.Seq.cons`, a key characteristic of the functorial nature of sequences.

For any types `α` and `β`, functions `f : α → β`, elements `a : α`, and sequences `s : Stream α`, the application of `f` to the sequence obtained by consing `a` to `s` is equal to the sequence obtained by consing `f a` to the sequence obtained by applying `f` to `s`.


theorem Multiset.map_const :
    ∀ {α : Type u_1} {β : Type v} (s : Multiset α) (b : β),
      Multiset.map (Function.const α b) s = Multiset.replicate (Multiset.card s) b :=
  by sorry

This theorem states that for any multiset `s` of type `α` and any value `b` of type `β`, if we apply `Multiset.map` to `s` using the constant function with value `b` (`Function.const α b`), then the resulting multiset is equivalent to a multiset that contains only the value `b` repeated `Multiset.card s` times (`Multiset.replicate (Multiset.card s) b`). In other words, mapping a constant function over a multiset simply replaces every element in the multiset with the constant value, yielding a new multiset where the constant value is repeated as many times as the original multiset's cardinality.

For any multiset `s` and value `b`, `Multiset.map (Function.const _ _) s = Multiset.replicate (Multiset.card s) b`.


theorem Fintype.sum_eq_single :
    ∀ {α : Type u_1} {M : Type u_4} [inst : Fintype α] [inst_1 : AddCommMonoid M] {f : α → M} (a : α),
      (∀ (x : α), x ≠ a → f x = 0) → (Finset.sum Finset.univ fun x => f x) = f a :=
  by sorry

This theorem, `Fintype.sum_eq_single`, states that for any type `α` with a finite number of instances (as indicated by `Fintype α`) and any type `M` with addition and commutativity (as indicated by `AddCommMonoid M`), given a function `f` from `α` to `M` and an element `a` of `α`, if `f(x)` equals zero for all `x` in `α` that are not equal to `a`, then the sum of `f(x)` for all `x` in the universal finite set of `α` is equal to `f(a)`. In mathematical terms, this could be expressed as $\sum_{x \in X} f(x) = f(a)$ for $f(x) = 0$ when $x \neq a$, where the sum ranges over all elements in the finite set.

For a finite type `α` and an `AddCommMonoid M` with function `f` from `α` to `M` such that `f(x) = 0` for all `x ≠ a`, the sum of `f(x)` over `α` equals `f(a)`.


theorem ChainComplex.next_nat_zero : ComplexShape.next (ComplexShape.down ℕ) 0 = 0 := by sorry

This theorem states that when we consider the "down" direction ComplexShape, which is suitable for homology and in which a morphism `d : X i ⟶ X j` exists only when `i = j + 1`, the "next" index after `0` remains `0`. In other words, if we are at the start (`0`) of a chain complex defined over natural numbers (`ℕ`), the next index, according to the down direction ComplexShape, is also `0`.

In the context of a chain complex over natural numbers with the "down" direction, the successor index is equal to zero.


theorem CategoryTheory.Iso.refl_trans :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} (α : X ≅ Y),
      CategoryTheory.Iso.refl X ≪≫ α = α :=
  by sorry

This theorem states that for any category `C` and any two objects `X` and `Y` in `C`, if there is an isomorphism `α` between `X` and `Y`, then the composition of the identity isomorphism on `X` and `α` is equal to `α`. This identity isomorphism is defined such that its forward and backward morphisms are simply the identity on `X`. In other words, pre-composing the isomorphism `α` with the identity mapping on `X` doesn't change `α`.

Given any category C, isomorphism α between objects X and Y in C implies identity on X ∘ α = α.


theorem Finset.sum_image :
    ∀ {α : Type u_3} {β : Type u_4} {γ : Type u_5} {f : α → β} [inst : AddCommMonoid β] [inst_1 : DecidableEq α]
      {s : Finset γ} {g : γ → α},
      (∀ x ∈ s, ∀ y ∈ s, g x = g y → x = y) →
        (Finset.sum (Finset.image g s) fun x => f x) = Finset.sum s fun x => f (g x) :=
  by sorry

The theorem `Finset.sum_image` states that for any types α, β, and γ, a function `f` from α to β, a finite set `s` of elements of type γ, a function `g` from γ to α, as long as `g` sends different elements in `s` to different elements, the sum of `f` over the image of `s` under `g` equals to the sum of `f` after applying `g` over the elements of `s`. In simpler terms, the sum of the function values at the images is the same as the sum of the function values at the originals, provided that the mapping function maintains distinctness among elements.

For any functions `f: α -> β`, `g: γ -> α` with `g(s)` injective for a finite set `s` in γ, the sum of `f` over `g(s)` equals the sum of `f` applied to `s`.


theorem Ideal.comap_mono :
    ∀ {R : Type u} {S : Type v} {F : Type u_1} [inst : Semiring R] [inst_1 : Semiring S] [inst_2 : FunLike F R S]
      [rc : RingHomClass F R S] {f : F} {K L : Ideal S}, K ≤ L → Ideal.comap f K ≤ Ideal.comap f L :=
  by sorry

The theorem `Ideal.comap_mono` states that for any semirings `R` and `S`, and any function `f` that is a ring homomorphism from `R` to `S`, if we have two ideals `K` and `L` in `S` such that `K` is a subset of `L`, then the preimage of `K` under `f` is a subset of the preimage of `L` under `f`. In other words, the function `Ideal.comap f`, which maps an ideal of `S` to an ideal of `R`, preserves the subset order between ideals.

For any semirings R and S, and ring homomorphism f from R to S, if K is an ideal of S containing L, then the preimage f⁁⁻¹(K) is an ideal of R containing f⁁⁻¹(L).


theorem AddMonoidHom.id_comp :
    ∀ {M : Type u_4} {N : Type u_5} [inst : AddZeroClass M] [inst_1 : AddZeroClass N] (f : M →+ N),
      AddMonoidHom.comp (AddMonoidHom.id N) f = f :=
  by sorry

This theorem states that for any additive monoids `M` and `N`, and for any additive monoid morphism `f` from `M` to `N`, composing `f` with the identity map on `N` yields `f` itself. In other words, if we first apply the morphism `f`, and then apply the identity transformation, the overall effect is the same as just applying `f`. This is consistent with the mathematical concept of an identity function, which leaves its argument unchanged.

For any additive monoid morphism `f` from `M` to `N`, the composition `f ∘ id_N` equals `f`, where `id_N` is the identity map on `N`.


theorem groupCohomology.mem_oneCocycles_iff :
    ∀ {k G : Type u} [inst : CommRing k] [inst_1 : Group G] {A : Rep k G} (f : G → CoeSort.coe A),
      f ∈ groupCohomology.oneCocycles A ↔ ∀ (g h : G), f (g * h) = ((Rep.ρ A) g) (f h) + f g :=
  by sorry

This theorem states that for any commutative ring `k`, any group `G`, any `k`-linear representation `A` of `G`, and any function `f` from `G` to `A`, `f` is a 1-cocycle (i.e., a member of the set of 1-cocycles of `A`) if and only if, for any pair of elements `g` and `h` from `G`, the function `f` evaluated at the product `g * h` is equal to the sum of the action of `g` on `f(h)` and `f(g)`. In mathematical terms, the theorem captures the property of 1-cocycles in group cohomology: $f(g * h) = g.f(h) + f(g)$.

A function from a group to a `k`-linear representation of the group is a 1-cocycle if and only if it satisfies the condition `f(gh) = g.f(h) + f(g)` for all `g, h` in the group.


/-- For `f : α →ᵤ β`, `𝓝 f` admits the family `{g | ∀ x, (f x, g x) ∈ V}` for `V ∈ 𝓑` as a filter
basis, for any basis `𝓑` of `𝓤 β`.  -/
theorem UniformFun.hasBasis_nhds_of_basis :
    ∀ (α : Type u_1) (β : Type u_2) {ι : Type u_4} [inst : UniformSpace β] (f : UniformFun α β) {p : ι → Prop}
      {s : ι → Set (β × β)},
      Filter.HasBasis (uniformity β) p s →
        Filter.HasBasis (nhds f) p fun i => {g | (f, g) ∈ UniformFun.gen α β (s i)} :=
  by sorry

This theorem, `UniformFun.hasBasis_nhds_of_basis`, states that for any given function `f` of type `α →ᵤ β`, if the uniformity filter `𝓤 β` has a basis `{s_i}` indexed by a predicate `p`, then the neighborhood filter of `f`, denoted as `𝓝 f`, has a filter basis `{g | ∀ x, (f x, g x) ∈ V}` indexed by the same predicate `p`. Here, each `V` in the basis set of `𝓝 f` consists of pairs `(f x, g x)` that belong to the corresponding basis set `s_i` of `𝓤 β`. In simpler words, the theorem connects the filter bases of the uniformity of the codomain type and the neighborhood filter of a function in the space of uniformly continuous functions.

If `𝓤 β` is a uniformity on `β` with basis `{s_i}`, then the neighborhood filter of a function `f : α → β` has a basis `{g}` consisting of functions `g : α → β` such that `(f x, g x) ∈ s_i` for all `i` and `x`.


theorem Real.log_neg : ∀ {x : ℝ}, 0 < x → x < 1 → Real.log x < 0 := by sorry

The theorem `Real.log_neg` states that for every real number `x` that is greater than `0` and less than `1`, the real logarithm of `x` is less than `0`. In other words, it asserts that the logarithm of any real number between `0` and `1` (exclusive) is negative.

For all real numbers `x` with `0 < x < 1`, the logarithm of `x` is negative.


theorem Finset.sdiff_inter_self_right : ∀ {α : Type u_1} [inst : DecidableEq α] (s t : Finset α), s \ (t ∩ s) = s \ t :=
  by sorry

The theorem `Finset.sdiff_inter_self_right` states that for any two finite sets `s` and `t` of any type `α` that has a decidable equality, the symmetric difference of `s` with the intersection of `t` and `s` is the same as the symmetric difference of `s` with `t`. In other words, removing the elements of `s` that are in both `t` and `s` is the same as removing the elements of `s` that are in `t`.

For finite sets `s` and `t` of type `α` with decidable equality, `(s \ (s ∩ t)) = (s \ t)`.


/-- In an R₁ space, if a compact set `K` is contained in an open set `U`,
then its closure is also contained in `U`.  -/
theorem IsCompact.closure_subset_of_isOpen :
    ∀ {X : Type u_1} [inst : TopologicalSpace X] [inst_1 : R1Space X] {K : Set X},
      IsCompact K → ∀ {U : Set X}, IsOpen U → K ⊆ U → closure K ⊆ U :=
  by sorry

In a R₁ space (a topological space that satisfies the R₁ separation axiom), given a compact set `K` and an open set `U`, if `K` is a subset of `U`, then the closure of `K` is also a subset of `U`. The closure of a set is the smallest closed set that contains the original set. This theorem states that the closure of a compact set, when contained within an open set, remains within that open set in an R₁ space.

In an R₁ space, the closure of a compact set is contained in any open set that contains the set itself.


theorem Set.image2_iInter₂_subset_left :
    ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {ι : Sort u_4} {κ : ι → Sort u_7} (f : α → β → γ)
      (s : (i : ι) → κ i → Set α) (t : Set β), Set.image2 f (⋂ i, ⋂ j, s i j) t ⊆ ⋂ i, ⋂ j, Set.image2 f (s i j) t :=
  by sorry

The theorem `Set.image2_iInter₂_subset_left` states that for any types `α`, `β`, `γ`, an index type `ι`, a dependent type `κ` indexed by `ι`, a binary function `f` from `α` and `β` to `γ`, a two-level nested indexed family of sets of `α` elements `s`, and a set `t` of `β`, the image under `f` of the intersection over all `i` and `j` of `s i j` and `t` is a subset of the intersection over all `i` and `j` of the image under `f` of `s i j` and `t`. This theorem basically asserts that the image of the intersection is a subset of the intersection of the images in a specific context involving double-indexed families of sets and a binary function.

For any types α, β, γ, index type ι, dependent type κ over ι, binary function f from α × β to γ, sets s i j of α, and set t of β, the image under f of the intersection over all i and j of s i j and t is a subset of the intersection over all i and j of the images under f of s i j and t.


theorem Finset.eq_singleton_iff_unique_mem :
    ∀ {α : Type u_1} {s : Finset α} {a : α}, s = {a} ↔ a ∈ s ∧ ∀ x ∈ s, x = a := by sorry

This theorem states that for any given set `s` of type `α` and any element `a` of the same type, `s` is a singleton set containing only `a` if and only if `a` is an element of `s` and any other element `x` in `s` is equal to `a`. In other words, `s` equals the set `{a}` exactly when `s` contains `a` and no other distinct elements.

A set `s` of type `α` is a singleton containing only `a` if and only if `a` is an element of `s` and for all `x` in `s`, `x = a`.


theorem Finsupp.support_erase :
    ∀ {α : Type u_1} {M : Type u_5} [inst : Zero M] [inst_1 : DecidableEq α] {a : α} {f : α →₀ M},
      (Finsupp.erase a f).support = Finset.erase f.support a :=
  by sorry

The theorem `Finsupp.support_erase` states that for any type `α` and `M` where `M` is a zero type and `α` has decidable equality, given any element `a` of type `α` and a function `f` from `α` to `M` with finite support, the support of the function obtained by erasing `a` from `f` is the same as the set obtained by erasing `a` from the support of `f`. In simpler terms, it asserts that erasing an element from a function with finite support only affects the values at that specific element, but the rest of the support remains the same.

For any type `α` with decidable equality and any function `f` from `α` to a zero type with finite support, the support of `f` with an element `a` erased is equal to the support of `f` without `a` erased.


theorem Filter.map₂_bot_left :
    ∀ {α : Type u_1} {β : Type u_3} {γ : Type u_5} {m : α → β → γ} {g : Filter β}, Filter.map₂ m ⊥ g = ⊥ := by sorry

The theorem `Filter.map₂_bot_left` states that for any types `α`, `β`, and `γ`, and any binary function `m : α → β → γ` and filter `g : Filter β`, mapping `m` over the least (bottom) filter and `g` results in the least filter. In other words, the image of the least filter and any other filter under a binary function is always the least filter.

Given any types α, β, and γ, binary function m : α → β → γ, and filter g on β, the application of the function m to the least filter on α and filter g results in the least filter on the image of g under m.


theorem RelIso.apply_symm_apply :
    ∀ {α : Type u_1} {β : Type u_2} {r : α → α → Prop} {s : β → β → Prop} (e : r ≃r s) (x : β),
      e ((RelIso.symm e) x) = x :=
  by sorry

This theorem states that for any types `α` and `β`, any relations `r` on `α` and `s` on `β`, and any relation isomorphism `e` from `r` to `s`, if we apply the inverse of `e` to an element `x` of `β`, then apply `e` to the result, we get back `x`. This essentially asserts that the `RelIso.symm` function is the true inverse of a relation isomorphism, in compliance with the property of an inverse function.

For any relation isomorphisms `e : r ≃ s` between relations `r` on type `α` and `s` on type `β`, `e (e⁻¹ x) = x` for all `x : β`.


theorem one_le_pow_of_one_le' :
    ∀ {M : Type u_3} [inst : Monoid M] [inst_1 : Preorder M]
      [inst_2 : CovariantClass M M (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1] {a : M}, 1 ≤ a → ∀ (n : ℕ), 1 ≤ a ^ n :=
  by sorry

This theorem states that for any type `M` that is a monoid and has a preorder, and where the multiplication operation is covariant in the sense that if `x ≤ y` then `x * z ≤ y * z` for all `z`, if `1 ≤ a` for some `a` of type `M`, then `1 ≤ a^n` for all natural numbers `n`. In other words, if a value `a` is greater than or equal to one in a preordered monoid, then its power `n` is also greater than or equal to one for any natural number `n`.

In a preordered monoid where multiplication is covariant, if one element has a preorder relation greater than or equal to one, then every power of that element is also greater than or equal to one.


ZFSet.ext

theorem ZFSet.ext : ∀ {x y : ZFSet}, (∀ (z : ZFSet), z ∈ x ↔ z ∈ y) → x = y := by sorry

This theorem, `ZFSet.ext`, states that for any two ZFSet types `x` and `y`, if for every ZFSet type `z`, `z` is an element of `x` if and only if `z` is an element of `y`, then `x` and `y` are equal. In other words, this is an extensionality theorem for the ZFSet type, asserting that two sets are identical if they have the same members. This concept is a fundamental axiom in many formulations of set theory.

Two ZFSets `x` and `y` are equal if they have the same elements.


theorem Complex.normSq_apply : ∀ (z : ℂ), Complex.normSq z = z.re * z.re + z.im * z.im := by sorry

This theorem, `Complex.normSq_apply`, states that for all complex numbers `z`, the application of the function `Complex.normSq` to `z` is equal to the sum of the square of the real part of `z` and the square of the imaginary part of `z`. In mathematical terms, for any complex number `z`, `Complex.normSq z = Re(z)^2 + Im(z)^2`, where `Re(z)` and `Im(z)` denote the real and imaginary parts of `z`, respectively.

The theorem asserts that for any complex number `z`, the square of its norm equals the sum of the squares of its real and imaginary parts: `Complex.normSq z = Re(z)² + Im(z)²`.


theorem continuousAt_iff_continuous_left_right :
    ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : LinearOrder α] [inst_2 : TopologicalSpace β]
      {a : α} {f : α → β}, ContinuousAt f a ↔ ContinuousWithinAt f (Set.Iic a) a ∧ ContinuousWithinAt f (Set.Ici a) a :=
  by sorry

The theorem `continuousAt_iff_continuous_left_right` states that, for all types `α` and `β` such that `α` has a topology and a linear order, and `β` has a topology, and for all `a` in `α` and function `f` from `α` to `β`, the function `f` is continuous at point `a` if and only if `f` is continuous at `a` within the left-infinite right-closed interval at `a` (i.e., all `x` such that `x ≤ a`) and `f` is continuous at `a` within the left-closed right-infinite interval at `a` (i.e., all `x` such that `a ≤ x`).

A function between ordered topological spaces is continuous at a point if and only if it is continuous on the left-closed, right-infinite intervals at that point.


theorem Set.image2_iUnion₂_right :
    ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {ι : Sort u_4} {κ : ι → Sort u_7} (f : α → β → γ) (s : Set α)
      (t : (i : ι) → κ i → Set β), Set.image2 f s (⋃ i, ⋃ j, t i j) = ⋃ i, ⋃ j, Set.image2 f s (t i j) :=
  by sorry

This theorem states that for any types `α`, `β`, and `γ`, and any function `f` from `α` and `β` to `γ`, and any set `s` of type `α`, and a double indexed family of sets `t` of type `β`, the image under `f` of `s` and the union over both indices of `t` is equal to the union over both indices of the image under `f` of `s` and `t`. In other words, applying a function to the elements of a set and a union of sets gives the same result as taking the union of applying the function to the elements of the set and each individual set. This theorem can be described in mathematical notation as: `f(s, ⋃(i,j), t(i,j)) = ⋃(i,j), f(s, t(i,j))`.

For any functions `f` from types `α` and `β` to `γ`, sets `s` of type `α`, and double indexed families of sets `t` of type `β`, `f(s ∪ ⋃i,j t(i,j)) = ∪i,j (f(s) ∪ t(i,j))`.


theorem comm_topologicalAddGroup_is_uniform :
    ∀ {G : Type u_1} [inst : AddCommGroup G] [inst_1 : TopologicalSpace G] [inst_2 : TopologicalAddGroup G],
      UniformAddGroup G :=
  by sorry

This theorem states that for any type `G` which is an additive commutative group and has a topological space structure and a topological additive group structure, `G` also has the structure of a uniform additive group. In more mathematical terms, if we have a topological group `G` that is also an Abelian (or commutative) group, then `G` is a uniform additive group. This brings uniform structure to `G`, allowing us to discuss concepts like completeness and uniform continuity in the context of `G`.

If `G` is a topological group that is also an Abelian group, then `G` is a uniform additive group.


theorem Polynomial.natDegree_add_C :
    ∀ {R : Type u} [inst : Semiring R] {p : Polynomial R} {a : R},
      Polynomial.natDegree (p + Polynomial.C a) = Polynomial.natDegree p :=
  by sorry

This theorem states that for any semiring `R`, any polynomial `p` over `R`, and any element `a` from `R`, the natural degree of the sum of the polynomial `p` and the constant polynomial `a` is equal to the natural degree of the polynomial `p`. In other words, adding a constant to a polynomial does not change its natural degree.

The natural degree of a polynomial `p` over a semiring `R` plus a constant polynomial `a` over `R` equals the natural degree of `p`.


theorem Mathlib.Order.Filter.Basic._auxLemma.179 : ∀ {α : Type u} {a b : α}, (a ∈ {b}) = (a = b) := by sorry

This theorem, `Mathlib.Order.Filter.Basic._auxLemma.179`, states that for any type α, and any two instances a and b of this type, a is an element of the singleton set {b} if and only if a is equal to b. In other words, given any type and instances a and b of that type, a being in the set {b} is equivalent to a being equal to b.

For any type α and instances a, b of α, a is in the singleton set {b} if and only if a is equal to b.


theorem Finset.inf_eq_iInf :
    ∀ {α : Type u_2} {β : Type u_3} [inst : CompleteLattice β] (s : Finset α) (f : α → β),
      Finset.inf s f = ⨅ a ∈ s, f a :=
  by sorry

The theorem `Finset.inf_eq_iInf` states that for any types `α` and `β` where `β` is a complete lattice, any finite set `s` of type `α`, and any function `f` from `α` to `β`, the infimum of the set `s` under the function `f` is equal to the infimum over all elements `a` in the set `s` of `f(a)`. In other words, `Finset.inf s f` is the same as computing the infimum of `f(a)` for all `a` in `s`.

For any complete lattice β, the infimum of a function f from a finite set s to β, over all elements in s, is equal to the infimum of the images of the elements in s under f.


theorem Mathlib.Order.Filter.Basic._auxLemma.132 : ∀ {α : Type u} {a : α} {s : Set α}, (s ∈ pure a) = (a ∈ s) := by
  sorry

This theorem states that for any type `α`, any element `a` of type `α`, and any set `s` of elements of type `α`, the property that set `s` belongs to the filter generated by `a` (represented as `pure a`) is equivalent to the property that `a` belongs to the set `s`. In the context of filters in order theory, `pure a` represents the principal filter generated by `a`, which consists of all sets that contain `a`. Therefore, the theorem is establishing a fundamental property of principal filters.

For any type `α`, element `a` of type `α`, and set `s` of elements of type `α`, the set `s` belongs to the filter generated by `a` if and only if `a` is an element of `s`.


theorem Commute.pow_right : ∀ {M : Type u_2} [inst : Monoid M] {a b : M}, Commute a b → ∀ (n : ℕ), Commute a (b ^ n) :=
  by sorry

This theorem states that for any type `M` that forms a monoid, if two elements `a` and `b` of `M` commute, then `a` also commutes with any natural number power of `b`. In mathematical terms, if `a * b = b * a` (i.e., `a` and `b` commute), then for any natural number `n`, `a * b^n = b^n * a`.

If `a` and `b` are commuting elements of a monoid `M`, then `a` commutes with any natural power of `b`, i.e., `a * b^n = b^n * a` for all natural numbers `n`.


theorem ContinuousLinearEquiv.symm_apply_apply :
    ∀ {R₁ : Type u_1} {R₂ : Type u_2} [inst : Semiring R₁] [inst_1 : Semiring R₂] {σ₁₂ : R₁ →+* R₂} {σ₂₁ : R₂ →+* R₁}
      [inst_2 : RingHomInvPair σ₁₂ σ₂₁] [inst_3 : RingHomInvPair σ₂₁ σ₁₂] {M₁ : Type u_4} [inst_4 : TopologicalSpace M₁]
      [inst_5 : AddCommMonoid M₁] {M₂ : Type u_6} [inst_6 : TopologicalSpace M₂] [inst_7 : AddCommMonoid M₂]
      [inst_8 : Module R₁ M₁] [inst_9 : Module R₂ M₂] (e : M₁ ≃SL[σ₁₂] M₂) (b : M₁),
      (ContinuousLinearEquiv.symm e) (e b) = b :=
  by sorry

This is a theorem about continuous linear equivalences between two topological modules over semirings. Specifically, it states that for any semirings R₁ and R₂ with ring homomorphisms σ₁₂ from R₁ to R₂ and σ₂₁ from R₂ to R₁, and any two topological modules M₁ and M₂ over R₁ and R₂ respectively, if we have a continuous linear equivalence 'e' from M₁ to M₂, applying 'e' to an element 'b' in M₁ and then applying the inverse of 'e' gives us back the original element 'b'. This asserts that the continuous linear equivalence and its inverse are indeed inverses of each other in the category of topological modules.

Given semirings R₁ and R₂ with ring homomorphisms σ₁₂ and σ₂₁, and topological modules M₁ over R₁ and M₂ over R₂ with a continuous linear equivalence e : M₁ ≈ M₂, e ∘ e⁻¹ = id on M₁ and e⁻¹ ∘ e = id on M₂.


/-- Two morphisms out of a pushout are equal if their compositions with the pushout morphisms are
equal  -/
theorem CategoryTheory.Limits.pushout.hom_ext :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z : C} {f : X ⟶ Y} {g : X ⟶ Z}
      [inst_1 : CategoryTheory.Limits.HasPushout f g] {W : C} {k l : CategoryTheory.Limits.pushout f g ⟶ W},
      CategoryTheory.CategoryStruct.comp CategoryTheory.Limits.pushout.inl k =
          CategoryTheory.CategoryStruct.comp CategoryTheory.Limits.pushout.inl l →
        CategoryTheory.CategoryStruct.comp CategoryTheory.Limits.pushout.inr k =
            CategoryTheory.CategoryStruct.comp CategoryTheory.Limits.pushout.inr l →
          k = l :=
  by sorry

This theorem, named `CategoryTheory.Limits.pushout.hom_ext`, states that in category theory, given a category `C` and objects `X`, `Y`, `Z`, `W` in `C`, and morphisms `f : X ⟶ Y`, `g : X ⟶ Z` that have a pushout, if there are two morphisms `k, l : pushout f g ⟶ W` such that the compositions of `k` and `l` with the first and second inclusion morphisms into the pushout are equal (i.e., `pushout.inl ≫ k = pushout.inl ≫ l` and `pushout.inr ≫ k = pushout.inr ≫ l`), then `k` and `l` must be the same morphism. This theorem is a form of the universal property of pushouts: a morphism from the pushout is determined uniquely by its compositions with the pushout morphisms.

In a category, if two morphisms from the pushout of `X` into `W` of morphisms `f : X ⟶ Y` and `g : X ⟶ Z` have equal compositions with both inclusion morphisms into the pushout, then they are equal.


PFun.ext

theorem PFun.ext : ∀ {α : Type u_1} {β : Type u_2} {f g : α →. β}, (∀ (a : α) (b : β), b ∈ f a ↔ b ∈ g a) → f = g := by
  sorry

This theorem, `PFun.ext`, states that for any two partial functions `f` and `g` from a type `α` to a type `β`, if for all elements `a` from `α` and `b` from `β`, `b` is in the domain of `f a` if and only if `b` is in the domain of `g a`, then `f` and `g` are equal. In other words, two partial functions are equal if they have the same domain and produce the same results for every input in that domain.

If two partial functions from type `α` to type `β` have the same domains and agree on their outputs for all elements in their common domain, then they are equal.


theorem Ordinal.opow_add : ∀ (a b c : Ordinal.{u_1}), a ^ (b + c) = a ^ b * a ^ c := by sorry

The theorem `Ordinal.opow_add` states that for any three well-ordered sets `a`, `b`, and `c` in a given type, the ordinal exponentiation of `a` to the power of the ordinal sum of `b` and `c` is equal to the product of the ordinal exponentiation of `a` to the power of `b` and the ordinal exponentiation of `a` to the power of `c`. This theorem essentially illustrates the law of exponents for ordinal numbers, similar to that in regular arithmetic: $a^{(b + c)} = a^b * a^c$.

For any well-ordered sets $a$, $b$, and $c$, $a^{b + c} = a^b \times a^c$ (ordinal exponentiation).


theorem zpow_add_one : ∀ {G : Type w} [inst : Group G] (a : G) (n : ℤ), a ^ (n + 1) = a ^ n * a := by sorry

This theorem states that for any group `G`, any element `a` of `G`, and any integer `n`, raising `a` to the power of `n + 1` is the same as multiplying `a` raised to the power `n` by `a`. This is a generalization of the familiar power rule from elementary arithmetic, but applied to groups and integer exponents.

For any group `G`, any of its element `a`, and any integer `n`, the power `a^(n+1)` equals the product `a^n * a`.


theorem Mathlib.Algebra.GroupWithZero.Units.Basic._auxLemma.4 :
    ∀ {M₀ : Type u_2} [inst : MonoidWithZero M₀], IsUnit 0 = (0 = 1) := by sorry

This theorem states that for any type `M₀` with a structure of `MonoidWithZero` (a monoid that also has a zero element), the zero element of `M₀` is a unit (i.e., has a two-sided inverse) if and only if zero equals one in `M₀`. This is a characterization of units in monoids with zero, in particular, it shows the unusual situation where the zero element could potentially be a unit, which can only occur in a degenerate case where the monoid's unit element is also its zero element.

In a monoid with zero, the zero element is its own two-sided inverse if and only if zero equals one.


UniformContinuous.add

theorem UniformContinuous.add :
    ∀ {α : Type u_1} {β : Type u_2} [inst : UniformSpace α] [inst_1 : AddGroup α] [inst_2 : UniformAddGroup α]
      [inst_3 : UniformSpace β] {f g : β → α},
      UniformContinuous f → UniformContinuous g → UniformContinuous fun x => f x + g x :=
  by sorry

The theorem `UniformContinuous.add` states that for any two functions `f` and `g` mapping from a type `β` to a type `α`, if both `f` and `g` are uniformly continuous and `α` is an add group equipped with a uniform add group structure, then the function that sends each element `x` of `β` to `f x + g x` in `α` is also uniformly continuous. In other words, the theorem asserts that the sum of two uniformly continuous functions is also uniformly continuous when the codomain is a uniform add group.

The sum of two uniformly continuous functions from type `β` to an add group `α` is uniformly continuous.


theorem SimpleGraph.Walk.reverse_cons :
    ∀ {V : Type u} {G : SimpleGraph V} {u v w : V} (h : G.Adj u v) (p : SimpleGraph.Walk G v w),
      SimpleGraph.Walk.reverse (SimpleGraph.Walk.cons h p) =
        SimpleGraph.Walk.append (SimpleGraph.Walk.reverse p) (SimpleGraph.Walk.cons ⋯ SimpleGraph.Walk.nil) :=
  by sorry

This theorem, `SimpleGraph.Walk.reverse_cons`, states that for any simple graph `G` with vertices of type `V` and any three vertices `u`, `v`, and `w` in that graph such that `u` is adjacent to `v`, and there's a walk `p` from `v` to `w`, the reverse of the walk that starts at `u`, goes to `v` and then follows the walk `p` to `w`, is equal to the walk which first does the reverse of `p` and then goes from `v` to `u`. In other words, reversing a walk that begins with an edge preserves the structure of the walk, but with the direction of each edge and the order of the edges reversed.

For any simple graph `G` and vertices `u`, `v`, `w` in `G` such that `u` is adjacent to `v` and there exists a walk `p` from `v` to `w`, the reverse walk from `u` to `v` followed by `p` is equal to the reverse of `p` followed by the walk from `v` to `u`.


theorem BoxIntegral.Box.lower_le_upper : ∀ {ι : Type u_1} (I : BoxIntegral.Box ι), I.lower ≤ I.upper := by sorry

This theorem states that, for any given box `I` of an arbitrary type `ι` in the context of integral calculus, the lower bound of the box is always less than or equal to the upper bound of the box. The theorem follows the fundamental principle that the lower limits are always smaller or equal to the upper limits in mathematical intervals or boxes.

For any box I of type ι in integral calculus, the lower bound of I is less than or equal to the upper bound.


theorem List.length_set :
    ∀ {α : Type u} (as : List α) (i : ℕ) (a : α), List.length (List.set as i a) = List.length as := by sorry

The theorem `List.length_set` states that for all types `α`, any list `as` of type `α`, any natural number `i`, and any element `a` of type `α`, the length of the list resulting from setting the `i`-th element of `as` to `a` is equal to the length of the original list `as`. In simpler terms, updating an element at a specific index in a list doesn't change the length of the list.

For all types `α`, lists `as` of length `n` over `α`, natural numbers `i`, and elements `a` of `α`, updating the `i`-th element of `as` to `a` results in a list of length `n`.


theorem iSup_exists :
    ∀ {α : Type u_1} {ι : Sort u_5} [inst : CompleteLattice α] {p : ι → Prop} {f : Exists p → α},
      ⨆ (x : Exists p), f x = ⨆ i, ⨆ (h : p i), f ⋯ :=
  by sorry

This theorem, `iSup_exists`, states that for any type `α` that forms a complete lattice, and for any predicate `p` over some index type `ι`, there is an equivalence between the supremum over all elements satisfying the predicate `p` and the corresponding function `f` applied on their existence proofs, and the supremum over all indices `i` with the second supremum over all elements satisfying the predicate `p(i)`. It effectively shows that the supremum operation is invariant under the proof of existence.

For any complete lattice `α` and predicate `p` over an index type `ι`, the function `f` that maps an element `x` to its existence proof returns the supremum of elements satisfying `p` if and only if it is the supremum of the second supremum of elements `i` with `p(i)`.


theorem cast_heq : ∀ {α β : Sort u} (h : α = β) (a : α), HEq (cast h a) a := by sorry

This theorem, `cast_heq`, asserts that for any two sorts `α` and `β` in Lean 4 (which can be thought of as types), if `α` is equal to `β` and `a` is an instance of `α`, then `a` cast to `β` (using the equality `h` as justification for the cast) is heterogeneously equal to `a`. In other words, not only is `a` equal to itself after the cast, but the cast version of `a` and the original `a` are considered to be the same kind of object. Here, "HEq" stands for heterogeneous equality, a notion of equality that allows for comparison of values of different types.

For any types `α` and `β` in Lean 4, and for any `a` of type `α`, if `α` is equal to `β` and `a` has an instance of type `α`, then `a` and its cast to type `β` are heterogeneously equal.


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

The theorem `inner_self_eq_norm_mul_norm` states that for any type `𝕜` that is a ring complete (as defined by `RCLike 𝕜`), and any type `E` that is a normed add commutative group and an inner product space over `𝕜`, the real component of the inner product of a vector `x` with itself (denoted by `⟪x, x⟫_𝕜`) is equal to the square of the norm of the vector `x` (denoted by `‖x‖ * ‖x‖`). This is a fundamental property in inner product spaces representing the Pythagorean theorem in any such space.

For any ring complete `𝕜`, normed add commutative group and inner product space `E` over `𝕜`, the inner product `⟪x, x⟫_𝕜` of a vector `x` with itself equals the square of its norm `‖x‖ * ‖x‖`.


theorem Nat.even_iff : ∀ {n : ℕ}, Even n ↔ n % 2 = 0 := by sorry

This theorem states that for any natural number `n`, `n` is even if and only if the remainder when `n` is divided by 2 equals 0. In other words, this theorem provides a condition to check the evenness of a number in terms of a modular arithmetic operation. Specifically, a natural number `n` satisfies `Even n` (meaning there exists a natural number `r` such that `n = r + r`) if and only if `n` modulo 2 equals zero.

A natural number `n` is even if and only if `n` modulo 2 equals 0.


Antivary.antivaryOn

theorem Antivary.antivaryOn :
    ∀ {ι : Type u_1} {α : Type u_3} {β : Type u_4} [inst : Preorder α] [inst_1 : Preorder β] {f : ι → α} {g : ι → β},
      Antivary f g → ∀ (s : Set ι), AntivaryOn f g s :=
  by sorry

The theorem `Antivary.antivaryOn` states that for any types `ι`, `α`, and `β` with preorders on `α` and `β`, and for any functions `f: ι → α` and `g: ι → β`, if `f` antivaries with `g`, then for any set `s` of type `ι`, `f` also antivaries with `g` on the set `s`. In other words, if the function `g` increases between any two elements, then the function `f` decreases (or stays the same) between those elements, not only over the whole domain but also when restricted to any subset of the domain.

If functions `f: ι → α` and `g: ι → β` have the property that `f(x) ≤ f(y)` whenever `g(x) < g(y)` for all `x, y ∈ ι`, then `f` antivaries with `g` on any subset of `ι`.


theorem Function.Surjective.forall₃ :
    ∀ {α : Sort u_1} {β : Sort u_2} {f : α → β},
      Function.Surjective f →
        ∀ {p : β → β → β → Prop}, (∀ (y₁ y₂ y₃ : β), p y₁ y₂ y₃) ↔ ∀ (x₁ x₂ x₃ : α), p (f x₁) (f x₂) (f x₃) :=
  by sorry

The theorem `Function.Surjective.forall₃` states that for any type `α` and `β` and any function `f` from `α` to `β`, if `f` is surjective, then for any predicate `p` that takes three arguments of type `β`, the predicate `p` holds for any three elements of type `β` if and only if `p` holds for the images of any three elements of type `α` under the function `f`. In other words, we can replace any three elements of type `β` in the predicate `p` by their preimages in type `α` under the function `f`, without changing the truth value of `p`, provided `f` is surjective.

If `f: α → β` is a surjective function, then for any predicate `p:` `β → Prop`, `p` holds for any three elements of `β` if and only if `p` holds for the images of any three elements of `α` under `f`.


theorem Set.union_diff_cancel : ∀ {α : Type u} {s t : Set α}, s ⊆ t → s ∪ t \ s = t := by sorry

The theorem `Set.union_diff_cancel` states that for any type `α` and any two sets `s` and `t` of type `α`, if `s` is a subset of `t`, then the union of `s` and the difference of `t` and `s` equals `t`. In other words, if all elements of `s` are also in `t`, then adding `s` to `t` (which already includes `s`) and then removing `s` from the result leaves us with the original set `t`. This is a fundamental property of set operations in mathematics.

For any set `α` and sets `s` and `t` such that `s` is a subset of `t`, we have `s ⊆ t` implies `(s ∪ (t \ s)) = t`.


theorem CategoryTheory.Preadditive.zsmul_comp :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C] {P Q R : C}
      (f : P ⟶ Q) (g : Q ⟶ R) (n : ℤ),
      CategoryTheory.CategoryStruct.comp (n • f) g = n • CategoryTheory.CategoryStruct.comp f g :=
  by sorry

The theorem `CategoryTheory.Preadditive.zsmul_comp` states that for any three objects `P`, `Q`, and `R` in a preadditive category `C`, and for any two morphisms `f` from `P` to `Q` and `g` from `Q` to `R`, and for any integer `n`, the composition of `n` times the morphism `f` with the morphism `g` is equal to `n` times the composition of the morphisms `f` and `g`. In mathematical terms, it states that `(n • f) ≫ g = n • (f ≫ g)`, where `≫` represents composition of morphisms, and `•` represents scaling by an integer.

For any integer `n` and morphisms `f` and `g` in a preadditive category, `n * (f ∘ g) = (n * f) ∘ g`.


/-- The image under an `AddMonoid` hom of the `AddSubmonoid` generated by a set equals
the `AddSubmonoid` generated by the image of the set. -/
theorem AddMonoidHom.map_mclosure :
    ∀ {M : Type u_1} {N : Type u_2} [inst : AddZeroClass M] [inst_1 : AddZeroClass N] {F : Type u_5}
      [inst_2 : FunLike F M N] [mc : AddMonoidHomClass F M N] (f : F) (s : Set M),
      AddSubmonoid.map f (AddSubmonoid.closure s) = AddSubmonoid.closure (⇑f '' s) :=
  by sorry

This theorem states that for any set `s` in an additive monoid `M`, and any homomorphism `f` from `M` to another additive monoid `N`, the additive submonoid generated by the image of `s` under `f` (denoted by `⇑f '' s`) is the same as the image under `f` of the additive submonoid generated by `s`. In other words, mapping a set to another monoid and then taking the generated submonoid yields the same result as first taking the generated submonoid and then mapping it to the other monoid. This means the operations of "taking the generated submonoid" and "mapping with `f`" commute with each other.

For any set `s` in an additive monoid `M` and any homomorphism `f` from `M` to an additive monoid `N`, the image of the additive submonoid generated by `s` under `f` equals the additive submonoid generated by the image of `s` under `f`.


theorem Set.image2_iUnion₂_left :
    ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {ι : Sort u_4} {κ : ι → Sort u_7} (f : α → β → γ)
      (s : (i : ι) → κ i → Set α) (t : Set β), Set.image2 f (⋃ i, ⋃ j, s i j) t = ⋃ i, ⋃ j, Set.image2 f (s i j) t :=
  by sorry

This theorem states that for any types `α`, `β`, and `γ`, an index type `ι`, and a function `κ` mapping each index to a sort, and given a binary function `f : α → β → γ`, a family of sets `s : (i : ι) → κ i → Set α`, and a set `t : Set β`, the image under `f` of the union over `i` and `j` of the sets `s i j` and `t` is equal to the union, over `i` and `j`, of the image under `f` of `s i j` and `t`. In mathematical terms, this encapsulates the property that the image of a union of sets under a function is the union of the images of those sets, for a family of sets indexed by two indices.

For any types `α`, `β`, `γ`, index type `ι`, function `κ : ι -> Sort γ`, binary function `f : α -> β -> γ`, sets `s : ι -> κ i -> Set α`, and set `t : Set β`, we have `unions (map (λ i, map (λ j, f <$> s i <$> j) <*> t) = unions (map (λ i, map (λ j, f <$> s i j) <$> [i, j]))`.


theorem Basis.addHaar_def :
    ∀ {ι : Type u_5} {E : Type u_6} [inst : Fintype ι] [inst_1 : NormedAddCommGroup E] [inst_2 : NormedSpace ℝ E]
      [inst_3 : MeasurableSpace E] [inst_4 : BorelSpace E] (b : Basis ι ℝ E),
      Basis.addHaar b = MeasureTheory.Measure.addHaarMeasure (Basis.parallelepiped b) :=
  by sorry

This theorem states that for any basis `b` of a real normed vector space `E` of finite type `ι`, the Lebesgue measure associated to this basis (`Basis.addHaar b`), which gives measure `1` to the parallelepiped spanned by the basis, is equal to the Haar measure of the parallelepiped spanned by the basis (`MeasureTheory.Measure.addHaarMeasure (Basis.parallelepiped b)`).

For any finite basis `b` of a real normed vector space `E`, the Lebesgue measure and Haar measure of the parallelepiped spanned by `b` are equal.


theorem smul_iterate :
    ∀ {G : Type u_3} {H : Type u_4} [inst : Monoid G] (a : G) (n : ℕ) [inst_1 : MulAction G H],
      (fun x => a • x)^[n] = fun x => a ^ n • x :=
  by sorry

This theorem, `smul_iterate`, states that for any type `G` with a monoid structure, a value `a` of type `G`, a natural number `n`, and any type `H` with a multiplication action defined by `G`, the `n`-th iterate of the function that scales by `a` is equivalent to the function that scales by `a` raised to the power of `n`. In other words, applying the scaling function `n` times in a row has the same effect as scaling once by `a^n`.

For any monoid `G` and element `a` in `G`, any type `H` with a right action by `G`, and natural number `n`, the repeated application of the function that scales elements in `H` by `a` is equivalent to scaling them by `a` raised to the power of `n`.


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

This is a theorem about the multiplication operation in a non-unital, non-associative semiring. Specifically, it states that for any type `R` that forms a non-unital non-associative semiring, and any two additive submonoids `M` and `N` of `R`, if a number `m` is in `M` and a number `n` is in `N`, then the product `m * n` is in the set created by multiplying elements from `M` and `N`. In other words, the product of elements from the submonoids is also an element of the product of the submonoids.

For any non-unital, non-associative semiring `R`, and additive submonoids `M` and `N` of `R`, the product of any element from `M` with any element from `N` is an element of the submonoid generated by the products of elements from `M` and `N`.


theorem UniformSpace.Completion.coe_mul :
    ∀ {α : Type u_1} [inst : Ring α] [inst_1 : UniformSpace α] [inst_2 : TopologicalRing α] (a b : α),
      ↑α (a * b) = ↑α a * ↑α b :=
  by sorry

This theorem states that for any type `α` that is a Ring and a Topological Ring with a Uniform Space structure, the completion operation respects multiplication. In other words, for any two elements `a` and `b` of `α`, the completion of the product `a * b` is the same as the product of the completions of `a` and `b`. This theorem formalizes one of the essential properties of complete metric spaces that are also rings.

For any commutative ring `α` with a uniform space structure, the completion operation is multiplicative, i.e., `∫(a * b) dμ = ∫(a) dμ * ∫(b) dμ` for any `a, b` in `α`, where `∫` denotes the completion and `μ` is the compatible measure on the uniform space.


theorem Metric.cobounded_eq_cocompact :
    ∀ {α : Type u} [inst : PseudoMetricSpace α] [inst_1 : ProperSpace α], Bornology.cobounded α = Filter.cocompact α :=
  by sorry

This theorem establishes the equivalence between the filter of cobounded sets in a bornology and the filter generated by the complements to compact sets in a pseudometric space that is also a proper space. More precisely, for any pseudometric space that is a proper space, the filter of sets that are not bounded away from any point in the space (the cobounded sets in the bornology of the space) is the same as the filter generated by the complements of compact subsets of the space.

In a proper pseudometric space, the filter of cobounded sets equals the filter generated by the complements of compact sets.


theorem div_sub_div_same : ∀ {K : Type u_3} [inst : DivisionRing K] (a b c : K), a / c - b / c = (a - b) / c := by sorry

This theorem states that for any division ring `K` and for any elements `a`, `b`, and `c` in `K`, the difference between `a` divided by `c` and `b` divided by `c` is equal to the result of `a` minus `b` divided by `c`. In mathematical expression, it can be written as: $\frac{a}{c} - \frac{b}{c} = \frac{a-b}{c}$.

For any division ring K and elements a, b, and c in K, $\frac{a}{c} - \frac{b}{c} = \frac{a-b}{c}$.


theorem Real.sin_nonneg_of_nonneg_of_le_pi : ∀ {x : ℝ}, 0 ≤ x → x ≤ Real.pi → 0 ≤ Real.sin x := by sorry

This theorem states that for all real numbers `x`, if `x` is nonnegative and less than or equal to the value of pi (`π`), then the sine of `x` is nonnegative. In other words, the sine function returns a nonnegative real number when its input is a real number between 0 and `π` inclusive.

For all real numbers `x` with `0 ≤ x ≤ π`, the sine of `x` is nonnegative (i.e., `sin x ≥ 0`).


Function.Periodic.nsmul

theorem Function.Periodic.nsmul :
    ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {c : α} [inst : AddMonoid α],
      Function.Periodic f c → ∀ (n : ℕ), Function.Periodic f (n • c) :=
  by sorry

The theorem `Function.Periodic.nsmul` states that for any types `α` and `β`, any function `f` from `α` to `β`, and any element `c` of type `α` in an additive monoid, if `f` is periodic with period `c`, then `f` is also periodic with period `n•c` for any natural number `n`. Here, `n•c` denotes the result of adding `c` to itself `n` times.

If `f` is a periodic function from type `α` to type `β` with period `c`, then `f` is also periodic with period `nc` for any natural number `n`.


/-- The indexed supremum of a function is bounded above by a uniform bound -/
theorem ciSup_le :
    ∀ {α : Type u_1} {ι : Sort u_4} [inst : ConditionallyCompleteLattice α] [inst_1 : Nonempty ι] {f : ι → α} {c : α},
      (∀ (x : ι), f x ≤ c) → iSup f ≤ c :=
  by sorry

This theorem states that for any type `α` that is a conditionally complete lattice and any nonempty type `ι`, given a function `f` from `ι` to `α` and any element `c` of `α`, if all values of the function `f` are less than or equal to `c`, then the indexed supremum (or least upper bound) of the function `f`, denoted `iSup f`, is also less than or equal to `c`. In simple terms, if every output of a function is bounded by a certain value, then the supremum of these outputs cannot exceed this bound.

If `α` is a conditionally complete lattice and `f : ι → α` is a function with domain `ι` such that `∀ i, f i ≤ c`, then `iSup f ≤ c`.


FirstOrder.Language.Embedding.injective

theorem FirstOrder.Language.Embedding.injective :
    ∀ {L : FirstOrder.Language} {M : Type w} {N : Type w'} [inst : FirstOrder.Language.Structure L M]
      [inst_1 : FirstOrder.Language.Structure L N] (f : FirstOrder.Language.Embedding L M N), Function.Injective ⇑f :=
  by sorry

The theorem `FirstOrder.Language.Embedding.injective` states that for any first order language `L`, and any two types `M` and `N` that have a structure of this language, every embedding `f` from `M` to `N` in the context of language `L` is injective. In other words, if `f` is an embedding from `M` to `N`, and `f x = f y` for some elements `x` and `y` in `M`, then it must be the case that `x = y`. This means that no two distinct elements of `M` get mapped to the same element in `N` under the embedding `f`.

Given any first order language L and embeddings f from type M to type N in the context of L, if x and y are distinct elements of M then f(x) and f(y) are distinct in N.


theorem List.nodup_finRange : ∀ (n : ℕ), List.Nodup (List.finRange n) := by sorry

The theorem `List.nodup_finRange` states that for every natural number `n`, the list generated by `List.finRange n` has no duplicates. In other words, each element in the list `List.finRange n`, which comprises all elements of `Fin n` from `0` to `n-1`, appears at most once.

For any natural number `n`, the list `List.finRange n` contains no repetitions of elements from `Fin n`.


theorem finprod_congr_Prop :
    ∀ {M : Type u_2} [inst : CommMonoid M] {p q : Prop} {f : p → M} {g : q → M} (hpq : p = q),
      (∀ (h : q), f ⋯ = g h) → finprod f = finprod g :=
  by sorry

This theorem states that for any type `M` that forms a commutative monoid, given two propositions `p` and `q` and two functions `f` from `p` to `M` and `g` from `q` to `M`, if `p` is equivalent to `q`, and for every truth of `q` the value of `f` and `g` are equal, then the "finite product" (as defined by the `finprod` function) of `f` over its multiplicative support is equal to the "finite product" of `g` over its multiplicative support. In simpler terms, if we have two functions that are essentially defined on the same domain and take the same values, their products over their respective domains (calculated by the `finprod` function) are equal.

Given two functions `f` and `g` from propositions `p` and `q` to a commutative monoid `M` respectively, if `p` is equivalent to `q` and for all `q', g(q') = f(q')`, then the finite products of `f` and `g` over their multiplicative supports are equal.


theorem Filter.hasBasis_biInf_principal' :
    ∀ {α : Type u_1} {ι : Type u_6} {p : ι → Prop} {s : ι → Set α},
      (∀ (i : ι), p i → ∀ (j : ι), p j → ∃ k, p k ∧ s k ⊆ s i ∧ s k ⊆ s j) →
        (∃ i, p i) → Filter.HasBasis (⨅ i, ⨅ (_ : p i), Filter.principal (s i)) p s :=
  by sorry

This theorem states that, for any type `α` and index type `ι`, given a predicate `p : ι → Prop` and a function `s : ι → Set α` such that for every pair of indices `i` and `j` for which `p` holds, there exists an index `k` for which `p` also holds and the sets `s k` are subsets of both `s i` and `s j`, and there exists at least one index for which `p` holds, then the Filter generated by the infimum over all i of the principal filters of `s i` for which `p i` holds, has a basis characterized by the predicate `p` and the function `s`. In other words, we have a filter basis formed by sets `s i` for the indices `i` for which the predicate `p` is true.

Given a type `α`, an index type `ι`, a predicate `p : ι → Prop`, and a function `s : ι → Set α` such that for any pair `i`, `j` with `p i` and `p j` holding and `s i ⊆ s k` and `s j ⊆ s k` for some `k`, there exists an index with `p` holding having this property, and there exists at least one index with `p` holding: the filter basis of the infimum of the principal filters of `s i` for `i` with `p i` is `p` and `s`.


theorem Finset.sum_sdiff :
    ∀ {α : Type u_3} {β : Type u_4} {s₁ s₂ : Finset α} {f : α → β} [inst : AddCommMonoid β] [inst_1 : DecidableEq α],
      s₁ ⊆ s₂ → ((Finset.sum (s₂ \ s₁) fun x => f x) + Finset.sum s₁ fun x => f x) = Finset.sum s₂ fun x => f x :=
  by sorry

This theorem states that for any types `α` and `β`, any two finite sets `s₁` and `s₂` of type `α`, and any function `f` from `α` to `β`, given that `β` forms an additive commutative monoid and that equality in `α` is decidable, if `s₁` is a subset of `s₂`, then the sum of `f(x)` over all elements `x` in the set difference `s₂ \ s₁` plus the sum of `f(x)` over all elements `x` in `s₁` equals the sum of `f(x)` over all elements `x` in `s₂`. In other words, splitting the sum over `s₂` into a sum over `s₁` and a sum over `s₂ \ s₁` preserves the total sum.

For any additive commutative monoid β, decidably equated type α, and function f : α → β, if s₁ ∋ s₂ and s₂ = s₁ ∪ (s₂ \ s₁), then ∑x ∈ s₂ (f x) = ∑x ∈ s₁ (f x) + ∑x ∈ s₂ \ s₁ (f x).


theorem IsOfFinAddOrder.exists_nsmul_eq_zero :
    ∀ {G : Type u_1} [inst : AddMonoid G] {x : G}, IsOfFinAddOrder x → ∃ n, 0 < n ∧ n • x = 0 := by sorry

The theorem `IsOfFinAddOrder.exists_nsmul_eq_zero` states that for any element `x` of an additive monoid `G` that satisfies the property `IsOfFinAddOrder`, there exists a positive integer `n` such that `n` multiplied by `x` (denoted as `n • x` in Lean) equals zero. In other words, if an element of an additive monoid has finite order, then there exists a non-zero multiple of this element that equals the additive identity (zero).

For every additive monoid element `x` with finite order, there exists a positive integer `n` such that `n` times `x` equals the additive identity.


theorem MeasureTheory.AEEqFun.smul_toGerm :
    ∀ {α : Type u_1} {γ : Type u_3} [inst : MeasurableSpace α] {μ : MeasureTheory.Measure α}
      [inst_1 : TopologicalSpace γ] {𝕜 : Type u_5} [inst_2 : SMul 𝕜 γ] [inst_3 : ContinuousConstSMul 𝕜 γ] (c : 𝕜)
      (f : α →ₘ[μ] γ), MeasureTheory.AEEqFun.toGerm (c • f) = c • MeasureTheory.AEEqFun.toGerm f :=
  by sorry

The theorem `MeasureTheory.AEEqFun.smul_toGerm` states that for any types `α`, `γ` and `𝕜`, given a measurable space instance for `α`, a measure `μ` on `α`, a topological space instance for `γ`, an instance of scalar multiplication (`SMul`) on `𝕜` and `γ`, and an instance of continuous constant scalar multiplication (`ContinuousConstSMul`) on `𝕜` and `γ`, for any scalar `c` of type `𝕜` and any function `f` from `α` to `γ` that is almost everywhere equal with respect to the measure `μ`, the germ (i.e., equivalence class of functions equal almost everywhere) of the scalar multiplication of `c` and `f` (denoted as `c • f`) is equal to the scalar multiplication of `c` and the germ of `f`. In other words, scalar multiplication commutes with the operation of taking germs of functions that are almost everywhere equal.

For measurable functions `f: α → γ` and scalars `c` in a commutative ring `𝕜` with a measure `μ` on `α`, continuous scalar multiplication, and assuming `f` and `c • f` are equal almost everywhere, their germs are equal: `germ (c • f) = germ (c * f)`.


Nat.Primrec'.tail

theorem Nat.Primrec'.tail : ∀ {n : ℕ} {f : Vector ℕ n → ℕ}, Nat.Primrec' f → Nat.Primrec' fun v => f (Vector.tail v) :=
  by sorry

The theorem `Nat.Primrec'.tail` states that if we have a function `f`, which takes a vector of natural numbers of length `n` and returns a natural number, and this function `f` is primitive recursive (`Nat.Primrec' f`), then the function that applies `f` to the tail of its input vector (`fun v => f (Vector.tail v)`) is also primitive recursive. In other words, the theorem guarantees that getting the tail of a vector preserves the property of being primitive recursive.

If `f` is a primitive recursive function from vectors of natural numbers to natural numbers, then the function `x => f (Vector.tail x)` is also primitive recursive.


theorem Mathlib.CategoryTheory.Monoidal.Category._auxLemma.1 :
    ∀ {C : Type u} [𝒞 : CategoryTheory.Category.{v, u} C] [inst : CategoryTheory.MonoidalCategory C] (X : C) {Y₁ Y₂ : C}
      (f : Y₁ ⟶ Y₂),
      CategoryTheory.MonoidalCategory.whiskerLeft X f =
        CategoryTheory.MonoidalCategory.tensorHom (CategoryTheory.CategoryStruct.id X) f :=
  by sorry

The theorem `Mathlib.CategoryTheory.Monoidal.Category._auxLemma.1` states that for any category `C` of Type `u` which is a monoidal category, for any object `X` in `C` and any morphism `f` from object `Y₁` to object `Y₂` in `C`, the operation of whiskering on the left with `X` on `f` is equal to the tensor product of the identity morphism on `X` and `f`. This is a key property in the theory of monoidal categories, connecting the concepts of whiskering and tensor product of morphisms.

For any object X in a monoidal category C and any morphism f in C, the whiskering of X with f is equal to the tensor product of the identity morphism on X and f.


theorem Mathlib.CategoryTheory.Monoidal.Category._auxLemma.3 :
    ∀ {C : Type u} [𝒞 : CategoryTheory.Category.{v, u} C] [inst : CategoryTheory.MonoidalCategory C] {X₁ X₂ : C}
      (f : X₁ ⟶ X₂) (Y : C),
      CategoryTheory.MonoidalCategory.whiskerRight f Y =
        CategoryTheory.MonoidalCategory.tensorHom f (CategoryTheory.CategoryStruct.id Y) :=
  by sorry

The theorem, `Mathlib.CategoryTheory.Monoidal.Category._auxLemma.3`, states that for any category `C` of type `u` equipped with the structure of a monoidal category, for any two objects `X₁` and `X₂` in `C` and any morphism `f` from `X₁` to `X₂`, and for any object `Y` in `C`, the operation of whiskering on the right by `f` on `Y` is equal to the tensor product of `f` and the identity morphism on `Y`. In other words, for all `f` and `Y`, we have: `CategoryTheory.MonoidalCategory.whiskerRight f Y = CategoryTheory.MonoidalCategory.tensorHom f (CategoryTheory.CategoryStruct.id Y)`. In simpler terms, this theorem is asserting a specific property about how morphisms interact with the tensor product and identity morphism in a monoidal category.

In a monoidal category, whiskering a morphism on the right by another morphism is equivalent to the tensor product of the two morphisms.


Asymptotics.IsBigO.add

theorem Asymptotics.IsBigO.add :
    ∀ {α : Type u_1} {F : Type u_4} {E' : Type u_6} [inst : Norm F] [inst_1 : SeminormedAddCommGroup E'] {g : α → F}
      {l : Filter α} {f₁ f₂ : α → E'}, f₁ =O[l] g → f₂ =O[l] g → (fun x => f₁ x + f₂ x) =O[l] g :=
  by sorry

This theorem, `Asymptotics.IsBigO.add`, states that for any given alpha type `α`, filter type `F`, and seminormed add commutative group `E'`, along with any given function `g : α → F` and filter `l`, if the functions `f₁ : α → E'` and `f₂ : α → E'` are both Big O of `g` with respect to `l` (expressed as `f₁ =O[l] g` and `f₂ =O[l] g`), then the function that maps `x` to `f₁ x + f₂ x` is also Big O of `g` with respect to `l`. In other words, the sum of two functions, each of which is Big O of a certain function, is itself Big O of the same function.

If `f₁` and `f₂` are both Big O of `g` with respect to filter `l`, then `f₁ + f₂` is also Big O of `g` with respect to `l`.


theorem Nat.dvd_mul_left : ∀ (a b : ℕ), a ∣ b * a := by sorry

This theorem states that for any two natural numbers `a` and `b`, `a` is a divisor of the product of `b` and `a`. In the context of number theory, if we multiply `a` with any natural number `b`, `a` will always divide the resulting product.

For all natural numbers a and b, a divides the product b * a.


theorem CategoryTheory.ShortComplex.LeftHomologyMapData.cyclesMap'_eq :
    ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
      {S₁ S₂ : CategoryTheory.ShortComplex C} {φ : S₁ ⟶ S₂} {h₁ : CategoryTheory.ShortComplex.LeftHomologyData S₁}
      {h₂ : CategoryTheory.ShortComplex.LeftHomologyData S₂}
      (γ : CategoryTheory.ShortComplex.LeftHomologyMapData φ h₁ h₂),
      CategoryTheory.ShortComplex.cyclesMap' φ h₁ h₂ = γ.φK :=
  by sorry

This theorem states that for any category `C` with zero morphisms, given two short complexes `S₁` and `S₂` in `C`, a morphism `φ` from `S₁` to `S₂`, and left homology data `h₁` and `h₂` for `S₁` and `S₂` respectively, for any left homology map data `γ` defined by `φ`, `h₁`, and `h₂`, the `cyclesMap'` of `φ`, `h₁`, and `h₂` in the short complex category is equal to the `φK` component of `γ`.

In simpler terms, it is about a particular association between the morphism of two short complexes and the left homology map data, where the cycles map of the morphism and the left homology data is the same as a certain component of the left homology map data.

For any category with zero morphisms `C`, given short complexes `S₁` and `S₂`, a morphism `φ` from `S₁` to `S₂`, and left homology data `h₁` and `h₂` for `S₁` and `S₂` respectively, the cycles map of `φ` with respect to `h₁` and `h₂` is equal to the `φK` component of the induced left homology map `γ` between `h₁` and `h₂`.


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

The theorem `AlgEquiv.symm_symm` states that for any types `R`, `A₁`, and `A₂` where `R` is a commutative semiring, `A₁` and `A₂` are semirings, and `A₁` and `A₂` are algebras over `R`, for any algebra equivalence `e` from `A₁` to `A₂`, the algebra equivalence that is the result of applying the function `AlgEquiv.symm` twice to `e` is equal to `e` itself. In simpler terms, taking the 'symmetric' or 'inverse' of an algebra equivalence twice gives you back the original equivalence.

For any commutative semiring `R` and algebra equivalences `e`: (`AlgEquiv.symm `∘` `AlgEquiv.symm`) `e` = `e`, where `A₁`, `A₂` are semirings and algebras over `R`.


theorem Function.mem_mulSupport :
    ∀ {α : Type u_1} {M : Type u_5} [inst : One M] {f : α → M} {x : α}, x ∈ Function.mulSupport f ↔ f x ≠ 1 := by sorry

The theorem `Function.mem_mulSupport` states that for any types `α` and `M` (with `M` having an identity element under multiplication), a function `f` from `α` to `M`, and an element `x` of type `α`, `x` is in the `mulSupport` of `f` if and only if the value of `f` at `x` is not equal to the identity element of `M`. In other words, the `mulSupport` of a function `f` is the set of all points `x` where `f(x)` does not equal the multiplicative identity.

The theorem `Function.mem_mulSupport` asserts that an element `x` is in the domain of a multiplication function `f` from type `α` to type `M` if and only if `f x` is not the identity element of `M`.


theorem MeasureTheory.FiniteMeasure.mass_nonzero_iff :
    ∀ {Ω : Type u_1} [inst : MeasurableSpace Ω] (μ : MeasureTheory.FiniteMeasure Ω),
      MeasureTheory.FiniteMeasure.mass μ ≠ 0 ↔ μ ≠ 0 :=
  by sorry

This theorem states that for any type Ω equipped with a measurable space structure and any finite measure μ on Ω, the mass of the finite measure μ is non-zero if and only if μ is not the zero measure. In other words, a finite measure on a measurable space has a non-zero mass exactly when it is not the zero measure.

A finite measure on a measurable space is non-zero if and only if it is not the zero measure.


theorem GaloisCoinsertion.u_iInf_l :
    ∀ {α : Type u} {β : Type v} {l : α → β} {u : β → α} [inst : CompleteLattice α] [inst_1 : CompleteLattice β],
      GaloisCoinsertion l u → ∀ {ι : Sort x} (f : ι → α), u (⨅ i, l (f i)) = ⨅ i, f i :=
  by sorry

This theorem states that for any two types `α` and `β`, given a pair of functions `l : α → β` and `u : β → α`, along with the assumption that `α` and `β` form complete lattices, if `l` and `u` form a Galois coinsertion, then for any index set `ι` and any family of elements `(f : ι → α)`, the value of applying `u` to the infimum (greatest lower bound) over `ι` of `l(f i)` is the same as the infimum over `ι` of `f i`. In mathematical terms, it says that the function `u` commutes with the operation of taking infima in the context of a Galois coinsertion.

Given types `α` and `β` that form complete lattices, if functions `l : α → β` and `u : β → α` form a Galois coinsertion, then for any indexed family `(f : ι → α)`, `inf (map l (ι → α) f) = inf (list ι) (map (u ∘) (ι → α) f)`.


theorem Matrix.nonsing_inv_apply_not_isUnit :
    ∀ {n : Type u'} {α : Type v} [inst : Fintype n] [inst_1 : DecidableEq n] [inst_2 : CommRing α] (A : Matrix n n α),
      ¬IsUnit (Matrix.det A) → A⁻¹ = 0 :=
  by sorry

This theorem states that for any square matrix `A` of type `α` with indices of type `n`, if the determinant of `A` is not a unit in the commutative ring `α`, then the inverse of `A` is the zero matrix. In other words, if the determinant of the matrix is not invertible (i.e., the matrix is singular), then the matrix does not have an inverse in the usual sense, and this is represented in Lean by the inverse equalling the zero matrix. This is a fundamental result in linear algebra.

If the determinant of a square matrix over a commutative ring is not a unit, then the matrix has no multiplicative inverse and is equal to its own inverse (zero matrix).


Set.LeftInvOn.mono

theorem Set.LeftInvOn.mono :
    ∀ {α : Type u_1} {β : Type u_2} {s s₁ : Set α} {f : α → β} {f' : β → α},
      Set.LeftInvOn f' f s → s₁ ⊆ s → Set.LeftInvOn f' f s₁ :=
  by sorry

The theorem `Set.LeftInvOn.mono` states that for any types `α` and `β`, any sets `s` and `s₁` of `α`, and any functions `f : α → β` and `f' : β → α`, if `f'` is a left inverse to `f` on `s` (i.e., `f'(f(x)) = x` for all `x` in `s`), and `s₁` is a subset of `s`, then `f'` is also a left inverse to `f` on `s₁`. This means that the property of being a left inverse is preserved under taking subsets.

If `f : α → β`, `f' : β → α`, `s ⊆ α`, `f'` is a left inverse to `f` on `s`, then `f'` is a left inverse to `f` on `s₁`.


theorem Finset.monotone_filter_right :
    ∀ {α : Type u_1} (s : Finset α) ⦃p q : α → Prop⦄ [inst : DecidablePred p] [inst_1 : DecidablePred q],
      p ≤ q → Finset.filter p s ⊆ Finset.filter q s :=
  by sorry

The theorem `Finset.monotone_filter_right` states that for any finset `s` of elements of type `α`, and any two predicates `p` and `q` on `α` such that `p` is a subset of `q` (i.e., `p ≤ q`), the filtering of `s` by `p` is a subset of the filtering of `s` by `q`. This holds under the condition that both `p` and `q` are decidable predicates, meaning that for any element in `α`, it can decisively be told whether it satisfies the predicate `p` or `q`. So, if a property defined by `p` is less restrictive than a property defined by `q`, then the set of elements in `s` satisfying `p` is a subset of the set satisfying `q`.

For any finset `s` of decidable predicates `p ≤ q` on type `α`, the filtered set `s.filter p` is a subset of `s.filter q`.


theorem Multiset.card_eq_zero : ∀ {α : Type u_1} {s : Multiset α}, Multiset.card s = 0 ↔ s = 0 := by sorry

This theorem states that for any multiset `s` of any type `α`, the cardinality (or size) of the multiset `s` is equal to zero if and only if the multiset itself is the zero multiset. In other words, a multiset `s` is empty (is the zero multiset) if and only if the count of its elements is zero.

The theorem asserts that a multiset of type `α` has cardinality zero if and only if it is the empty multiset.


theorem Algebra.FiniteType.of_surjective :
    ∀ {R : Type uR} {A : Type uA} {B : Type uB} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Semiring B]
      [inst_3 : Algebra R A] [inst_4 : Algebra R B],
      Algebra.FiniteType R A → ∀ (f : A →ₐ[R] B), Function.Surjective ⇑f → Algebra.FiniteType R B :=
  by sorry

This theorem, `Algebra.FiniteType.of_surjective`, states that for all types `R`, `A` and `B` where `R` is a commutative semiring, `A` and `B` are semirings, `R` is an algebra structure on `A` and `B`, if `A` is of finite type over `R`, then for any algebra homomorphism `f` from `A` to `B` that is surjective (every element of `B` is the image under `f` of some element in `A`), we can conclude that `B` is also of finite type over `R`. In mathematical terms, it states that the surjective image of a finitely generated algebra is also a finitely generated algebra.

If `A` is a finite type algebra over a commutative semiring `R`, and `f : A → B` is a surjective algebra homomorphism from `A` to another algebra `B` over `R`, then `B` is also of finite type over `R`.


theorem Filter.map₂_pure :
    ∀ {α : Type u_1} {β : Type u_3} {γ : Type u_5} {m : α → β → γ} {a : α} {b : β},
      Filter.map₂ m (pure a) (pure b) = pure (m a b) :=
  by sorry

This theorem, `Filter.map₂_pure`, states that for any binary function `m` of type `α → β → γ`, and any two elements `a` of type `α` and `b` of type `β`, the image of the function `m` under the filters `pure a` and `pure b` (which are the filters containing only the elements `a` and `b` respectively) is equal to the filter containing only the element `m a b`. In mathematical terms, if we consider the function `m` as a mapping from the Cartesian product `α × β` to `γ`, then applying this function to the pairs `(a, b)` where `a` and `b` are specific elements of `α` and `β` respectively, produces the same result as applying the function `m` to `a` and `b` directly and taking the filter containing only this result.

For any binary function `m` and elements `a` and `b`, `Filter.map₂ m (pure a) (pure b) = pure (m a b)`.


theorem Finset.mem_of_max : ∀ {α : Type u_2} [inst : LinearOrder α] {s : Finset α} {a : α}, Finset.max s = ↑a → a ∈ s :=
  by sorry

The theorem `Finset.mem_of_max` states that for any type `α` equipped with a linear order and for any finite set `s` of type `α` and any element `a` of type `α`, if the maximum element of the set `s` is `a` (i.e., `Finset.max s = ↑a`), then `a` is an element of `s`. This theorem essentially asserts the basic property that if `a` is the maximum element in a finite set, then `a` must necessarily be in the set.

If a finite set `s` has maximum element `a`, then `a` is an element of `s`.


/-- A variation around the pseudometric characterization of Cauchy sequences  -/
theorem Metric.cauchySeq_iff' :
    ∀ {α : Type u} {β : Type v} [inst : PseudoMetricSpace α] [inst_1 : Nonempty β] [inst_2 : SemilatticeSup β]
      {u : β → α}, CauchySeq u ↔ ∀ ε > 0, ∃ N, ∀ n ≥ N, dist (u n) (u N) < ε :=
  by sorry

This theorem establishes a variant of the pseudometric characterization of Cauchy sequences. Specifically, it states that for any types `α` and `β`, where `α` has a structure of a pseudometric space, `β` is nonempty and has a structure of a semilattice with supremum, and `u` is a function from `β` to `α`, then `u` is a Cauchy sequence if and only if for every positive real number `ε`, there exists an element `N` in `β` such that for all `n` in `β` greater than or equal to `N`, the distance between `u(n)` and `u(N)` is less than `ε`.

A function from a semilattice with supremum to a pseudometric space is a Cauchy sequence if and only if for every ε > 0, there exists an element N such that the distance between f(N) and f(n) < ε for all n ≥ N.


theorem one_lt_pow : ∀ {R : Type u_3} [inst : OrderedSemiring R] {a : R}, 1 < a → ∀ {n : ℕ}, n ≠ 0 → 1 < a ^ n := by
  sorry

This theorem states that for any type `R` that is an ordered semiring, and for any element `a` of type `R`, if `a` is greater than 1, then `a` raised to the power of any non-zero natural number `n` is also greater than 1. In mathematical terms, this theorem can be written as: For all `a` in 'R' and 'n' in natural numbers, if 'a' > 1 and 'n' ≠ 0, then 'a^n' > 1.

For any ordered semiring R and its element a > 1, the power a^n with a non-zero natural number n also holds the property a^n > 1.


theorem List.IsRotated.nodup_iff : ∀ {α : Type u} {l l' : List α}, l ~r l' → (List.Nodup l ↔ List.Nodup l') := by sorry

The theorem `List.IsRotated.nodup_iff` states that for any type `α` and any two lists `l` and `l'` of type `α`, if `l` is a rotation of `l'` (denoted as `l ~r l'`), then `l` has no duplicates if and only if `l'` has no duplicates. In other words, the property of having no duplicate elements is preserved under the operation of rotation.

For any type `α` and lists `l` and `l'` of type `α`, `l` has no duplicates if and only if `l'` has no duplicates whenever `l` is a rotation of `l'`.


theorem Fin.val_add : ∀ {n : ℕ} (a b : Fin n), ↑(a + b) = (↑a + ↑b) % n := by sorry

This theorem, `Fin.val_add`, states that for any natural number `n` and any two finite numbers `a` and `b` (which are both less than `n`), the value obtained by casting the sum of `a` and `b` to a natural number is equal to the remainder when the sum of the natural number equivalents of `a` and `b` is divided by `n`. In essence, this theorem is about performing addition in the finite number system (modulo arithmetic) and making sure it corresponds correctly to the arithmetic in the natural numbers.

For any natural number `n`, and finite numbers `a` and `b` less than `n`, the cast of `a + b` to a natural number equals the remainder when `a + b` is modulo `n`.


theorem closure_eq_compl_interior_compl :
    ∀ {X : Type u} {s : Set X} [inst : TopologicalSpace X], closure s = (interior sᶜ)ᶜ := by sorry

This theorem states that for any type `X`, any `s` which is a set of `X`, and given that `X` is a topological space, the closure of the set `s` is equal to the complement of the interior of the complement of `s`. In other words, it says that in any topological space, the closure of a set is the same as taking the set, finding its complement (all points not in the set), determining the interior of that complement, and then taking the complement of that interior.

In a topological space, the closure of a set is equal to the complement of the interior of its complement.


theorem Pi.continuous_precomp' :
    ∀ {ι : Type u_5} {π : ι → Type u_6} [T : (i : ι) → TopologicalSpace (π i)] {ι' : Type u_8} (φ : ι' → ι),
      Continuous fun f j => f (φ j) :=
  by sorry

For all types `ι` and `π`, if `π` is a function from `ι` to a topology, and `φ` is a function from some other type `ι'` to `ι`, then the function which takes a function `f` and a value `j` and gives `f (φ j)` is continuous. Here, continuity is defined in the topological sense - that is, the preimage of every open set is open.

Given a type `ι`, a function `π : ι → Topology`, and a function `φ : ι' → ι`, the function `f ↦ φ → f ∘ φ` is continuous from `(Fun ι' ι) → (OpenSet (π i))` to `(OpenSet (π i))`.


theorem Hyperreal.isSt_ofSeq_iff_tendsto :
    ∀ {f : ℕ → ℝ} {r : ℝ}, Hyperreal.IsSt (Hyperreal.ofSeq f) r ↔ Filter.Tendsto f (↑(Filter.hyperfilter ℕ)) (nhds r) :=
  by sorry

This theorem establishes an equivalence between two properties of a sequence `f` of real numbers and a real number `r`. On one hand, it states that `r` is the standard part of the hyperreal number constructed from the sequence `f`, denoted as `Hyperreal.IsSt (Hyperreal.ofSeq f) r`. On the other hand, it asserts that the sequence `f` converges to `r` under the ultrafilter extending the cofinite filter (in other words, almost all elements of the sequence are close to `r`), denoted as `Filter.Tendsto f (↑(Filter.hyperfilter ℕ)) (nhds r)`. The equivalence between these two conditions implies that the standard part of a hyperreal number is the limit point of the sequence from which the hyperreal number is constructed, when the limit is taken under the hyperfilter, a certain type of ultrafilter.

The theorem states that a real number `r` is the standard part of the hyperreal number constructed from a convergent sequence `f` of real numbers if and only if `f` converges to `r` under the ultrafilter extending the cofinite filter.


theorem Ordinal.blsub_le_iff :
    ∀ {o : Ordinal.{u}} {f : (a : Ordinal.{u}) → a < o → Ordinal.{max u v}} {a : Ordinal.{max u v}},
      Ordinal.blsub o f ≤ a ↔ ∀ (i : Ordinal.{u}) (h : i < o), f i h < a :=
  by sorry

This theorem, `Ordinal.blsub_le_iff`, states that for any ordinal `o`, function `f` from ordinals less than `o` to ordinals, and ordinal `a`, the least strict upper bound of the family of ordinals indexed by the set of ordinals less than `o` (denoted as `Ordinal.blsub o f`) is less than or equal to `a` if and only if, for all ordinals `i` that are less than `o`, `f(i)` is less than `a`. In other words, it provides a characterization of the least upper bound in terms of the ordinals less than the index `o`.

For any ordinal `o`, function `f` from ordinals less than `o` to ordinals, and ordinal `a`, `Ordinal.blsub o f` is less than or equal to `a` if and only if `f(i)` is less than `a` for all `i` less than `o`.


theorem CentroidHom.toEnd_smul :
    ∀ {M : Type u_2} {α : Type u_5} [inst : NonUnitalNonAssocSemiring α] [inst_1 : Monoid M]
      [inst_2 : DistribMulAction M α] [inst_3 : SMulCommClass M α α] [inst_4 : IsScalarTower M α α] (m : M)
      (x : CentroidHom α), CentroidHom.toEnd (m • x) = m • CentroidHom.toEnd x :=
  by sorry

The theorem `CentroidHom.toEnd_smul` states that for any type `M` which is a monoid, any type `α` which is a non-unital non-associative semiring, and with `α` having a distributive multiplication action by `M` and scalar multiplication on `α` commuting with the multiplication in `α` (i.e., `M`, `α` and `α` form a scalar multiplication commutative class) and `M` being a scalar tower over `α`, for any element `m` in `M` and any centroid homomorphism `x` on `α`, the endomorphism obtained by applying the scalar `m` to `x` and then converting to an endomorphism is the same as first converting `x` to an endomorphism and then applying the scalar `m`. In terms of formulas, the theorem says that for all `m` in `M` and all `x` in `CentroidHom α`, we have `CentroidHom.toEnd (m • x) = m • CentroidHom.toEnd x`.

For any monoid `M`, non-unital non-associative semiring `α` with distributive `M`-action and commuting scalar multiplication, and scalar tower `M` over `α`, the endomorphism obtained by applying a scalar `m` in `M` to a centroid homomorphism `x` and then converting to an endomorphism is equal to first converting `x` to an endomorphism and then applying `m`.