theorem IsAddUnit.sub_add_cancel :
    ∀ {α : Type u} [inst : SubtractionMonoid α] {b : α}, IsAddUnit b → ∀ (a : α), a - b + b = a := by sorry

This theorem states that for any type `α` that forms a subtraction monoid, if an element `b` of `α` is an additive unit (meaning it has a two-sided additive inverse), then for any element `a` of `α`, the operation of subtracting `b` from `a`, then adding `b` back to the result, is the same as doing nothing to `a` (i.e., `a - b + b` equals `a`).
In other words, it formalizes the intuitive property of subtraction and addition where the subtracted quantity `b` can be added back to restore the original value `a`. The specific condition that `b` is an additive unit ensures that the addition operation is well-defined and invertible.

For any type `α` that forms a subtraction monoid with additive unit `b`, we have `a - b + b = a` for all `a` in `α`.


theorem Filter.le_lift' :
    ∀ {α : Type u_1} {β : Type u_2} {f : Filter α} {h : Set α → Set β} {g : Filter β},
      g ≤ Filter.lift' f h ↔ ∀ s ∈ f, h s ∈ g :=
  by sorry

This theorem states that for any given types `α` and `β`, a filter `f` on `α`, a function `h` from the set of `α` to the set of `β`, and a filter `g` on `β`, the filter `g` is less than or equal to the lift of filter `f` through function `h` if and only if for all sets `s` in the filter `f`, the image of the set `s` under the function `h` is in the filter `g`. In other words, this theorem establishes the condition under which a filter on `β` is considered to be below (or equal to) the push-forward of a filter on `α` via a function mapping sets of `α` to sets of `β`.

A filter `g` on `β` is less than or equal to the lift of filter `f` on `α` through function `h` if and only if for all sets `s` in `f`, `h(`s`) ∈ g`.


theorem OrderIso.map_mem_maximals :
    ∀ {β : Type u_2} {α : Type u_1} [inst : LE α] [inst_1 : LE β] {s : Set α} {t : Set β} (f : ↑s ≃o ↑t) {x : α}
      (hx : x ∈ maximals (fun x x_1 => x ≤ x_1) s),
      ↑(f { val := x, property := ⋯ }) ∈ maximals (fun x x_1 => x ≤ x_1) t :=
  by sorry

The theorem `OrderIso.map_mem_maximals` states that for any two types `α` and `β` with a less than or equal to (`<=`) order defined on them, given a set `s` of type `α` and a set `t` of type `β`, if there exists an order-isomorphism `f` between the sets `s` and `t`, then for any element `x` in the maximal elements of set `s` (where the maximal elements are defined with respect to the `<=` order), the image of `x` under the isomorphism `f` is in the maximal elements of set `t` (also defined with respect to the `<=` order). Essentially, the order isomorphism preserves the property of being a maximal element.

If `f` is an order isomorphism between sets `s` and `t` with respect to a given order `<=`, then for any maximal element `x` in `s`, `f(x)` is a maximal element in `t`.


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

The theorem `gcd_same` states that for any type `α` that has the structure of a `CancelCommMonoidWithZero` and a `NormalizedGCDMonoid`, the greatest common divisor (GCD) of any element `a` with itself is equal to the normalized value of `a`. In other words, `gcd(a, a)` equals `normalize(a)`. This is a common property in number theory, and it holds in this general algebraic setting as well.

For any type `α` with the structures of a CancelCommMonoidWithZero and a NormalizedGCDMonoid, the normalized value of an element `a` is equal to its greatest common divisor, i.e., `normalize(a) = gcd(a, a)`.


theorem Units.exists_iff_ne_zero : ∀ {G₀ : Type u_3} [inst : GroupWithZero G₀] {x : G₀}, (∃ u, ↑u = x) ↔ x ≠ 0 := by
  sorry

This theorem states that for any type `G₀` that forms a `GroupWithZero`, and any element `x` of `G₀`, there exists a unit `u` such that `u` casted to the type `G₀` equals `x` if and only if `x` is not zero. In other words, every non-zero element of a group with zero can be represented as a unit in that group.

For any group with zero `G₀` and non-zero element `x` in `G₀`, there exists a unit `u` such that `x = u` in `G₀`.


theorem AffineSubspace.wOppSide_comm :
    ∀ {R : Type u_1} {V : Type u_2} {P : Type u_4} [inst : StrictOrderedCommRing R] [inst_1 : AddCommGroup V]
      [inst_2 : Module R V] [inst_3 : AddTorsor V P] {s : AffineSubspace R P} {x y : P},
      AffineSubspace.WOppSide s x y ↔ AffineSubspace.WOppSide s y x :=
  by sorry

This theorem states that for any strict ordered commutative ring `R`, additive commutative group `V`, module `R` over `V`, and an additive torsor `P` over `V`, with `s` being an affine subspace of `P`, and `x` and `y` being two points in `P`, the property of `x` and `y` being weakly on the opposite sides of subspace `s` is commutative. That is, `x` being weakly on the opposite side of `s` from `y` is logically equivalent to `y` being weakly on the opposite side of `s` from `x`.

Remember that `x` and `y` are said to be weakly on the opposite sides of `s` if there exists two points `p₁` and `p₂` in `s` such that the subtracted vectors `(x -ᵥ p₁)` and `(p₂ -ᵥ y)` are on the same ray in the `R`-vector space `V`.

For any strict ordered commutative ring `R`, additive commutative group `V`, `R`-module `P` over `V`, and an additive torsor `P` over `V`, with `s` being an affine subspace of `P`, the property of two points `x` and `y` in `P` being weakly on opposite sides of `s` is a symmetric relation.


theorem Nat.factors_prime : ∀ {p : ℕ}, Nat.Prime p → Nat.factors p = [p] := by sorry

The theorem `Nat.factors_prime` states that for any natural number `p`, if `p` is prime, then the prime factorization of `p` is just the list containing `p` itself. In other words, for a prime number `p`, the only prime factor is `p`.

For any prime number `p`, its prime factorization is the list `[p]`.


DifferentiableOn.congr

theorem DifferentiableOn.congr :
    ∀ {𝕜 : 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 f₁ : E → F} {s : Set E}, DifferentiableOn 𝕜 f s → (∀ x ∈ s, f₁ x = f x) → DifferentiableOn 𝕜 f₁ s :=
  by sorry

The theorem `DifferentiableOn.congr` states that for any nontrivially normed field `𝕜`, and any normed additive commutative groups `E` and `F` with `E` and `F` being vector spaces over `𝕜`, if a function `f` is differentiable on a set `s` of elements from `E` to `F`, and there is another function `f₁` which equals `f` for all points `x` in the set `s`, then `f₁` is also differentiable on the set `s`. This theorem essentially shows that the differentiability of a function on a set is not affected if we replace the function with another function that agrees with it on that set.

If `f` is differentiable on a set `s` in the vector spaces `E` and `F` over a nontrivially normed field `𝕜`, and `f₁` equals `f` on `s`, then `f₁` is differentiable on `s`.


theorem Mathlib.RingTheory.RootsOfUnity.Basic._auxLemma.4 :
    ∀ {α : Type u} [inst : Monoid α] {a b : αˣ}, (a = b) = (↑a = ↑b) := by sorry

This theorem, from the RingTheory.RootsOfUnity.Basic module in Mathlib, states that for any type `α` that has a structure of a monoid, the equality of two units (elements with a multiplicative inverse) `a` and `b` is equivalent to the equality of their corresponding elements in `α`. In other words, two units `a` and `b` are equal if and only if their coercions to `α` are equal.

For any monoid `α`, two of its units `a` and `b` are equal if and only if their coercions to `α` are equal.


theorem ContDiffBump.one_lt_rOut_div_rIn : ∀ {E : Type u_1} {c : E} (f : ContDiffBump c), 1 < f.rOut / f.rIn := by sorry

This theorem states that for any continuously differentiable "bump" function `f` centred at a point `c` in a certain type `E`, the ratio of `rOut` to `rIn` is always greater than 1. Here, `rOut` and `rIn` are parameters of the "bump" function that determine its shape, specifically the radii of the outer and inner regions where the function transitions from 0 to its maximum value.

For any continuously differentiable bump function `f` on type `E` with radii `rOut` and `rIn` such that `rOut > rIn`, we have `f(x)/f(c) > 1` for all `x ε B(c, rOut) \ B(c, rIn)`.


theorem CategoryTheory.ShortComplex.exact_iff_mono :
    ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_3, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
      (S : CategoryTheory.ShortComplex C) [inst_2 : CategoryTheory.Limits.HasZeroObject C],
      S.f = 0 → (CategoryTheory.ShortComplex.Exact S ↔ CategoryTheory.Mono S.g) :=
  by sorry

This theorem states that for a given short complex `S` in a category `C`, which has a zero object and is preadditive, if the morphism `f` in `S` is equal to the zero morphism, then `S` is exact if and only if the morphism `g` in `S` is monic (i.e., a left-cancelable morphism). A short complex is a sequence of objects and morphisms in a category, and exactness is a property of such a sequence that pertains to certain equalities and kernel-cokernel relationships between the morphisms.

In a preadditive category with a zero object, a short complex is exact if and only if every zero morphism in the complex is left-cancelable (monic).


theorem MeasureTheory.IsStoppingTime.measurableSpace_mono :
    ∀ {Ω : Type u_1} {ι : Type u_3} {m : MeasurableSpace Ω} [inst : Preorder ι] {f : MeasureTheory.Filtration ι m}
      {τ π : Ω → ι} (hτ : MeasureTheory.IsStoppingTime f τ) (hπ : MeasureTheory.IsStoppingTime f π),
      τ ≤ π → MeasureTheory.IsStoppingTime.measurableSpace hτ ≤ MeasureTheory.IsStoppingTime.measurableSpace hπ :=
  by sorry

The theorem `MeasureTheory.IsStoppingTime.measurableSpace_mono` states that for any types `Ω` and `ι`, a measurable space `m` over `Ω`, a preorder on `ι`, a filtration `f` of `m`, and two stopping times `τ` and `π` with respect to `f`, if `τ` is less than or equal to `π`, then the σ-algebra associated with stopping time `τ` is a sub-σ-algebra of the σ-algebra associated with stopping time `π`. Intuitively, this means that if one stopping rule `τ` stops no later than another stopping rule `π`, then any event measurable with respect to the earlier stopping rule `τ` is also measurable with respect to the later stopping rule `π`.

If `(Ω, m)` is a measurable space, `f` is a filtration on `m`, `τ` and `π` are stopping times with respect to `f` such that `τ ≤ π`, then the σ-algebra generated by `τ` is a sub-σ-algebra of the σ-algebra generated by `π`.


FractionalIdeal.ext

theorem FractionalIdeal.ext :
    ∀ {R : Type u_1} [inst : CommRing R] {S : Submonoid R} {P : Type u_2} [inst_1 : CommRing P] [inst_2 : Algebra R P]
      {I J : FractionalIdeal S P}, (∀ (x : P), x ∈ I ↔ x ∈ J) → I = J :=
  by sorry

The theorem `FractionalIdeal.ext` states that for any commutative ring `R`, a submonoid `S` of `R`, a type `P` with a commutative ring structure and an `R`-algebra structure, and any two fractional ideals `I` and `J` of `S` in `P`, if every element `x` in `P` belongs to `I` if and only if it belongs to `J`, then `I` and `J` are equal. In other words, two fractional ideals are equal if they contain exactly the same elements.

Two fractional ideals of a commutative ring `R` in a commutative `R`-algebra `P` are equal if and only if they contain the same elements.


theorem TruncatedWittVector.truncate_comp_wittVector_truncate :
    ∀ {p : ℕ} [hp : Fact (Nat.Prime p)] {n : ℕ} {R : Type u_1} [inst : CommRing R] {m : ℕ} (hm : n ≤ m),
      RingHom.comp (TruncatedWittVector.truncate hm) (WittVector.truncate m) = WittVector.truncate n :=
  by sorry

This theorem, `TruncatedWittVector.truncate_comp_wittVector_truncate`, states that for any natural number `p` that is prime, any natural number `n`, any commutative ring `R`, and any natural number `m` such that `n` is less than or equal to `m`, the composition of the ring homomorphism that truncates a truncated Witt vector of length `m` to a truncated Witt vector of length `n` and the ring homomorphism that truncates a Witt vector to its first `m` entries to obtain a truncated Witt vector is equal to the ring homomorphism that truncates a Witt vector to its first `n` entries to obtain a truncated Witt vector. In other words, truncating a Witt vector to length `m` and then truncating the result to length `n` is the same as directly truncating the original Witt vector to length `n`.

For any prime number p, commutative ring R, and natural numbers n ≤ m, the truncation map of Witt vectors of length m followed by the truncation map of length n is equal to the truncation map of length n.


theorem QuotientAddGroup.mk_zero :
    ∀ {G : Type u} [inst : AddGroup G] (N : AddSubgroup G) [nN : AddSubgroup.Normal N], ↑0 = 0 := by sorry

The theorem `QuotientAddGroup.mk_zero` states that for any type `G` that forms an additive group, and any additive subgroup `N` of `G` that is normal, the canonical projection of the zero element from `G` to the quotient group `G/N` is also the zero element. In other words, in the quotient group, the equivalence class of the zero element of the original group is the zero element of the quotient group.

For any normal additive subgroup `N` of an additive group `G`, the canonical projection of the group's zero element maps to the zero element in the quotient group `G/N`.


theorem Asymptotics.IsBigO.eq_zero_imp :
    ∀ {α : Type u_1} {E'' : Type u_9} {F'' : Type u_10} [inst : NormedAddCommGroup E'']
      [inst_1 : NormedAddCommGroup F''] {f'' : α → E''} {g'' : α → F''} {l : Filter α},
      f'' =O[l] g'' → ∀ᶠ (x : α) in l, g'' x = 0 → f'' x = 0 :=
  by sorry

This theorem states that for any types `α`, `E''`, and `F''`, with `E''` and `F''` being normed additively commutative groups, and any functions `f''` from `α` to `E''` and `g''` from `α` to `F''`, and any filter `l` on `α`, if `f''` is big O of `g''` at the points approaching through the filter `l`, then whenever `g''` equals zero at a point in the filter `l`, `f''` will also equal zero at that point. In other words, if function `f''` grows no faster than `g''` near the points determined by the filter `l`, and if `g''` is zero at some of those points, then `f''` must be zero at those points too.

If `f: α -> E` and `g: α -> F` are functions from a type `α` to normed additively commutative groups `E` and `F`, respectively, and `f` is big O of `g` at the points approaching through filter `l`, then for any point `x in α` where `g(x) = 0`, it follows that `f(x) = 0`.


theorem Polynomial.splits_of_splits_id :
    ∀ {K : Type v} {L : Type w} [inst : Field K] [inst_1 : Field L] (i : K →+* L) {f : Polynomial K},
      Polynomial.Splits (RingHom.id K) f → Polynomial.Splits i f :=
  by sorry

The theorem `Polynomial.splits_of_splits_id` states that for any two fields `K` and `L`, and a ring homomorphism `i` from `K` to `L`, if a polynomial `f` over the field `K` splits over `K` itself (meaning that it is either the zero polynomial or all of its irreducible factors have a degree of 1), then `f` also splits over `L` under the ring homomorphism `i`. This implies that the property of being a split polynomial is preserved under ring homomorphisms.

If a polynomial over a field splits in the field, then it splits in any larger field under a ring homomorphism.


/-- In a preadditive category, if all binary products exist, then all binary biproducts exist.  -/
theorem CategoryTheory.Limits.HasBinaryBiproducts.of_hasBinaryProducts :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C]
      [inst_2 : CategoryTheory.Limits.HasBinaryProducts C], CategoryTheory.Limits.HasBinaryBiproducts C :=
  by sorry

This theorem states that for any type `C` which has the structure of a category, if this category is preadditive (meaning that it has a compatible addition operation on the morphisms) and it has binary products (meaning that for each pair of objects, there is another object that represents their product in some sense), then it has binary biproducts. In other words, in a preadditive category, the existence of binary products guarantees the existence of binary biproducts. A biproduct in a category is both a product and a coproduct, and can be thought of as a generalization of the concept of a direct sum in linear algebra.

In a preadditive category with binary products, binary biproducts exist.


theorem LipschitzOnWith.ediam_image2_le :
    ∀ {α : Type u} {β : Type v} {γ : Type w} [inst : PseudoEMetricSpace α] [inst_1 : PseudoEMetricSpace β]
      [inst_2 : PseudoEMetricSpace γ] (f : α → β → γ) {K₁ K₂ : NNReal} (s : Set α) (t : Set β),
      (∀ b ∈ t, LipschitzOnWith K₁ (fun x => f x b) s) →
        (∀ a ∈ s, LipschitzOnWith K₂ (f a) t) →
          EMetric.diam (Set.image2 f s t) ≤ ↑K₁ * EMetric.diam s + ↑K₂ * EMetric.diam t :=
  by sorry

The theorem `LipschitzOnWith.ediam_image2_le` states that for any three types `α`, `β`, and `γ` equipped with pseudoemetric spaces, and for any binary function `f : α → β → γ`, if for every `b` in a set `t` the function `f(_ , b)` is Lipschitz continuous with constant `K₁` on a set `s`, and for every `a` in the set `s` the function `f(a, _)` is Lipschitz continuous with constant `K₂` on the set `t`, then the diameter of the image of the function `f` on the sets `s` and `t`, denoted `EMetric.diam (Set.image2 f s t)`, is less than or equal to `K₁` times the diameter of `s` plus `K₂` times the diameter of `t`. Here, the diameter of a set is the supremum of the distances between all pairs of points in the set.

For any three pseudometric spaces `α × β → γ` with functions `f : α → β → γ`, if `f(_, b)` is Lipschitz continuous on `s ⊆ α` with constant `K₁` for each `b ∈ t ⊆ β`, and `f(a, _)` is Lipschitz continuous on `t` with constant `K₂` for each `a ∈ s`, then the diameter of `f(s × t)` is at most `K₁ * ∇(s) + K₂ * ∇(t)`, where `∇` denotes the diameter.


theorem Complex.arg_neg_eq_arg_sub_pi_of_im_pos : ∀ {x : ℂ}, 0 < x.im → Complex.arg (-x) = Complex.arg x - Real.pi := by
  sorry

This theorem states that for any complex number `x`, if the imaginary part of `x` is positive (i.e., `0 < x.im`), then the argument of the negation of `x` (i.e., `Complex.arg (-x)`) is equal to the argument of `x` subtracted by pi (i.e., `Complex.arg x - Real.pi`). In simpler terms, if we have a complex number with a positive imaginary part, the angle that its negative makes with the positive real axis is the angle made by the original number minus pi. This is based on the polar form representation of complex numbers.

For any complex number `x` with positive imaginary part, `Complex.arg (-x) = Complex.arg x - Real.pi`.


/-- If `s` is a closed set and two functions `f` and `g` are continuous on `s`,
then the set `{x ∈ s | f x ≤ g x}` is a closed set.  -/
theorem IsClosed.isClosed_le :
    ∀ {α : Type u} {β : Type v} [inst : TopologicalSpace α] [inst_1 : Preorder α] [t : OrderClosedTopology α]
      [inst_2 : TopologicalSpace β] {f g : β → α} {s : Set β},
      IsClosed s → ContinuousOn f s → ContinuousOn g s → IsClosed {x | x ∈ s ∧ f x ≤ g x} :=
  by sorry

This theorem states that if we have a set `s` that is closed in a topological space, and `f` and `g` are functions that are continuous on `s`, then the set of points `x` in `s` such that `f(x)` is less than or equal to `g(x)` is also a closed set. Here, `α` and `β` are types equipped with a topological structure, `α` is also equipped with an order relation and an order-closed topology. The functions `f` and `g` map from `β` to `α`. The `IsClosed` predicate checks whether a set is closed in its topological space.

If `s` is a closed subset of a topological space `(α, τ)` with order relation `≤`, and `f` and `g` are continous functions from `(β, τ')` to `(α, τ)` such that `f(x) ≤ g(x)` for all `x ∈ s`, then the set `{x ∈ s | f(x) ≤ g(x)}` is closed in `(α, τ)`.


theorem Set.prod_subset_iff :
    ∀ {α : Type u_1} {β : Type u_2} {s : Set α} {t : Set β} {P : Set (α × β)},
      s ×ˢ t ⊆ P ↔ ∀ x ∈ s, ∀ y ∈ t, (x, y) ∈ P :=
  by sorry

The theorem `Set.prod_subset_iff` states that for any types `α` and `β`, and for any sets `s` of type `α`, `t` of type `β`, and `P` of type `(α × β)`, the Cartesian product of `s` and `t` is a subset of `P` if and only if for every element `x` in `s` and every element `y` in `t`, the ordered pair `(x, y)` is an element of `P`. This theorem is essentially asserting a characterization for when a Cartesian product of two sets is a subset of a third set, in terms of individual elements of the original sets.

For sets `s` of type `α`, `t` of type `β`, and `P` of type `(α × β)`, `s × t ⊆ P` if and only if for all `x ∈ s` and `y ∈ t`, `(x, y) ∈ P`.


theorem Mathlib.Data.Semiquot._auxLemma.6 : ∀ {α : Type u_1} {a b : α}, (a ∈ pure b) = (a = b) := by sorry

This theorem, from the Mathlib library in Lean 4, states that for any type `α` and any two elements `a` and `b` of `α`, the proposition that `a` is in the set `pure b` is equivalent to the proposition that `a` equals `b`. Here, `pure` is a function from the underlying type to a type of sets over the underlying type. In the context of this theorem, `pure b` can be seen as a set that contains only the element `b`.

For any type `α` and any two elements `a` and `b` of `α`, `a` is in the singleton set `{b}` (denoted `pure b`) if and only if `a` equals `b`.


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

This theorem states that for any type `α` that forms a Heyting algebra, for any two elements `a` and `b` of this type, if `a` and `b` are complement to each other (which means `a` and `b` satisfy the properties of being complements in a Heyting algebra), then `a` is equal to the complement of `b`. The complement operation is denoted by `bᶜ` in Lean notation.

In a Heyting algebra, if elements `a` and `b` are complements to each other, then `a = bᶜ`.


theorem Mathlib.NumberTheory.LegendreSymbol.QuadraticChar.Basic._auxLemma.4 :
    ∀ {α : Type u_2} [inst : Zero α] [inst_1 : One α] [inst_2 : NeZero 1], (1 = 0) = False := by sorry

This theorem, part of the Mathlib library in Number Theory, specifically under Legendre Symbol and Quadratic Characters, asserts that for any type `α` that has zero and one as instances and for which one is not zero (`NeZero`), the equality `1 = 0` is always false. In other words, in any number system where "one" and "zero" are defined and "one" is not equal to "zero", one cannot be equal to zero. This is a fundamental concept in most number systems in mathematics.

In any type with defined zero and one where one is non-zero, the equality of one and zero always holds false.


theorem Mathlib.NumberTheory.LegendreSymbol.QuadraticChar.Basic._auxLemma.7 :
    ∀ {α : Sort u_1} {a b : α} {P : Prop} [inst : Decidable P], ((if P then a else b) = a) = (¬P → b = a) := by sorry

This theorem, labeled as `Mathlib.NumberTheory.LegendreSymbol.QuadraticChar.Basic._auxLemma.7`, states that for any sort `α` and any elements `a` and `b` of `α`, along with a proposition `P` for which we can decide whether it is true or false, the equality of the result of a conditional statement `if P then a else b` to `a` is equivalent to the assertion that if `P` is not true, then `b` equals `a`. In other words, if `P` is false, then `b` must be `a` for the conditional statement to still result in `a`.

The theorem `Mathlib.NumberTheory.LegendreSymbol.QuadraticChar.Basic._auxLemma.7` in Lean 4 states that the equality of `a` and `if P then a else b` holds if and only if `b = a` whenever `P` is false.


theorem IsOpen.add_closure :
    ∀ {G : Type w} [inst : TopologicalSpace G] [inst_1 : AddGroup G] [inst_2 : TopologicalAddGroup G] {s : Set G},
      IsOpen s → ∀ (t : Set G), s + closure t = s + t :=
  by sorry

The theorem `IsOpen.add_closure` states that for any type `G` which has a topological space structure, an additive group structure and a topological additive group structure, and for any open set `s` in `G`, the sum of `s` and the closure of any set `t` in `G` is equal to the sum of `s` and `t`. This property is important in the study of topological groups, where the algebraic operations interact with the topology in a continuous way.

For any topological additive group `(G, ⊓, +)`, and open set `s` in `G`, the sum of `s` and the closure of any set `t` in `G` is equal to the sum of `s` and `t`.


theorem List.get_range :
    ∀ {n : ℕ} (i : ℕ) (H : i < List.length (List.range n)), List.get (List.range n) { val := i, isLt := H } = i := by
  sorry

This theorem, `List.get_range`, states a property about the function `List.range` and `List.get` on lists of natural numbers in Lean 4. Specifically, for any natural number `n`, and any index `i` such that `i` is less than the length of the list generated by `List.range n` (i.e., a list of all natural numbers from 0 to `n`, exclusive), the function `List.get` applied to the list `List.range n` at the position `i` will return `i`. In other words, if you have a list of the first `n` natural numbers and you pick the `i`-th element from this list (using zero-based indexing), you will get the number `i` itself.

For any natural number `n` and index `i` less than the length of `List.range n`, `List.get (List.range n) i = i`.


RelEmbedding.isTrans

theorem RelEmbedding.isTrans :
    ∀ {α : Type u_1} {β : Type u_2} {r : α → α → Prop} {s : β → β → Prop},
      r ↪r s → ∀ [inst : IsTrans β s], IsTrans α r :=
  by sorry

This theorem, `RelEmbedding.isTrans`, states that for any two types `α` and `β`, and any two relations `r` on `α` and `s` on `β`, if `r` is embedded in `s` (`r ↪r s`), and `s` is transitive, then `r` is also transitive. In the context of order theory, this means that the transitivity of an order relation is preserved under order-embedding.

If relation `r` on type `α` is embedded in transitive relation `s` on type `β`, then `r` is transitive.


/-- If `μ` is a σ-finite measure, and `s ⊆ α × β` is measurable, then `y ↦ μ { x | (x, y) ∈ s }` is
a measurable function.  -/
theorem measurable_measure_prod_mk_right :
    ∀ {α : Type u_1} {β : Type u_3} [inst : MeasurableSpace α] [inst_1 : MeasurableSpace β]
      {μ : MeasureTheory.Measure α} [inst_2 : MeasureTheory.SFinite μ] {s : Set (α × β)},
      MeasurableSet s → Measurable fun y => ↑↑μ ((fun x => (x, y)) ⁻¹' s) :=
  by sorry

The theorem `measurable_measure_prod_mk_right` states that if `μ` is a σ-finite measure and `s` is a subset of the Cartesian product of `α` and `β` that is measurable, then the function `y ↦ μ { x | (x, y) ∈ s }` is also measurable. In other words, for a σ-finite measure `μ` and a measurable set `s` in the product space of `α` and `β`, the function that maps each `y` to the measure of the set of `x` such that `(x, y)` is in `s` is a measurable function.

If `μ` is a σ-finite measure and `s` is a measurable subset of the product space `α × β`, then the function `y ↦ μ { x | (x, y) ∈ s }` is a measurable function.


/-- If two functions are equal in the relevant interval, their interval integrals are also equal.  -/
theorem intervalIntegral.integral_congr :
    ∀ {E : Type u_3} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {f g : ℝ → E}
      {μ : MeasureTheory.Measure ℝ} {a b : ℝ},
      Set.EqOn f g (Set.uIcc a b) → ∫ (x : ℝ) in a..b, f x ∂μ = ∫ (x : ℝ) in a..b, g x ∂μ :=
  by sorry

This theorem states that if two functions `f` and `g`, mapping from the real numbers to a normed additive commutative group `E`, are equal on an interval including the endpoints `a` and `b` (denoted as `[a, b]`), then the interval integrals of the two functions over the interval `[a, b]` are also equal. The interval integral is taken with respect to a measure `μ`. In other words, if `f(x) = g(x)` for all `x` in `[a, b]`, then the integral of `f` from `a` to `b` is the same as the integral of `g` from `a` to `b`.

If functions `f` and `g` are equal on an interval `[a, b]` in a normed additive commutative group `E` with respect to a measure `μ`, then their integrals from `a` to `b` are equal: `∫[a,b] f(x) δx = ∫[a,b] g(x) δx`.


theorem Function.Antiperiodic.nat_mul_eq_of_eq_zero :
    ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {c : α} [inst : Semiring α] [inst_1 : NegZeroClass β],
      Function.Antiperiodic f c → f 0 = 0 → ∀ (n : ℕ), f (↑n * c) = 0 :=
  by sorry

The theorem `Function.Antiperiodic.nat_mul_eq_of_eq_zero` states that for any function `f` from a type `α` to a type `β`, and any value `c` of type `α`, given that the semiring structure is defined on `α` and the negation-zero class is defined on `β`, if `f` is antiperiodic with antiperiod `c` and `f` at zero equals zero, then for all natural numbers `n`, `f` at the product of `n` and `c` equals zero. In other words, if a function is antiperiodic at some point and equals zero at that point, then it will also equal zero at all points that are multiples of the antiperiod.

If `f` is an Antiperiodic function from type `α` to type `β`, with antiperiod `c` and `f(c) = 0`, then `f(n * c) = 0` for all natural numbers `n`.


theorem ENNReal.div_mul_cancel : ∀ {a b : ENNReal}, a ≠ 0 → a ≠ ⊤ → b / a * a = b := by sorry

This theorem states that for any two extended nonnegative real numbers `a` and `b`, where `a` is neither zero nor infinity, the operation of dividing `b` by `a`, then multiplying the result by `a`, will yield `b` back. In mathematical terms, this theorem asserts that for `a` and `b` in the set of extended nonnegative real numbers (typically denoted as [0, ∞]), if `a` is not zero and `a` is not infinity, then `(b / a) * a = b`. This is akin to the mathematical principle that division and multiplication are inverse operations for non-zero and non-infinite numbers.

For any extended nonnegative real numbers `a` and `b` with `a \neq 0 \neq \infty`, `(b / a) * a = b`.


theorem Mathlib.Data.Ordmap.Ordset._auxLemma.6 :
    ∀ {α : Type u_1} {P : α → Prop} {l : Ordnode α} {x : α} {r : Ordnode α},
      Ordnode.All P (Ordnode.node' l x r) = (Ordnode.All P l ∧ P x ∧ Ordnode.All P r) :=
  by sorry

The theorem `Mathlib.Data.Ordmap.Ordset._auxLemma.6` states that for any type `α`, property `P` that each element of type `α` can have, and ordered nodes `l`, `x`, and `r`, the predicate `Ordnode.All P` applied to the node created by `Ordnode.node' l x r` (without rebalancing) is equivalent to the conjunction (logical "and") of `Ordnode.All P l`, `P x`, and `Ordnode.All P r`. In other words, every element in the balanced tree (comprising of nodes `l`, `x`, and `r`) satisfies `P` if and only if every element in `l`, `x`, and `r` individually satisfies `P`.

For any type `α` and property `P`, the node `Ordnode.node' l x r` in an ordered tree satisfies `Ordnode.All P` if and only if nodes `l`, `x`, and `r` individually satisfy `P`.


theorem Polynomial.isPrimitive_primPart :
    ∀ {R : Type u_1} [inst : CommRing R] [inst_1 : IsDomain R] [inst_2 : NormalizedGCDMonoid R] (p : Polynomial R),
      Polynomial.IsPrimitive (Polynomial.primPart p) :=
  by sorry

The theorem `Polynomial.isPrimitive_primPart` states that for any commutative ring `R` that is a domain and has a normalized greatest common divisor monoid, the primitive part of any polynomial `p` over `R` is a primitive polynomial. In other words, if a constant polynomial divides the primitive part of `p`, that constant polynomial is a unit. If `p` is the zero polynomial, its primitive part is taken to be 1, which is a primitive polynomial since the only constant polynomial (i.e., a scalar) dividing it is itself, which is a unit.

For any commutative domain ring `R` with a normalized greatest common divisor monoid, the primitive part of a polynomial `p` over `R` is a primitive polynomial.


theorem Mathlib.Algebra.BigOperators.Finprod._auxLemma.6 :
    ∀ {α : Type u_1} {M : Type u_5} [inst : One M] {f : α → M} {x : α}, (x ∈ Function.mulSupport f) = (f x ≠ 1) := by
  sorry

This theorem states that for any types `α` and `M`, where `M` is a type with a one-element (`1`), and any function `f` from `α` to `M`, and any element `x` of type `α`, the element `x` is in the `mulSupport` of `f` if and only if `f(x)` is not equal to `1`. In other words, `mulSupport f` is precisely the set of points `x` in `α` such that `f(x) ≠ 1`.

For any type `α` and function `f` from `α` to a one-element type `M`, `x` in `α` is in the support of `f` (denoted `mulSupport f`) if and only if `f(x)` is not equal to the unique element of `M`.


/-- If `[c, d]` is a subinterval of `[a, b]`, then the distance between `c` and `d` is less than or
equal to that of `a` and `b`  -/
theorem Set.abs_sub_le_of_uIcc_subset_uIcc :
    ∀ {α : Type u_1} [inst : LinearOrderedAddCommGroup α] {a b c d : α},
      Set.uIcc c d ⊆ Set.uIcc a b → |d - c| ≤ |b - a| :=
  by sorry

The theorem `Set.abs_sub_le_of_uIcc_subset_uIcc` states that for any subtype α, which is a linear ordered additive commutative group, and any elements a, b, c, d of this type, if the interval [c, d] is a subset of the interval [a, b] (represented by the condition '`Set.uIcc c d ⊆ Set.uIcc a b`'), then the absolute difference between c and d is less than or equal to the absolute difference between a and b, denoted as '|d - c| ≤ |b - a|'. This theorem basically asserts that if one interval is contained within another, then the length or "distance" of the inner interval is not larger than the length or "distance" of the outer interval.

If $c, d, a, b$ are elements of a linear ordered additive commutative group $\alpha$, then $|d-c|\leq|b-a|$ whenever $[c,d]\subseteq[a,b]$.


theorem LieSubmodule.subsingleton_iff :
    ∀ (R : Type u) (L : Type v) (M : Type w) [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : AddCommGroup M]
      [inst_3 : Module R M] [inst_4 : LieRingModule L M], Subsingleton (LieSubmodule R L M) ↔ Subsingleton M :=
  by sorry

This theorem states that for any given types `R`, `L`, `M` where `R` is a commutative ring, `L` is a Lie Ring, and `M` is an additive commutative group with a module structure over `R` and a Lie Ring module structure over `L`, the type `LieSubmodule R L M` is a subsingleton if and only if `M` is a subsingleton. In other words, there is at most one Lie submodule of `M` (under the stated conditions) if and only if `M` itself has at most one element.

For a commutative ring `R`, a Lie Ring `L`, and an additive commutative group `M` with module and Lie Ring module structures over `R`, the unique Lie submodule of `M` (if it exists) is isomorphic to `M` itself if and only if `M` is a singleton.


theorem Equiv.Perm.IsCycleOn.apply_ne :
    ∀ {α : Type u_2} {f : Equiv.Perm α} {s : Set α} {a : α},
      Equiv.Perm.IsCycleOn f s → Set.Nontrivial s → a ∈ s → f a ≠ a :=
  by sorry

This theorem states that, for any type `α`, any permutation `f` on `α`, and any set `s` of `α`, if `f` is a cycle on `s` and `s` is a nontrivial set (i.e., `s` contains at least two distinct elements), then for every element `a` in `s`, the application of the permutation `f` to `a` does not equal `a`. In other words, in a nontrivial set on which a permutation forms a cycle, no element is mapped to itself by the permutation.

If `f` is a permutation on a nontrivial set `s` that forms a cycle on `s`, then for all `a` in `s`, `f(a) ≠ a`.


theorem continuous_piecewise :
    ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] {s : Set α} {f g : α → β}
      [inst_2 : (a : α) → Decidable (a ∈ s)],
      (∀ a ∈ frontier s, f a = g a) →
        ContinuousOn f (closure s) → ContinuousOn g (closure sᶜ) → Continuous (Set.piecewise s f g) :=
  by sorry

This theorem, `continuous_piecewise`, states that for any types `α` and `β`, assumed to be topological spaces, and for a set `s` of type `α`, and two functions `f` and `g` mapping `α` to `β`. Assuming that we can decide for each element of `α` whether it belongs to `s` or not, if for every element on the frontier of `s`, `f` and `g` coincide, and `f` is continuous over the closure of `s`, and `g` is continuous over the closure of the complement of `s`, then the piecewise function that equals `f` on `s` and `g` on its complement is continuous. In simpler words, this theorem guarantees the continuity of a piecewise function under certain conditions about the continuity of its component functions and their agreement on the border of the regions where they are defined.

Given topological spaces α and β, sets s ⊆ α, and continuous functions f : α → β and g : α → β with f restriction to s = g restriction to s on the frontier of s, if f is continuous over the closure of s and g is continuous over the closure of s∖s, then the piecewise function (x : α) → if x ∈ s then f x else g x is continuous.


/-- A set is a neighborhood of `a` if and only if it contains an interval `(l, u)` containing `a`,
provided `a` is neither a bottom element nor a top element.  -/
theorem mem_nhds_iff_exists_Ioo_subset' :
    ∀ {α : Type u} [inst : TopologicalSpace α] [inst_1 : LinearOrder α] [inst_2 : OrderTopology α] {a : α} {s : Set α},
      (∃ l, l < a) → (∃ u, a < u) → (s ∈ nhds a ↔ ∃ l u, a ∈ Set.Ioo l u ∧ Set.Ioo l u ⊆ s) :=
  by sorry

This theorem states that for a given set `s` and an element `a` of a linear ordered topological space `α`, `s` is a neighborhood of `a` if and only if there exist elements `l` and `u` such that `a` is in the open interval `(l, u)` and this interval is a subset of `s`. This is provided that `a` is not a bottom or top element, meaning there exist elements `l` and `u` in `α` such that `l` is less than `a` and `a` is less than `u`, respectively.

A set `s` is a neighborhood of an element `a` in a linear ordered topological space if and only if `a` is an interior point of the open interval `(l, u)` that is a subset of `s`, where `l` and `u` are elements strictly less and greater than `a`, respectively.


theorem FirstOrder.Language.LHom.comp_onTerm :
    ∀ {L : FirstOrder.Language} {L' : FirstOrder.Language} {α : Type u'} {L'' : FirstOrder.Language} (φ : L' →ᴸ L'')
      (ψ : L →ᴸ L'),
      FirstOrder.Language.LHom.onTerm (FirstOrder.Language.LHom.comp φ ψ) =
        FirstOrder.Language.LHom.onTerm φ ∘ FirstOrder.Language.LHom.onTerm ψ :=
  by sorry

The theorem `FirstOrder.Language.LHom.comp_onTerm` states that for any three first-order languages `L`, `L'`, and `L''` and any two language homomorphisms `φ : L' →ᴸ L''` and `ψ : L →ᴸ L'`, the composition of `φ` and `ψ` when applied to a term is equivalent to first applying `ψ` to the term, and then applying `φ` to the resulting term. This is an assertion of the commutativity of the `onTerm` function with the composition operation for language homomorphisms.

For any first-order languages $L$, $L'$, $L''$, and homomorphisms $\varphi : L' \rightarrow L''$ and $\psi : L \rightarrow L'$, we have $\varphi \circ \psi (t) = \varphi ( \psi (t))$ for all terms $t$ in $L$.


theorem WittVector.coeff_truncateFun :
    ∀ {p n : ℕ} {R : Type u_1} (x : WittVector p R) (i : Fin n),
      TruncatedWittVector.coeff i (WittVector.truncateFun n x) = x.coeff ↑i :=
  by sorry

This theorem states that for any given prime number `p`, any nonnegative integer `n`, any type `R`, any Witt vector `x` of type `R` and base `p`, and any index `i` which is less than `n`, the `i`th coefficient of the truncated Witt vector obtained from `x` by the function `WittVector.truncateFun` is equal to the `i`th coefficient of the original Witt vector `x`. In other words, the truncation operation preserves the `i`th coefficient of the Witt vector.

For any prime number `p`, type `R`, Witt vector `x` of type `WittVector R p`, and index `i` less than the length of `x`, the `i`th coefficient of `WittVector.truncateFun x` equals the `i`th coefficient of `x`.


theorem WittVector.verschiebung_coeff_zero :
    ∀ {p : ℕ} {R : Type u_1} [hp : Fact (Nat.Prime p)] [inst : CommRing R] (x : WittVector p R),
      (WittVector.verschiebung x).coeff 0 = 0 :=
  by sorry

The theorem `WittVector.verschiebung_coeff_zero` states that for any prime number `p`, and any type `R` that is a commutative ring, the 0th coefficient of the verschiebung (or shift) of any Witt vector `x` with coefficients in `R` modulo `p` is always 0. In other words, when we apply the verschiebung operation, which shifts the coefficients of a Witt vector up by one, the new coefficient at position 0 is always 0.

For any prime number p and commutative ring R, the 0th coefficient of the verschiebung of a Witt vector with coefficients in R modulo p is 0.


theorem Mathlib.Data.Nat.Periodic._auxLemma.1 : ∀ {b : Prop} (α : Sort u_1) [i : Nonempty α], (α → b) = b := by sorry

This theorem states that for any proposition `b` and any type `α` (which is nonempty, meaning there exists at least one value of type `α`), the type of a function that takes an input of type `α` and returns `b` is simply the same as the type of `b`. In other words, if `b` is any proposition and `α` is any nonempty type, then the function type `(α → b)` collapses to `b`.

For any nonempty type `α` and proposition `b`, the function type `(α → b)` is equivalent to `b`.


theorem CategoryTheory.GrothendieckTopology.Subpresheaf.le_sheafify :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (J : CategoryTheory.GrothendieckTopology C)
      {F : CategoryTheory.Functor Cᵒᵖ (Type w)} (G : CategoryTheory.GrothendieckTopology.Subpresheaf F),
      G ≤ CategoryTheory.GrothendieckTopology.Subpresheaf.sheafify J G :=
  by sorry

This theorem states that for any category `C`, Grothendieck topology `J` on `C`, and subpresheaf `G` on `C`, `G` is less than or equal to the sheafification of `G` with respect to `J`. In other words, in the context of category theory and Grothendieck topologies, any subpresheaf is always dominated by its sheafification.

For any category `C`, Grothendieck topology `J`, and subpresheaf `G` on `C`, `G` is pointwise included in the sheafification of `G` with respect to `J`.


theorem isClosed_le_prod :
    ∀ {α : Type u} [inst : TopologicalSpace α] [inst_1 : Preorder α] [t : OrderClosedTopology α],
      IsClosed {p | p.1 ≤ p.2} :=
  by sorry

The theorem `isClosed_le_prod` states that for any type `α` that has a topology (i.e., it is a topological space), a preorder (i.e., it has a relation that is reflexive and transitive), and an order-closed topology (i.e., the topology is such that the set of points less than or equal to a given point is always closed), the set of ordered pairs `(p.1, p.2)` where `p.1` is less than or equal to `p.2` is a closed set.

Given a topological space `α` with a preorder and an order-closed topology, the set of ordered pairs `{(x, y) | x ≤ y}` is closed.


theorem Real.dimH_of_mem_nhds :
    ∀ {E : Type u_4} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [inst_2 : FiniteDimensional ℝ E] {x : E}
      {s : Set E}, s ∈ nhds x → dimH s = ↑(FiniteDimensional.finrank ℝ E) :=
  by sorry

This theorem states that for any normed additive commutative group `E` that is a normed space over the real numbers `ℝ` and is finite-dimensional, given any point `x` in `E` and any set `s` in `E` that is a neighborhood of `x` (i.e., `s` belongs to the neighborhood filter of `x`), the Hausdorff dimension of `s` is equal to the rank of `E` as a module over `ℝ`. The rank of `E` is expressed as a natural number using `FiniteDimensional.finrank`. In essence, the theorem is a connection between topological dimension (Hausdorff dimension) and algebraic dimension (rank) in the context of finite-dimensional normed spaces over the reals.

In a finite-dimensional, real normed space, the Hausdorff dimension of a neighborhood of any point equals the rank of the space as an $\mathbb{R}$-module.


theorem Complex.abs_exp_ofReal_mul_I : ∀ (x : ℝ), Complex.abs (Complex.exp (↑x * Complex.I)) = 1 := by sorry

This theorem states that for all real numbers `x`, the absolute value (or magnitude) of the complex exponential function when evaluated at the product of `x` and the imaginary unit `I`, is equal to 1. In simpler terms, whenever we multiply a real number by the imaginary unit and then apply the complex exponential function to the result, the magnitude of the resulting complex number will always be 1. In mathematical notation, this theorem can be expressed as: for all x in ℝ, |exp(x * i)| = 1.

For all real numbers x, |exp(xi)| = 1. (The complex exponential function of the product of a real number and the imaginary unit has magnitude 1.)


theorem Complex.cpow_nat_cast : ∀ (x : ℂ) (n : ℕ), x ^ ↑n = x ^ n := by sorry

This theorem states that for all complex numbers 'x' and for all natural numbers 'n', raising 'x' to the power of the complex representation of 'n' is equal to raising 'x' to the power of 'n'. In other words, the power operation on complex numbers is consistent with the power operation on natural numbers when the exponent is a natural number.

For all complex numbers x and natural numbers n, x^(npow n) = x^n.


theorem MeasureTheory.IsProjectiveLimit.measure_univ_eq :
    ∀ {ι : Type u_1} {α : ι → Type u_2} [inst : (i : ι) → MeasurableSpace (α i)]
      {P : (J : Finset ι) → MeasureTheory.Measure ((j : { x // x ∈ J }) → α ↑j)}
      {μ : MeasureTheory.Measure ((i : ι) → α i)},
      MeasureTheory.IsProjectiveLimit μ P → ∀ (I : Finset ι), ↑↑μ Set.univ = ↑↑(P I) Set.univ :=
  by sorry

This theorem states that for any type `ι` and a type map `α : ι → Type`, given a measure `μ` on the product of the types `α i` and a family of measures `P` indexed by finite subsets of `ι`, if `μ` is the projective limit of the family `P`, then the measure of the universal set with respect to `μ` is equal to the measure of the universal set with respect to each measure in the family `P`. In mathematical terms, if `μ` is the projective limit of `P`, then for every finite subset `I` of `ι`, we have that `μ(Universe) = P_I(Universe)`. The universal set in this context represents the set of all possible values of a given type.

 If `μ` is the projective limit of a family `P` of measures on types `α i`, then `μ(Universe) = ∏ I in Finset ι, P I(Universe)`.

Here, `Universe` represents the universal set of each type `α i`, and `Finset ι` is the type of finite subsets of `ι`. The notation `∏ I in Finset ι, P I(Universe)` denotes the product of measures `P I(Universe)` over all finite subsets `I` of `ι`.


theorem Normal.of_algEquiv :
    ∀ {F : Type u_1} {E : Type u_3} {E' : Type u_4} [inst : Field F] [inst_1 : Field E] [inst_2 : Algebra F E]
      [inst_3 : Field E'] [inst_4 : Algebra F E'] [h : Normal F E], (E ≃ₐ[F] E') → Normal F E' :=
  by sorry

The theorem `Normal.of_algEquiv` states that for any three types `F`, `E`, and `E'`, where `F` is a field, `E` and `E'` are fields that are also algebras over `F`, if `E` is a normal extension of `F`, then if `E` is algebraically equivalent to `E'` (denoted as `E ≃ₐ[F] E'`), `E'` is also a normal extension of `F`. Essentially, it says that the property of being a normal extension is preserved under algebraic equivalence.

If `F` is a field, `E` and `E'` are fields and algebras over `F`, `E` is a normal extension of `F`, and `E ≃ₐ[F] E'`, then `E'` is a normal extension of `F`.


theorem TrivSqZeroExt.inl_zero :
    ∀ {R : Type u} (M : Type v) [inst : Zero R] [inst_1 : Zero M], TrivSqZeroExt.inl 0 = 0 := by sorry

The theorem `TrivSqZeroExt.inl_zero` states that for any two types `R` and `M` where `R` and `M` both have a zero element (i.e., are instances of the `Zero` typeclass), the canonical inclusion mapping of `0` from `R` to `TrivSqZeroExt R M` (performed using the `TrivSqZeroExt.inl` function) results in `0`. In simple terms, when `0` from the type `R` is mapped to the trivial square zero extension of `R` and `M`, it remains `0`.

For any types `R` and `M` with zero elements, the `TrivSqZeroExt.inl` function applied to the zero element of `R` results in the zero element of `TrivSqZeroExt R M`.


theorem of_eq : ∀ {α : Type u} {r : α → α → Prop} [inst : IsRefl α r] {a b : α}, a = b → r a b := by sorry

This theorem states that for any type `α` and any binary relation `r` on `α`, given also that `r` is reflexive, if `a` and `b` are equal elements of type `α`, then `r a b` holds true. In other words, if `a` and `b` are the same element, then the reflexive relation `r` is fulfilled between `a` and `b`.

If `r` is a reflexive binary relation on type `α`, then `r a a` holds for all `a` in `α`.


theorem Mathlib.Order.PartialSups._auxLemma.3 :
    ∀ {α : Type u_1} [inst : SemilatticeSup α] {f : ℕ → α} {n : ℕ} {a : α},
      ((partialSups f) n ≤ a) = ∀ k ≤ n, f k ≤ a :=
  by sorry

The theorem states that for any type `α` that forms a semilattice under a supremum operation, for any function `f` from natural numbers to `α`, for any natural number `n`, and for any element `a` of `α`, the following two conditions are equivalent: (1) the `n`-th element of the sequence of partial supremums of `f` is less than or equal to `a`, and (2) for all natural numbers `k` less than or equal to `n`, the `k`-th element of `f` is less than or equal to `a`. In other words, the maximum value of the function `f` up to the `n`-th term is less than or equal to `a` if and only if all terms of `f` up to the `n`-th term are less than or equal to `a`.

For any semilattice `α` with supremum operation, and any function `f` from natural numbers to `α`, the sequence of partial supremums of `f` up to the `n`-th term is less than or equal to an element `a` if and only if the first `n` terms of `f` are less than or equal to `a`.


/-- An additive group is finitely generated if and only
if it is finitely generated as an additive monoid. -/
theorem AddGroup.fg_iff_addMonoid_fg : ∀ {G : Type u_3} [inst : AddGroup G], AddGroup.FG G ↔ AddMonoid.FG G := by sorry

This theorem states that for any given type `G`, if `G` is an additive group, then `G` is finitely generated if and only if it is finitely generated as an additive monoid. In mathematical terms, it's stating that the properties of being finitely generated in the contexts of additive groups and additive monoids are equivalent for a given type.

For an additive group `G`, it is finitely generated if and only if it is finitely generated as an additive monoid.


theorem IsGalois.fixedField_fixingSubgroup :
    ∀ {F : Type u_1} [inst : Field F] {E : Type u_2} [inst_1 : Field E] [inst_2 : Algebra F E]
      (K : IntermediateField F E) [inst_3 : FiniteDimensional F E] [h : IsGalois F E],
      IntermediateField.fixedField (IntermediateField.fixingSubgroup K) = K :=
  by sorry

The theorem `IsGalois.fixedField_fixingSubgroup` states that for any field `F`, assuming `F` is an instance of a Field, and any field `E`, assuming `E` is an instance of a Field and there exists an algebra structure over `F` and `E`, and any intermediate field `K` of `F` and `E`, given that `E` is a finite dimensional extension over `F` and also a Galois extension over `F`, then the intermediate field which is fixed by the subgroup that fixes `K` is indeed `K` itself. In simpler terms, this theorem is a part of Galois theory, stating that the field fixed by the automorphism group that fixes a given intermediate field in a finite Galois extension is the intermediate field itself.

In a finite Galois extension, the fixed field of the subgroup stabilizing an intermediate field is that intermediate field itself.


theorem HasSum.add_isCompl :
    ∀ {α : Type u_1} {β : Type u_2} [inst : AddCommMonoid α] [inst_1 : TopologicalSpace α] {f : β → α} {a b : α}
      [inst_2 : ContinuousAdd α] {s t : Set β},
      IsCompl s t → HasSum (f ∘ Subtype.val) a → HasSum (f ∘ Subtype.val) b → HasSum f (a + b) :=
  by sorry

The theorem `HasSum.add_isCompl` states that for any types `α` and `β`, with `α` being an additive commutative monoid and also a topological space, and `f` being a function from `β` to `α`, if we have two sets `s` and `t` that are complements of each other (`IsCompl s t`), and we know that the series of `f` applied to the elements of `s` and `t` (denoted as `(f ∘ Subtype.val)`) respectively have sum `a` and `b` (`HasSum (f ∘ Subtype.val) a` and `HasSum (f ∘ Subtype.val) b`), then the series formed by applying `f` to all elements of `β` (the union of `s` and `t`) has sum `a + b`. It also assumes that the addition operation in `α` is continuous (`ContinuousAdd α`). In essence, this theorem is a statement about the sum of a disjoint partition of a series.

For any additive commutative monoid `α` that is a topological space, continuous addition, and functions `f : β -> α` from a type `β`, if `s` and `t` are complementary sets and `HasSum (f ∘ Subtype.val) a` and `HasSum (f ∘ Subtype.val) b` hold, then `HasSum (f) (a + b)`.


theorem AlgebraicTopology.NormalizedMooreComplex.map.proof_1 :
    ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Abelian C]
      {X Y : CategoryTheory.SimplicialObject C} (f : X ⟶ Y) (n : ℕ),
      CategoryTheory.Subobject.Factors (AlgebraicTopology.NormalizedMooreComplex.objX Y n)
        (CategoryTheory.CategoryStruct.comp
          (CategoryTheory.Subobject.arrow (AlgebraicTopology.NormalizedMooreComplex.objX X n))
          (f.app (Opposite.op (SimplexCategory.mk n)))) :=
  by sorry

This theorem states that for any category `C` which is an Abelian category, and for any `X` and `Y` which are simplicial objects in `C`, given a morphism `f` from `X` to `Y` and a natural number `n`, there exists a factorisation of the composition `(CategoryTheory.Subobject.arrow (AlgebraicTopology.NormalizedMooreComplex.objX X n))` and `(f.app (Opposite.op (SimplexCategory.mk n)))` through the `n`-th object of the normalized Moore complex of `Y`. In simple terms, it means the arrow from the `n`-th object of the normalized Moore complex of `X` followed by the `n`-th map of `f` factors through the `n`-th object of the normalized Moore complex of `Y`.

For any Abelian category `C`, given simplicial objects `X` and `Y` and a morphism `f : X → Y`, there exists a factorization through the `n`-th object of the normalized Moore complex of `Y` for each natural number `n`, of the composition of the `n`-th map of `f` with the arrow from the `n`-th object of the normalized Moore complex of `X`.


theorem Array.size_extract_loop :
    ∀ {α : Type u_1} (as bs : Array α) (size start : ℕ),
      Array.size (Array.extract.loop as size start bs) = Array.size bs + min size (Array.size as - start) :=
  by sorry

The theorem `Array.size_extract_loop` states that for any type `α`, arrays `as` and `bs`, and natural numbers `size` and `start`, the size of the array resulting from the `Array.extract.loop` operation on `as` with parameters `size` and `start` and initial array `bs` is equal to the size of `bs` plus the minimum of `size` and the difference between the size of `as` and `start`. In other words, it describes how the size of the output array is determined in the `Array.extract.loop` operation.

The size of the array obtained by extracting `min (size : nat) (length as - start)` elements from array `as` starting at position `start` using `Array.extract.loop`, is equal to the length of the initial array `bs` plus the extracted number of elements.


/-- A version of `ne_iff_lt_or_gt` with LHS and RHS reversed.  -/
theorem lt_or_lt_iff_ne : ∀ {α : Type u} [inst : LinearOrder α] {x y : α}, x < y ∨ y < x ↔ x ≠ y := by sorry

This theorem, `lt_or_lt_iff_ne`, states that for any type `α` that has a linear order, and for any two elements `x` and `y` of this type, the assertion that `x` is less than `y` or `y` is less than `x` is equivalent to `x` not being equal to `y`. This theorem essentially captures the fact that in a linear order, two elements are unequal if and only if one of them is strictly less than the other.

In a linear order, `x` is less than `y` or `y` is less than `x` if and only if `x` is not equal to `y`.


theorem MvPolynomial.rename_monomial :
    ∀ {σ : Type u_1} {τ : Type u_2} {R : Type u_4} [inst : CommSemiring R] (f : σ → τ) (d : σ →₀ ℕ) (r : R),
      (MvPolynomial.rename f) ((MvPolynomial.monomial d) r) = (MvPolynomial.monomial (Finsupp.mapDomain f d)) r :=
  by sorry

The theorem `MvPolynomial.rename_monomial` states that for any commutative semiring `R`, any function `f` from type `σ` to type `τ`, any finitely supported function `d` from type `σ` to natural numbers, and any element `r` of `R`, the operation of renaming the variables in the monomial given by `d` and `r` in the multivariable polynomial over `R` with variables of type `σ` using `f`, is the same as creating a monomial in the multivariable polynomial over `R` with variables of type `τ` whose exponents are given by the finitely supported function obtained by mapping the domain of `d` using `f`, and whose coefficient is `r`. In other words, renaming the variables in a monomial is equivalent to creating a new monomial with the variables renamed.

For any commutative semiring R, function f from type σ to τ, finitely supported function d from type σ to natural numbers, and element r of R, the operation of renaming variables in a multivariable polynomial over R using f and d is equivalent to creating a new monomial with variables from τ and corresponding exponents from the image of d under f, and coefficient r.


theorem Ne.ne_or_ne : ∀ {α : Sort u_2} {x y : α} (z : α), x ≠ y → x ≠ z ∨ y ≠ z := by sorry

This theorem, `Ne.ne_or_ne`, asserts that for any type `α` and any three elements `x`, `y`, and `z` of `α`, if `x` is not equal to `y`, then either `x` is not equal to `z`, or `y` is not equal to `z`. This is a basic property of inequality in any set or type, and can be used to reason about different elements in a type or set.

If `x ≠ y` in type `α`, then `x ≠ z` or `y ≠ z`.


theorem RingQuot.neg_quot :
    ∀ {R : Type uR} [inst : Ring R] (r : R → R → Prop) {a : R},
      -{ toQuot := Quot.mk (RingQuot.Rel r) a } = { toQuot := Quot.mk (RingQuot.Rel r) (-a) } :=
  by sorry

This theorem states that for any given ring `R` and binary relation `r` on `R`, the negation of a quotient ring element `{ toQuot := Quot.mk (RingQuot.Rel r) a }` is equal to the quotient ring element created by negating `a` first `{ toQuot := Quot.mk (RingQuot.Rel r) (-a) }`. In simpler terms, the negation operation can be performed either before or after creating the quotient ring element, yielding the same result.

For any ring `R` and binary relation `r`, the negation of a quotient ring element `{toQuot := Quot.mk (RingQuot.Rel r) a}` is equal to the quotient ring element created by negating `a` first, i.e., `{toQuot := Quot.mk (RingQuot.Rel r) (-a)}`.


theorem measurable_of_isOpen :
    ∀ {γ : Type u_3} {δ : Type u_5} [inst : TopologicalSpace γ] [inst_1 : MeasurableSpace γ] [inst_2 : BorelSpace γ]
      [inst_3 : MeasurableSpace δ] {f : δ → γ}, (∀ (s : Set γ), IsOpen s → MeasurableSet (f ⁻¹' s)) → Measurable f :=
  by sorry

The theorem `measurable_of_isOpen` states that for any types `γ` and `δ`, where `γ` is equipped with a topological space structure, a measurable space structure, and a Borel space structure, and `δ` is equipped with a measurable space structure, for any function `f` from `δ` to `γ`, if the preimage of every open set under `f` is measurable, then `f` itself is a measurable function. In mathematical terms, this means that if for all open sets `s` in `γ`, `f`−1(`s`) is a measurable set in `δ`, then `f` is measurable with respect to the given measurable spaces on `δ` and `γ`.

If the preimage of every open set under a function from a measurable space with a Borel space structure to a topological space with a measurable space structure is measurable, then the function is measurable.


theorem Mathlib.Order.Filter.Prod._auxLemma.8 :
    ∀ {α : Type u} {β : Type v} {f : Filter α} {m : α → β} {t : Set β}, (t ∈ Filter.map m f) = (m ⁻¹' t ∈ f) := by sorry

This theorem, named `Mathlib.Order.Filter.Prod._auxLemma.8`, states that for any types `α` and `β`, any filter `f` on `α`, any function `m` from `α` to `β`, and any set `t` of elements of type `β`, the set `t` is in the image of the filter `f` under the function `m` if and only if the preimage of `t` under `m` is in the filter `f`. In other words, it provides a criterion for a set to be in the image of a filter under a function: it is in the image if and only if its preimage is in the original filter.

For any filter \(f\) on type \(\alpha\), function \(m:\alpha \rightarrow \beta\), and set \(t \subseteq \beta\), \(t\) is in the image of \(f\) under \(m\) if and only if \(m^{-1}(t) \in f\).


/-- The sheaf condition in terms of an equalizer diagram is equivalent
to the reformulation in terms of a limit diagram over `U i` and `U i ⊓ U j`.
 -/
theorem TopCat.Presheaf.isSheaf_iff_isSheafPairwiseIntersections :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X : TopCat} (F : TopCat.Presheaf C X),
      TopCat.Presheaf.IsSheaf F ↔ TopCat.Presheaf.IsSheafPairwiseIntersections F :=
  by sorry

The theorem `TopCat.Presheaf.isSheaf_iff_isSheafPairwiseIntersections` states that for any category `C`, any topological space `X` in the category of topological spaces (`TopCat`), and any `C`-valued presheaf `F` on `X`, the condition of `F` being a sheaf is equivalent to `F` satisfying the sheaf condition for pairwise intersections. In other words, a presheaf is a sheaf if and only if, whenever we take the limit over an open set `U i` and its intersection with another open set `U j`, the presheaf satisfies the sheaf condition.

A presheaf on a topological space is a sheaf if and only if it satisfies the sheaf condition for pairwise intersections.


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

This theorem states that in any category `C` of a certain type `u`, which has a structure of a NonPreadditiveAbelian category, given four morphisms `a`, `b`, `c`, and `d` from object `X` to object `Y`, the equality `a - c - (b - d) = a - b - (c - d)` holds. In mathematical terms, this corresponds to the property that subtraction of morphisms in a NonPreadditiveAbelian category is associative and satisfies the specific rearrangement of terms specified by the equation.

In any NonPreadditive Abelian category, the subtraction of morphisms is associative: `a - c - (b - d) = a - b - (c - d)`.


theorem Polynomial.coeff_hermite_succ_succ :
    ∀ (n k : ℕ),
      Polynomial.coeff (Polynomial.hermite (n + 1)) (k + 1) =
        Polynomial.coeff (Polynomial.hermite n) k - (↑k + 2) * Polynomial.coeff (Polynomial.hermite n) (k + 2) :=
  by sorry

The theorem `Polynomial.coeff_hermite_succ_succ` states that for all natural numbers `n` and `k`, the coefficient of the term `X^(k+1)` in the (n+1)-th Hermite polynomial equals the coefficient of the term `X^k` in the n-th Hermite polynomial minus the product of the real number `k+2` and the coefficient of the term `X^(k+2)` in the n-th Hermite polynomial. This essentially provides a recursive formula to calculate the coefficients of the terms in the Hermite polynomials.

The coefficient of `X^(k+1)` in the (n+1)-th Hermite polynomial is equal to the coefficient of `X^k` in the n-th Hermite polynomial minus (k+2) times the coefficient of `X^(k+2)` in the n-th Hermite polynomial.


theorem Real.Angle.sin_toReal : ∀ (θ : Real.Angle), Real.sin (Real.Angle.toReal θ) = Real.Angle.sin θ := by sorry

This theorem states that for every angle `θ` of type `Real.Angle`, the real sine of its corresponding real number (which lies in the interval (-π, π)) equals to the sine of the angle `θ` itself. In other words, the function `Real.sin` applied to the real number equivalent of the angle (calculated using `Real.Angle.toReal`) gives the same result as the function `Real.Angle.sin` applied to the angle directly.

For every angle `θ`, the real value `Real.sin (Real.Angle.toReal θ)` equals `Real.Angle.sin θ`.


theorem Int.ofNat_natAbs_of_nonpos : ∀ {a : ℤ}, a ≤ 0 → ↑(Int.natAbs a) = -a := by sorry

The theorem `Int.ofNat_natAbs_of_nonpos` states that for any integer `a` which is less than or equal to zero, the absolute value (represented as a natural number) of `a` when converted back to an integer equals the negative of `a`. In other words, for any non-positive integer, its absolute value behaves as if we removed the negative sign, and this relationship holds when we convert this absolute value back to an integer.

For any integer `a`, if `a` is non-positive, then |a| = -a.


/-- A locally compact normed vector space is proper.  -/
theorem ProperSpace.of_locallyCompactSpace :
    ∀ (𝕜 : Type u_1) [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : SeminormedAddCommGroup E]
      [inst : NormedSpace 𝕜 E] [inst : LocallyCompactSpace E], ProperSpace E :=
  by sorry

This theorem states that a locally compact normed vector space is proper. Specifically, for any nontrivial normed field `𝕜` and any type `E` that forms a seminormed additive commutative group as well as a normed space over `𝕜` and is locally compact, `E` is a proper space. In mathematics, a proper space is a space where every closed ball is compact. This theorem thus connects the notions of local compactness and properness in the context of vector spaces.

A locally compact normed vector space is a proper space, i.e., every closed ball is compact.


FreeAddGroup.map.comp

theorem FreeAddGroup.map.comp :
    ∀ {α : Type u} {β : Type v} {γ : Type w} (f : α → β) (g : β → γ) (x : FreeAddGroup α),
      (FreeAddGroup.map g) ((FreeAddGroup.map f) x) = (FreeAddGroup.map (g ∘ f)) x :=
  by sorry

This theorem states that for any three types `α`, `β`, and `γ`, and any two functions `f` from `α` to `β` and `g` from `β` to `γ`, the composition of the two functions `g ∘ f` (meaning first apply `f`, then apply `g` to the result) behaves the same as first mapping with `f` and then mapping the result with `g`, for any element `x` of the free additive group over `α`. In other words, the `FreeAddGroup.map` function respects function composition, making it a functor in the category theory sense.

For any functions `f: α → β` and `g: β → γ`, the function composition `g ∘ f` equals the function `FreeAddGroup.map g ∘ FreeAddGroup.map f` when mapping elements of the free additive group over `α`.


theorem mul_inv_le_iff_le_mul :
    ∀ {α : Type u} [inst : Group α] [inst_1 : LE α]
      [inst_2 : CovariantClass α α (Function.swap fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1] {a b c : α},
      a * b⁻¹ ≤ c ↔ a ≤ c * b :=
  by sorry

This theorem, `mul_inv_le_iff_le_mul`, states that for any type `α` that forms a group and has a defined less than or equal to (`≤`) operation, and a certain covariance property, for any three elements `a`, `b`, and `c` of `α`, the statement "the product of `a` and the inverse of `b` is less than or equal to `c`" is equivalent to " `a` is less than or equal to the product of `c` and `b`."

For any group type `α` with a `≤` operation satisfying a covariance property, `a ≤ c * b` if and only if `a * b^(-1) ≤ c`.


theorem exists_dist_eq :
    ∀ {E : Type u_2} [inst : SeminormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] (x z : E) {a b : ℝ},
      0 ≤ a → 0 ≤ b → a + b = 1 → ∃ y, dist x y = b * dist x z ∧ dist y z = a * dist x z :=
  by sorry

This theorem states that for any types `E` that form a seminormed additive commutative group and a normed space over the real numbers, given any two elements `x` and `z` of this type and any two non-negative real numbers `a` and `b` such that `a + b = 1`, there exists an element `y` in `E` such that the distance between `x` and `y` is equal to `b` times the distance between `x` and `z`, and the distance between `y` and `z` is equal to `a` times the distance between `x` and `z`.

Given a seminormed additive commutative group `E` over the real numbers, for any `x`, `z` in `E` and `a`, `b` in `ℝ+` with `a + b = 1`, there exists `y` in `E` such that `||x - y|| = b * ||x - z||` and `||y - z|| = a * ||x - z||`.


theorem Matrix.adjugate_subsingleton :
    ∀ {n : Type v} {α : Type w} [inst : DecidableEq n] [inst_1 : Fintype n] [inst_2 : CommRing α]
      [inst_3 : Subsingleton n] (A : Matrix n n α), Matrix.adjugate A = 1 :=
  by sorry

This theorem states that for any type `n`, type `α`, any instance of decidable equality on `n`, any instance indicating `n` is finite, any instance of a commutative ring defined on `α`, and any instance proving `n` is a subsingleton (meaning it has at most one element), the adjugate of a matrix `A` of type `Matrix n n α` (which is a matrix with entries in `α`, whose rows and columns are indexed by `n`) is the identity matrix. In mathematical terms, if we have a matrix `A` derived from a commutative ring and `n` is a set with at most one element, then the adjugate of `A` is the identity matrix.

For any finite, subsingleton type `n` and commutative ring `α`, the adjugate of a matrix `A` of size `n x n` over `α` is the identity matrix.


theorem beq_false_of_ne : ∀ {α : Type u_1} [inst : BEq α] [inst_1 : LawfulBEq α] {a b : α}, a ≠ b → (a == b) = false :=
  by sorry

This theorem, `beq_false_of_ne`, states that for any type `α`, that has an instance of binary equality (`BEq`) and this binary equality is lawful (`LawfulBEq`), if two elements `a` and `b` of type `α` are not equal, then the result of the binary equality test (`a == b`) will be `false`. Essentially, it says that if two objects are not equal, their binary equality test result is `false`.

For any type `α` with lawful equality `BEq α`, if `a ≠ b` then `a == b` holds false.


theorem Cardinal.aleph0_mul_eq : ∀ {a : Cardinal.{u_1}}, Cardinal.aleph0 ≤ a → Cardinal.aleph0 * a = a := by sorry

The theorem `Cardinal.aleph0_mul_eq` states that for any cardinal number `a`, if `a` is greater than or equal to `ℵ₀` (the smallest infinite cardinal), then the product of `ℵ₀` and `a` is equal to `a`. This reflects the property of infinite cardinals where multiplication does not increase the cardinality.

For any cardinal number `a` greater than or equal to `ℵ₀`, the product of `ℵ₀` and `a` equals `a`.


theorem Mathlib.MeasureTheory.Function.L1Space._auxLemma.14 :
    ∀ {α : Type u_1} {β : Type u_2} [inst : NormedAddCommGroup β] [inst_1 : Finite α] [inst_2 : MeasurableSpace α]
      [inst_3 : MeasurableSingletonClass α] (μ : MeasureTheory.Measure α) [inst_4 : MeasureTheory.IsFiniteMeasure μ]
      (f : α → β), MeasureTheory.Integrable (fun a => f a) μ = True :=
  by sorry

The theorem `Mathlib.MeasureTheory.Function.L1Space._auxLemma.14` states that for any types `α` and `β`, where `β` is a normed add commutative group, `α` has a finite number of elements and a measurable singleton class, and for any measure `μ` on `α` which is finite, any function `f` from `α` to `β` is integrable. In other words, if a function `f` maps from a finite measurable space `α` to a normed add commutative group `β` and we have a finite measure `μ`, then the function `f` is always integrable with respect to the measure `μ`. This underlines the fact that integrability is a property that always holds when our domain is finite.

A function from a finite measurable space to a normed add commutative group is integrable with respect to any finite measure.


theorem Isometry.preimage_ball :
    ∀ {α : Type u} {β : Type v} [inst : PseudoMetricSpace α] [inst_1 : PseudoMetricSpace β] {f : α → β},
      Isometry f → ∀ (x : α) (r : ℝ), f ⁻¹' Metric.ball (f x) r = Metric.ball x r :=
  by sorry

This theorem states that for any two pseudo-metric spaces `α` and `β`, and any function `f` from `α` to `β` that is an isometry, the pre-image under `f` of the open ball in `β` centered at `f(x)` with radius `r` is exactly the open ball in `α` centered at `x` with the same radius `r`. In other words, if you take a point `x` in `α` and consider the open ball around `x` in `α`, then apply the isometry `f` which maps this ball to a ball in `β`, if you then take the inverse image of this latter ball under `f`, you end up with the original ball in `α`. This is a consequence of the defining property of isometries that they preserve distances.

For any isometry `f` between pseudo-metric spaces `α` and `β` and any point `x` in `α`, the pre-image under `f` of the open ball in `β` centered at `f(x)` with radius `r` is the open ball in `α` centered at `x` with radius `r`.


theorem Mathlib.MeasureTheory.Function.L1Space._auxLemma.12 :
    ∀ {α : Type u_1} [inst : Lattice α] [inst_1 : AddGroup α] (a : α), (a ≤ |a|) = True := by sorry

This theorem, `Mathlib.MeasureTheory.Function.L1Space._auxLemma.12`, states that for any type `α` that has a Lattice structure and an AddGroup structure, any element `a` of this type satisfies the property that `a` is less than or equal to the absolute value of `a`. This is always true, as indicated by the result `True`. In mathematical notation, this can be written as $a \leq |a|$.

For any type `α` with Lattice and AddGroup structures, every element `a` satisfies the inequality `|a| ≥ a`. Thus, `a ≤ |a|`.


theorem Monotone.map_sup :
    ∀ {α : Type u} {β : Type v} [inst : LinearOrder α] [inst_1 : SemilatticeSup β] {f : α → β},
      Monotone f → ∀ (x y : α), f (x ⊔ y) = f x ⊔ f y :=
  by sorry

The theorem `Monotone.map_sup` states that for any types `α` and `β`, given a linear order on `α`, a semilattice sup (supremum) structure on `β`, and a function `f` from `α` to `β`, if `f` is a monotone function, then for all elements `x` and `y` of `α`, the image under `f` of the supremum of `x` and `y` (`x ⊔ y`) is equal to the supremum of the images under `f` of `x` and `y` (`f x ⊔ f y`). This theorem is essentially saying that a monotone function preserves the operation of taking supremum.

If `f` is a monotone function from a type `α` equipped with a linear order and a supremum structure to a semilattice sup type `β`, then `f (x ⊔ y) = f x ⊔ f y` for all `x, y ∈ α`.


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

This theorem states that for any type `α` and `β`, a measurable space `m` over `α`, a measure `μ` on that measurable space, and a function `f` from `α` to `β` that is almost everywhere strongly measurable with respect to `μ`, the function `f` is integrable (in the sense of `MeasureTheory.AEEqFun.Integrable`) if and only if it is integrable in the sense of `MeasureTheory.Integrable`. In other words, the equivalence class `[f]` of almost everywhere equal functions is integrable if and only if its representative function `f` is integrable. This connects the concept of integrability for almost everywhere equal functions and the more general concept of integrability.

For any measurable spaces `α` and `β`, measure `μ` on `α`, almost everywhere strongly measurable function `f` from `α` to `β`, and integrals `∫` and `∫'` denoting integration with respect to `μ` on `α` and almost everywhere equal functions respectively, `f` is `∫'-integrable` if and only if `f` is `∫-integrable`.


theorem Polynomial.adjoin_rootSet_eq_range :
    ∀ {R : Type u_1} {K : Type v} {L : Type w} [inst : CommRing R] [inst_1 : Field K] [inst_2 : Field L]
      [inst_3 : Algebra R K] [inst_4 : Algebra R L] {p : Polynomial R},
      Polynomial.Splits (algebraMap R K) p →
        ∀ (f : K →ₐ[R] L),
          Algebra.adjoin R (Polynomial.rootSet p L) = AlgHom.range f ↔ Algebra.adjoin R (Polynomial.rootSet p K) = ⊤ :=
  by sorry

The theorem `Polynomial.adjoin_rootSet_eq_range` states that for any commutative rings `R`, `K`, and `L` with `K` and `L` being fields and `R` being an algebra over both `K` and `L`, and for any polynomial `p` over `R` that splits over `K`, for any algebra homomorphism `f` from `K` to `L`, the subalgebra of `L` generated by the set of roots of `p` in `L` is the range of `f` if and only if the subalgebra of `K` generated by the set of roots of `p` in `K` is the entire space `K`. In other words, the roots of a polynomial in a field generate the whole field if and only if they generate the entire range of any algebra homomorphism from that field to another.

For a polynomial `p` over a commutative ring `R` that splits over fields `K` and `L`, the subalgebras of `L` generated by the roots of `p` in `L` and of `K` generated by the roots of `p` in `K` are equal if and only if the latter is the entire field `K`.


theorem HasFDerivAtFilter.congr_of_eventuallyEq :
    ∀ {𝕜 : 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 f₁ : E → F} {f' : E →L[𝕜] F} {x : E} {L : Filter E},
      HasFDerivAtFilter f f' x L → f₁ =ᶠ[L] f → f₁ x = f x → HasFDerivAtFilter f₁ f' x L :=
  by sorry

This theorem states that for any nontrivially normed field `𝕜`, normed add commutative groups `E` and `F` with `E` and `F` being normed spaces over `𝕜`, two functions `f` and `f₁` from `E` to `F`, a continuous linear map `f'` from `E` to `F`, a point `x` in `E`, and a filter `L` on `E`, if `f` has a derivative at `x` with respect to filter `L`, and if `f₁` is eventually equal to `f` at filter `L` and `f₁` at `x` is equal to `f` at `x`, then `f₁` also has a derivative at `x` with respect to filter `L`. This theorem is essentially about the continuity of the derivative under certain conditions.

If `f` and `f₁` are functions from a normed space `E` to another normed space `F` over a nontrivially normed field, `f` is continuously linear and has a derivative at `x` in `E` with respect to filter `L`, and `f₁` is eventually equal to `f` at filter `L` and `f₁(x) = f(x)`, then `f₁` has a derivative at `x` with respect to filter `L`.


theorem PEquiv.symm_injective : ∀ {α : Type u} {β : Type v}, Function.Injective PEquiv.symm := by sorry

The theorem `PEquiv.symm_injective` states that for any two types `α` and `β`, the function `PEquiv.symm`, which takes a partial equivalence from `α` to `β` and returns its inverse partial equivalence from `β` to `α`, is injective. In other words, if two partial equivalences from `α` to `β` have the same inverse partial equivalence, then they must have been the same partial equivalence to begin with.

If two partial equivalences from type `α` to type `β` have the same inverse, then they are equal.


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

The theorem `Ordinal.limitRecOn_limit` states that for any type C indexed by ordinals, any ordinal `o`, and any functions `H₁`, `H₂`, and `H₃` defined appropriately, if `o` is a limit ordinal, then performing the limit ordinal recursion on `o` using `H₁`, `H₂`, and `H₃` is the same as applying `H₃` to `o`, the fact that `o` is a limit ordinal, and the recursion on all ordinals less than `o`.

In other words, this theorem guarantees the correctness of the limit case for a general recursive definition on ordinals, stating that when the recursion reaches a limit ordinal, it behaves as expected; it applies the limit case function `H₃` to the current ordinal and the results of the recursion on all smaller ordinals.

For any type indexed by ordinals, if a limit ordinal `o` and functions `H₁`, `H₂`, and `H₃` are given, then limit recursion on `o` using `H₁`, `H₂`, and `H₃` equals `H₃(o)` concatenated with the results of recursively applying `H₃` to all ordinals less than `o`.


theorem MulAction.orbit_smul :
    ∀ {G : Type u_1} {α : Type u_2} [inst : Group G] [inst_1 : MulAction G α] (g : G) (a : α),
      MulAction.orbit G (g • a) = MulAction.orbit G a :=
  by sorry

The theorem `MulAction.orbit_smul` asserts that for any group `G` and any type `α` that `G` acts on, the orbit under the action of `G` of the result of the action of any element of `G` on any element of `α` is the same as the orbit of the original element of `α`. In simpler terms, if a group element `g` acts on an element `a`, the set of all possible results you can get by letting any element of the group act on `g • a` is the same as the set of all results you can get by letting any group element act on `a`. This is a statement about the invariance of the orbit under the action of the group.

For any group action on a type `α`, the orbit of `g • a` is equal to the orbit of `a` for all `g` in the group.


/-- This lemma is useful for working with the `intDegree` of a rational function.  -/
theorem Polynomial.natDegree_sub_eq_of_prod_eq :
    ∀ {R : Type u} [inst : Semiring R] [inst_1 : NoZeroDivisors R] {p₁ p₂ q₁ q₂ : Polynomial R},
      p₁ ≠ 0 →
        q₁ ≠ 0 →
          p₂ ≠ 0 →
            q₂ ≠ 0 →
              p₁ * q₂ = p₂ * q₁ →
                ↑(Polynomial.natDegree p₁) - ↑(Polynomial.natDegree q₁) =
                  ↑(Polynomial.natDegree p₂) - ↑(Polynomial.natDegree q₂) :=
  by sorry

This theorem states that for any type `R` with a semiring structure and no zero divisors, and for any non-zero polynomials `p₁`, `p₂`, `q₁`, and `q₂` over `R`, if `p₁ * q₂` equals `p₂ * q₁`, then the difference between the 'natural degree' of `p₁` and `q₁` (i.e., `Polynomial.natDegree p₁ - Polynomial.natDegree q₁`) is equal to the difference between the 'natural degree' of `p₂` and `q₂` (i.e., `Polynomial.natDegree p₂ - Polynomial.natDegree q₂`).

Here, the 'natural degree' of a polynomial is a concept that generalizes the degree of a polynomial. For the zero polynomial, its 'natural degree' is defined to be zero. For a non-zero polynomial, its 'natural degree' is the degree of the polynomial.

For polynomials $p\_1, p\_2, q\_1,$ and $q\_2$ over a semiring $R$ without zero divisors, if $p\_1 \cdot q\_2 = p\_2 \cdot q\_1$, then $\text{deg}(p\_1) - \text{deg}(q\_1) = \text{deg}(p\_2) - \text{deg}(q\_2)$, where $\text{deg}$ denotes the natural degree.


theorem not_lt_zero' : ∀ {α : Type u_1} [inst : LinearOrderedCommMonoidWithZero α] {a : α}, ¬a < 0 := by sorry

This theorem states that for any type `α` that is a linear ordered commutative monoid with zero, no element `a` of that type can be less than zero. In other words, in any such structure, zero is the smallest element.

In any linear ordered commutative monoid with zero, zero is the smallest element.


theorem CategoryTheory.ShortComplex.rightHomologyMap_id :
    ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
      (S : CategoryTheory.ShortComplex C) [inst_2 : CategoryTheory.ShortComplex.HasRightHomology S],
      CategoryTheory.ShortComplex.rightHomologyMap (CategoryTheory.CategoryStruct.id S) =
        CategoryTheory.CategoryStruct.id (CategoryTheory.ShortComplex.rightHomology S) :=
  by sorry

This theorem, `CategoryTheory.ShortComplex.rightHomologyMap_id`, states that for any category `C` that has zero morphisms, and any short complex `S` in this category that has a right homology, the right homology map applied to the identity morphism of `S` is equal to the identity morphism of the right homology of `S`. In other words, the right homology map preserves identity morphisms in the category of short complexes.

For any short complex `S` in a zero-morphism category `C` with right homology, the right homology map of the identity morphism of `S` equals the identity morphism of `S`'s right homology.


theorem MeasureTheory.IsAddFundamentalDomain.nullMeasurableSet_vadd :
    ∀ {G : Type u_1} {α : Type u_3} [inst : AddGroup G] [inst_1 : AddAction G α] [inst_2 : MeasurableSpace α]
      {s : Set α} {μ : MeasureTheory.Measure α} [inst_3 : MeasurableSpace G] [inst_4 : MeasurableVAdd G α]
      [inst_5 : MeasureTheory.VAddInvariantMeasure G α μ],
      MeasureTheory.IsAddFundamentalDomain G s μ → ∀ (g : G), MeasureTheory.NullMeasurableSet (g +ᵥ s) μ :=
  by sorry

The theorem `MeasureTheory.IsAddFundamentalDomain.nullMeasurableSet_vadd` states that for any type `G` (which forms an additive group) and any type `α` (which has a measurable space structure and on which `G` acts additively), if we have a set `s` in `α` that is an additive fundamental domain under measure `μ` (which is `VAddInvariantMeasure`), then for every element `g` in `G`, the translate of the set `s` by `g` is a null measurable set under the same measure `μ`. Here, a set being null measurable means it can be approximated by a measurable set up to a set of null measure.

For any additive group G acting additively on a measurable space (α, μ) with VAddInvariantMeasure μ, an additive fundamental domain s in α is null measurable for every translate g \* s.


/-- `m` is not divisible by `n` if it is between `n * k` and `n * (k + 1)` for some `k`.  -/
theorem Nat.not_dvd_of_between_consec_multiples : ∀ {m n k : ℕ}, n * k < m → m < n * (k + 1) → ¬n ∣ m := by sorry

This theorem states that for any natural numbers `m`, `n`, and `k`, if `m` is strictly greater than the product of `n` and `k` and strictly less than the product of `n` and `k + 1`, then `n` does not divide `m`. Essentially, the theorem is saying that if `m` is between two consecutive multiples of `n`, it cannot be divisible by `n`.

If natural numbers `m`, `n`, and `k` satisfy `n * k < m < n * (k + 1)`, then `n` does not divide `m`.


theorem FirstOrder.Language.elementarilyEquivalent_iff :
    ∀ {L : FirstOrder.Language} {M : Type w} {N : Type u_1} [inst : FirstOrder.Language.Structure L M]
      [inst_1 : FirstOrder.Language.Structure L N],
      FirstOrder.Language.ElementarilyEquivalent L M N ↔ ∀ (φ : FirstOrder.Language.Sentence L), M ⊨ φ ↔ N ⊨ φ :=
  by sorry

The theorem `FirstOrder.Language.elementarilyEquivalent_iff` states that for any first-order language `L` and any two structures `M` and `N` of `L`, `M` and `N` are elementarily equivalent if and only if they satisfy the same sentences of `L`. Here, a sentence is defined as a formula with no free variables, and a structure is said to satisfy a sentence if the sentence holds true under an interpretation in that structure. Essentially, this theorem is reflecting the fact that two structures are identical in the language if they agree on all sentences of the language.

Two first-order structures of the same language are elementarily equivalent if and only if they satisfy the same sentences in that language.


/-- Every equalizer of `(f, g)`, where `f = g`, is an isomorphism.  -/
theorem CategoryTheory.Limits.isIso_limit_cone_parallelPair_of_eq :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} {f g : X ⟶ Y},
      f = g →
        ∀ {c : CategoryTheory.Limits.Fork f g},
          CategoryTheory.Limits.IsLimit c → CategoryTheory.IsIso (CategoryTheory.Limits.Fork.ι c) :=
  by sorry

The theorem `CategoryTheory.Limits.isIso_limit_cone_parallelPair_of_eq` states that in any category `C`, given objects `X` and `Y` and morphisms `f` and `g` from `X` to `Y`, if `f` equals `g`, then for any fork `c` on `f` and `g` (i.e., a cone over the parallel pair of `f` and `g`), if `c` is a limit cone, then the natural inclusion of `c` (denoted `CategoryTheory.Limits.Fork.ι c`) is an isomorphism. In other words, if `f` and `g` are the same morphism, then every limit of the fork on `f` and `g` is isomorphic to the initial object of the category.

In a category, if two morphisms from one object to another are equal and have a limit cone, then the inclusion of that cone is an isomorphism.


theorem Filter.eventually_const :
    ∀ {α : Type u} {f : Filter α} [t : Filter.NeBot f] {p : Prop}, (∀ᶠ (x : α) in f, p) ↔ p := by sorry

This theorem, `Filter.eventually_const`, states that for any type `α` and a filter `f` of `α` that is not a bottom filter (i.e., it is not the empty set), given a proposition `p`, the proposition `p` is eventually true for every element in the filter `f` if and only if `p` is true. This means that if `p` is true, then there exists a point beyond which all elements of the filter satisfy `p`, and conversely, if there exists a point beyond which all elements of the filter satisfy `p`, then `p` is true.

For any filter `f` on type `α` that is not bottom and proposition `p`, `p` is eventually true for all elements in `f` if and only if `p` holds.


theorem SimpleGraph.Walk.verts_toSubgraph :
    ∀ {V : Type u} {G : SimpleGraph V} {u v : V} (p : SimpleGraph.Walk G u v),
      (SimpleGraph.Walk.toSubgraph p).verts = {w | w ∈ SimpleGraph.Walk.support p} :=
  by sorry

This theorem states that for any type `V`, any simple graph `G` of type `V`, and any two vertices `u` and `v` of type `V`, for any walk `p` from `u` to `v` in graph `G`, the set of vertices of the subgraph generated by the walk `p` is exactly the set of vertices that the walk `p` visits in order. In other words, when you take a walk `p` in a graph `G`, and then consider the subgraph of `G` that includes just the vertices and edges involved in that walk, the vertices of this subgraph are precisely the ones that appear in the support of the walk `p`.

For any simple graph `G` and walk `p` in `G`, the subgraph generated by `p` consists exactly of the vertices visited in order by `p`.


theorem Int.natAbs_lt_natAbs_of_nonneg_of_lt : ∀ {a b : ℤ}, 0 ≤ a → a < b → Int.natAbs a < Int.natAbs b := by sorry

The theorem `Int.natAbs_lt_natAbs_of_nonneg_of_lt` states that for any two integers `a` and `b`, if `a` is nonnegative (i.e., `a` is greater than or equal to 0) and `a` is less than `b`, then the absolute value of `a` is less than the absolute value of `b`. Here the absolute value of an integer is defined by the function `Int.natAbs`, which is the non-negative equivalent of the integer.

For any integers `a` and `b`, if `a` is non-negative and `a` is strictly less than `b`, then `|a| < |b|`, where `|.|` denotes the absolute value function.


theorem mem_emetric_ball_zero_iff :
    ∀ {E : Type u_6} [inst : SeminormedAddGroup E] {a : E} {r : ENNReal}, a ∈ EMetric.ball 0 r ↔ ↑‖a‖₊ < r := by sorry

This theorem states that for any type `E` that forms a semi-normed additive group and any element `a` of `E` and `r` of type `ENNReal` (the extended nonnegative real numbers), `a` is in the `EMetric.ball` centered at 0 with radius `r` if and only if the semi-norm of `a` is less than `r`. In mathematical terms, it means that a point `a` lies within the open ball with radius `r` in a semi-normed additive group if and only if the semi-norm of `a` is less than `r`.

For any semi-normed additive group `E` and element `a` in `E` and real number `r` > 0, `a` lies in the open ball of radius `r` if and only if the semi-norm of `a` is less than `r`.


Flow.continuous

theorem Flow.continuous :
    ∀ {τ : Type u_1} [inst : AddMonoid τ] [inst_1 : TopologicalSpace τ] [inst_2 : ContinuousAdd τ] {α : Type u_2}
      [inst_3 : TopologicalSpace α] (ϕ : Flow τ α) {β : Type u_3} [inst_4 : TopologicalSpace β] {t : β → τ},
      Continuous t → ∀ {f : β → α}, Continuous f → Continuous fun x => ϕ.toFun (t x) (f x) :=
  by sorry

This theorem states that for any type `τ` with an addition operation and topological structure, and a continuous addition operation, and any type `α` with a topological structure, if `ϕ` is a Flow from `τ` to `α`, then for any type `β` with a topological structure and a function `t` from `β` to `τ`, if `t` is continuous and `f` is a continuous function from `β` to `α`, then the function that maps `x` in `β` to the result of applying `ϕ.toFun` to `t(x)` and `f(x)` is also continuous. Essentially, this theorem is about preserving continuity under the operations of the Flow.

Given types `τ` with addition, topology, and a continuous addition, `α` with topology, a continuous Flow `ϕ` from `τ` to `α`, a continuous function `t` from type `β` to `τ`, and a continuous function `f` from `β` to `α`, the function that maps `x` in `β` to `ϕ.toFun (t(x))` and `f(x)` is continuous.


NumberField.ComplexEmbedding.IsConj.eq

theorem NumberField.ComplexEmbedding.IsConj.eq :
    ∀ {K : Type u_1} [inst : Field K] {k : Type u_2} [inst_1 : Field k] [inst_2 : Algebra k K] {φ : K →+* ℂ}
      {σ : K ≃ₐ[k] K}, NumberField.ComplexEmbedding.IsConj φ σ → ∀ (x : K), φ (σ x) = star (φ x) :=
  by sorry

The theorem `NumberField.ComplexEmbedding.IsConj.eq` states that for any field `K` with a field `k` as its scalar field, given an embedding `φ` from `K` into the complex numbers `ℂ`, and a `k`-algebra isomorphism `σ` of `K` with itself, if `σ` is a conjugation under `φ`, then for any element `x` of `K`, the image of `σ(x)` under `φ` is the complex conjugate of the image of `x` under `φ`. In other words, applying the isomorphism and then the embedding is the same as applying the embedding and then taking the complex conjugate.

For any field extension `K/k` with complex embedding `φ` and `k`-algebra isomorphism `σ` of `K` as a conjugation under `φ`, `φ(σ(x)) = overline{φ(x)}` for all `x` in `K`.


theorem RatFunc.liftMonoidWithZeroHom_apply_ofFractionRing_mk :
    ∀ {G₀ : Type u_1} {R : Type u_3} [inst : CommGroupWithZero G₀] [inst_1 : CommRing R] (φ : Polynomial R →*₀ G₀)
      (hφ : nonZeroDivisors (Polynomial R) ≤ Submonoid.comap φ (nonZeroDivisors G₀)) (n : Polynomial R)
      (d : ↥(nonZeroDivisors (Polynomial R))),
      (RatFunc.liftMonoidWithZeroHom φ hφ) { toFractionRing := Localization.mk n d } = φ n / φ ↑d :=
  by sorry

This theorem states that for any commutative group with zero `G₀` and any commutative ring `R`, if there exists a monoid with zero homomorphism `φ` from the polynomials over `R` to `G₀` such that the set of non-zero divisors in the polynomials over `R` is a subset of the preimage under `φ` of the set of non-zero divisors in `G₀`, then for any polynomial `n` over `R` and any element `d` in the set of non-zero divisors of the polynomials over `R`, the application of the lift of the monoid with zero homomorphism `φ` to the fraction ring element represented by the ordered pair `(n, d)` equals to the ratio of the application of `φ` to `n` and the application of `φ` to `d`. In other words, we can lift the homomorphism `φ` to work with fractions of polynomials, and this lift behaves as expected on elements of the form `(n, d)`.

If `φ` is a monoid homomorphism from the polynomials over a commutative ring `R` to a commutative group with zero `G₀`, with the set of non-zero divisors in `R[X]` contained in the preimage of non-zero divisors in `G₀`, then `φ` extends to a homomorphism on the fraction ring of `R[X]`, preserving ratios of non-zero divisors.


theorem WittVector.ghostComponent_frobeniusFun :
    ∀ {p : ℕ} {R : Type u_1} [hp : Fact (Nat.Prime p)] [inst : CommRing R] (n : ℕ) (x : WittVector p R),
      (WittVector.ghostComponent n) (WittVector.frobeniusFun x) = (WittVector.ghostComponent (n + 1)) x :=
  by sorry

The theorem `WittVector.ghostComponent_frobeniusFun` states that for any prime number `p`, any commutative ring `R`, any natural number `n` and any Witt vector `x` in that ring, applying the `frobeniusFun` function to `x` and then evaluating the `n`th ghost component is equivalent to evaluating the `(n+1)`th ghost component of `x` directly. In other words, the action of the Frobenius function on a Witt vector effectively shifts the index of the ghost component by one.

For any prime number p, commutative ring R, natural number n, and Witt vector x in R, the n-th ghost component of the FrobeniusFun(x) equals the (n+1)-th ghost component of x.


/-- The nilpotency class of a nilpotent `G` is equal to the length of the lower central series.  -/
theorem lowerCentralSeries_length_eq_nilpotencyClass :
    ∀ {G : Type u_1} [inst : Group G] [hG : Group.IsNilpotent G], Nat.find ⋯ = Group.nilpotencyClass G := by sorry

The theorem states that for any nilpotent group `G`, the nilpotency class of `G` is equal to the length of the lower central series. In other words, the number of steps in the lower central series until reaching the whole group `G` is the same as the smallest natural number `n` for which the `n`-th term of the upper central series is `G` (the nilpotency class of `G`).

The nilpotency class of a nilpotent group equals the length of its lower central series.


theorem tsum_geometric_of_norm_lt_one :
    ∀ {K : Type u_4} [inst : NormedField K] {ξ : K}, ‖ξ‖ < 1 → ∑' (n : ℕ), ξ ^ n = (1 - ξ)⁻¹ := by sorry

The theorem `tsum_geometric_of_norm_lt_one` states that for any normed field `K` and any element `ξ` in `K` with a norm less than one, the infinite sum of `ξ` raised to the power of `n` over all `n` in natural numbers (which essentially forms a geometric series) is equal to `(1 - ξ)⁻¹` (i.e., the inverse of `1 - ξ`). This is a result from calculus known as the sum of an infinite geometric series, where the common ratio lies between -1 and 1.

For any normed field `K` and `ξ` in `K` with norm less than one, the infinite geometric series `∑(ξⁱ : ℕ) where i : ℕ, i != 0 := ξⁱ` equals `(1 - ξ)⁻¹`.


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

This theorem states that for any real number `x`, if `x` is greater than zero and `x` is not equal to one, then the real logarithm of `x` is not equal to zero. In other words, the log of any positive real number that is not one is always non-zero.

For any real number `x > 0` with `x ≠ 1`, the logarithm `log x` is non-zero.


theorem pow_right_strictMono' :
    ∀ {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]
      [inst_3 : CovariantClass M M (fun x x_1 => x * x_1) fun x x_1 => x < x_1] {a : M},
      1 < a → StrictMono fun x => a ^ x :=
  by sorry

The theorem `pow_right_strictMono'` asserts that for any type `M` which is a monoid and a preorder, and where the multiplication operation is covariant in both the less-than and less-than-or-equal-to relation, if `a` is an element of `M` such that `1 < a`, then the function that maps `x` to `a ^ x` is strictly monotone. In other words, if we have a monoid `M` that is also ordered and `a` is an element from `M` that is greater than 1, then for any two natural numbers `n` and `m`, if `n < m`, it implies that `a^n < a^m`.

For any monoid `M` with a covariant multiplication operation in a preorder, if `1 < a` in `M`, then the function `x => a ^ x` is strictly increasing.


theorem Set.disjoint_right : ∀ {α : Type u} {s t : Set α}, Disjoint s t ↔ ∀ ⦃a : α⦄, a ∈ t → a ∉ s := by sorry

This theorem states that for any type `α` and any sets `s` and `t` of type `α`, `s` and `t` are disjoint if and only if for all elements `a` in `t`, `a` is not in `s`. In other words, two sets are disjoint if there are no elements that are present in both sets, which is the classical definition of disjoint sets in set theory. In the context of this theorem, a set is defined as a collection of elements of a particular type that satisfy a certain property.

Two sets of the same type are disjoint if and only if none of their elements are common.