theorem CategoryTheory.ShortComplex.leftRightHomologyComparison'_fac :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
      {S : CategoryTheory.ShortComplex C} (h₁ : CategoryTheory.ShortComplex.LeftHomologyData S)
      (h₂ : CategoryTheory.ShortComplex.RightHomologyData S) [inst_2 : CategoryTheory.ShortComplex.HasHomology S],
      CategoryTheory.ShortComplex.leftRightHomologyComparison' h₁ h₂ =
        CategoryTheory.CategoryStruct.comp (CategoryTheory.ShortComplex.LeftHomologyData.homologyIso h₁).inv
          (CategoryTheory.ShortComplex.RightHomologyData.homologyIso h₂).hom :=
  by sorry

This theorem, `CategoryTheory.ShortComplex.leftRightHomologyComparison'_fac`, asserts that for any category `C` with zero morphisms and any short complex `S` within that category, given `LeftHomologyData` as `h₁` and `RightHomologyData` as `h₂` of `S`, and assuming that `S` has homology, the comparison of the left and right homology of `S` is equivalent to the composition of the inverse of the homology isomorphism for `h₁` and the homology isomorphism for `h₂`. In other words, the theorem provides a relationship between the left and right homologies of a short complex within a category.

Given a short complex `S` in a category with zero morphisms and homology, the comparison of its left and right homology isomorphisms is equivalent to the composition of the inverse of the left homology isomorphism with the right homology isomorphism.


theorem Rat.coe_int_num_of_den_eq_one : ∀ {q : ℚ}, q.den = 1 → ↑q.num = q := by sorry

This theorem states that for any rational number `q`, if the denominator of `q` is equal to `1`, then the numerator of `q` as an integer is equal to `q` itself. In other words, it ensures that when the denominator of a rational number is `1`, the rational number is essentially an integer.

For any rational number `q` with denominator `1`, its numerator is equal to `q`.


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

The theorem `hammingDist_eq_zero` asserts that for any finite type `ι`, any indexed type `β` such that for each `i : ι`, the type `β i` has decidable equality, and any two functions `x` and `y` mapping from `ι` to `β`, the Hamming distance between `x` and `y` is zero if and only if `x` and `y` are the same function. In other words, if the number of positions at which `x` and `y` output different values is zero, then `x` and `y` must be the same function.

For any finite type ι and indexed type β with decidable equality, two functions x and y from ι to β have Hamming distance zero if and only if they are equal as functions.


theorem MeasureTheory.Lp.coeFn_zero :
    ∀ {α : Type u_1} (E : Type u_2) {m0 : MeasurableSpace α} (p : ENNReal) (μ : MeasureTheory.Measure α)
      [inst : NormedAddCommGroup E], ↑↑0 =ᶠ[MeasureTheory.Measure.ae μ] 0 :=
  by sorry

This theorem, `MeasureTheory.Lp.coeFn_zero`, states that for any type `α`, any normed additively commutative group `E`, any measurable space `m0` on `α`, any extended nonnegative real number `p`, and any measure `μ` on `α`, it is almost everywhere true (according to the measure `μ`) that the double coercion of `0` is equal to `0`. In this context, "almost everywhere" means on all sets except a set of measure zero. The double coercion is a technical detail related to the way numbers are represented in the Lean 4 type system. Essentially, this theorem is stating that zero is zero almost everywhere.

For any measurable space `(α, μ)`, normed additively commutative group `E`, and extended nonnegative real number `p`, the double coercion of `0` is equal to `0` almost everywhere in `E` with respect to `μ`.


IsComplete.isClosed

/-- In a separated space, a complete set is closed.  -/
theorem IsComplete.isClosed :
    ∀ {α : Type u_1} [inst : UniformSpace α] [inst_1 : T0Space α] {s : Set α}, IsComplete s → IsClosed s := by sorry

This theorem states that in a separated space (also known as a T0 space), a complete set is always closed. Here, a set is complete if for any Cauchy filter on the set, there exists a limit in the set. In this context, a set is closed if its complement is open. A space is separated, or T0, if for any two distinct points, there exists a neighborhood that contains one but not the other.

In a separated (T0) space, every complete set is closed.


/-- **Alias** of `sup_sdiff_self`. -/
theorem sup_sdiff_self_right : ∀ {α : Type u_2} [inst : GeneralizedCoheytingAlgebra α] (a b : α), a ⊔ b \ a = a ⊔ b :=
  by sorry

This theorem, named `sup_sdiff_self_right`, states that for any type `α` that forms a Generalized Coheyting Algebra, for any two elements `a` and `b` of that type, the supremum (join) of `a` and the set difference of `b` and `a` is equal to the supremum of `a` and `b`. In the context of a Generalized Coheyting Algebra, the set difference operation is interpreted as a kind of 'relative complement': `b \ a` represents the part of `b` that is not in `a`. Thus, the theorem essentially states that 'adding' this 'relative complement' to `a` via the supremum operation does not change the supremum of `a` and `b`.

In a Generalized Coheting Algebra, the supremum of an element and the set difference of another element from it is equal to the supremum of the two elements.


theorem WithTop.coe_untop : ∀ {α : Type u_1} (x : WithTop α) (hx : x ≠ ⊤), ↑(WithTop.untop x hx) = x := by sorry

The theorem `WithTop.coe_untop` states that for any type `α` and for any element `x` of the type `WithTop α` which is not equal to `⊤` (Top), the result of applying the `untop` function to `x` and then embedding it back into the `WithTop α` type using the coercion function `↑` (up arrow), is equal to the original element `x` itself. In other words, the operation of `untop` followed by re-embedding is an identity operation for any element other than `⊤` in `WithTop α`.

For all types `α` and elements `x` in `WithTop α` distinct from `⊤`, the operation of `untop` followed by coercion `↑` is the identity function on `x`, i.e., `untop ↑x = x`.


theorem Mathlib.Analysis.Seminorm._auxLemma.6 :
    ∀ {𝕜 : Type u_3} {E : Type u_7} [inst : SeminormedRing 𝕜] [inst_1 : AddCommGroup E] [inst_2 : SMul 𝕜 E]
      (p : Seminorm 𝕜 E) {x y : E} {r : ℝ}, (y ∈ Seminorm.ball p x r) = (p (y - x) < r) :=
  by sorry

The theorem `Mathlib.Analysis.Seminorm._auxLemma.6` states that for any seminormed ring `𝕜`, additively commutative group `E`, and scalar multiplication `SMul 𝕜 E`, with a seminorm `p` on `E` and any elements `x` and `y` of `E` along with a real number `r`, the membership of `y` in the ball with radius `r` centered at `x` with respect to seminorm `p` is equivalent to the statement that the seminorm of the difference `(y - x)` is less than `r`. In simpler terms, `y` is in the ball of radius `r` around `x` if and only if the distance of `y` from `x`, measured by the seminorm `p`, is less than `r`.

For any seminormed ring 𝕜, additively commutative group E, and seminorm p on E, the element y belongs to the ball of radius r centered at x if and only if p(y - x) < r.


IsLUB.dual

theorem IsLUB.dual :
    ∀ {α : Type u} [inst : Preorder α] {s : Set α} {a : α},
      IsLUB s a → IsGLB (⇑OrderDual.ofDual ⁻¹' s) (OrderDual.toDual a) :=
  by sorry

This theorem states that for any given type `α` with a preorder relationship and any set `s` of elements of this type, if `a` is a least upper bound (LUB) of this set `s`, then `a` is also the greatest lower bound (GLB) of the set `s` under the order dual transformation. The order dual transforms each element of the set `s` to its dual order, effectively reversing the order of the elements. The theorem thus asserts that the LUB in the original order becomes the GLB in the reversed order.

For any preordered type `α` and set `s` of elements, if `a` is the least upper bound of `s`, then `a` is also the greatest lower bound of `s` in the order dual.


Asymptotics.IsLittleO.congr

theorem Asymptotics.IsLittleO.congr :
    ∀ {α : Type u_1} {E : Type u_3} {F : Type u_4} [inst : Norm E] [inst_1 : Norm F] {l : Filter α} {f₁ f₂ : α → E}
      {g₁ g₂ : α → F}, f₁ =o[l] g₁ → (∀ (x : α), f₁ x = f₂ x) → (∀ (x : α), g₁ x = g₂ x) → f₂ =o[l] g₂ :=
  by sorry

This theorem states that for any types `α`, `E`, and `F` with `E` and `F` being normed, any filter `l` on `α`, and any four functions `f₁`, `f₂` from `α` to `E`, `g₁`, `g₂` from `α` to `F`, if `f₁` is little-o of `g₁` at `l` and `f₁` equals `f₂` and `g₁` equals `g₂` for all `x` in `α`, then `f₂` is also little-o of `g₂` at `l`. In mathematical terms, we can write this as: if \(f_1(x) = O(g_1(x))\) as \(x \to l\), \(f_1(x) = f_2(x)\) and \(g_1(x) = g_2(x)\) for all \(x\), then \(f_2(x) = O(g_2(x))\) as \(x \to l\).

If `f₁(x) = O(g₁(x))` and `f₁(x) = f₂(x)` and `g₁(x) = g₂(x)` for all `x`, then `f₂(x) = O(g₂(x))`. In other words, if `f₁` is little-o of `g₁` and `f₁` equals `f₂` and `g₁` equals `g₂`, then `f₂` is also little-o of `g₂`.


theorem ContinuousMap.HomotopyRel.eq_fst :
    ∀ {X : Type u} {Y : Type v} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {f₀ f₁ : C(X, Y)} {S : Set X}
      (F : ContinuousMap.HomotopyRel f₀ f₁ S) (t : ↑unitInterval) {x : X}, x ∈ S → F (t, x) = f₀ x :=
  by sorry

This theorem, `ContinuousMap.HomotopyRel.eq_fst`, states that for any topological spaces `X` and `Y`, given continuous maps `f₀` and `f₁` from `X` to `Y`, a subset `S` of `X`, and a homotopy `F` between `f₀` and `f₁` that is fixed on `S`, then for any `x` in `S` and any `t` in the unit interval `[0,1]`, the value of the homotopy `F` at `(t, x)` equals the value of the initial function `f₀` at `x`. Thus, the homotopy `F` starts at `f₀` for all points in the set `S`.

For any continuous maps `f₀`, `f₁` from a topological space `X` to another space `Y`, a subset `S` of `X`, and a homotopy `F` between `f₀` and `f₁` fixed on `S`, the value of `F` at `(t, x)` equals the value of `f₀` at `x` for all `x` in `S` and `t` in [0,1].


theorem Mathlib.Order.Filter.Basic._auxLemma.157 : ∀ {p : Prop} {q : p → Prop} (h : p), (∀ (h' : p), q h') = q h := by
  sorry

This theorem states that for any proposition `p` and a function `q` dependent on `p`, given that `p` holds true (represented by `h : p`), the proposition that `q` holds true for all possible values of `p` (`∀ (h' : p), q h'`) is equivalent to `q` holding true for the specific instance of `p` being true (`q h`).

For any proposition `p` and dependent function `q`, `∀ (h : p) , q h ↔ q (h : p)` holds. (This statement asserts the equivalence of the dependent function `q` being true for all instances of `p` and the specific instance where `p` holds.)


theorem Mathlib.Order.Filter.Basic._auxLemma.171 :
    ∀ {α : Type u_1} {ι : Sort u_5} [inst : CompleteLattice α] {f : ι → α} {a : α}, (a ≤ iInf f) = ∀ (i : ι), a ≤ f i :=
  by sorry

This theorem states that for any type `α` that forms a complete lattice, and any function `f` from an arbitrary type `ι` to `α`, along with a given value `a` of type `α`, `a` is less than or equal to the infimum of `f` if and only if `a` is less than or equal to `f i` for every `i` of type `ι`. The infimum of `f` is calculated over its range using the `iInf` function.

For any complete lattice `α` and function `f` from type `ι` to `α`, and `a` in `α`, `a` is the infimum of `f` if and only if `a` is less than or equal to `f(i)` for all `i` in `ι`.


theorem Set.subset_compl_iff_disjoint_left : ∀ {α : Type u} {s t : Set α}, s ⊆ tᶜ ↔ Disjoint t s := by sorry

This theorem states that for any type `α` and any sets `s` and `t` of type `α`, `s` is a subset of the complement of `t` if and only if `t` and `s` are disjoint. In other words, all elements of `s` are not in `t` if and only if there's no element that belongs to both `t` and `s`. This theorem provides a connection between the concepts of set complement and disjointness in the context of set theory.

For sets `s` and `t` of type `α`, `s` is a subset of the complement of `t` if and only if `s` and `t` are disjoint.


theorem List.Pairwise.imp_of_mem :
    ∀ {α : Type u_1} {l : List α} {R S : α → α → Prop},
      (∀ {a b : α}, a ∈ l → b ∈ l → R a b → S a b) → List.Pairwise R l → List.Pairwise S l :=
  by sorry

This theorem states that, for any type `α` and any list `l` of type `α`, given two properties `R` and `S` of pairs of objects of type `α`, if for every pair of elements `a` and `b` in `l`, whenever `R a b` holds then `S a b` also holds, then if all pairs of elements in `l` have property `R`, it follows that all pairs of elements in `l` also have property `S`. In more mathematical language, it's saying that if `R` implies `S` for all pairs in the list, and the list is pairwise `R`, then the list is also pairwise `S`.

If `R` implies `S` between any pair of elements in a list `l` of type `α`, and every pair in `l` has property `R`, then `l` has the property `S` between all pairs.


IsMaxFilter.add

theorem IsMaxFilter.add :
    ∀ {α : Type u} {β : Type v} [inst : OrderedAddCommMonoid β] {f g : α → β} {a : α} {l : Filter α},
      IsMaxFilter f l a → IsMaxFilter g l a → IsMaxFilter (fun x => f x + g x) l a :=
  by sorry

The theorem `IsMaxFilter.add` states that for any types `α` and `β`, given an ordered commutative monoid on `β`, any two functions `f` and `g` from `α` to `β`, any point `a` of type `α`, and a filter `l` on `α`, if `f x ≤ f a` for all `x` in some `l`-neighborhood of `a` and `g x ≤ g a` for all `x` in the same `l`-neighborhood, then `(f x + g x) ≤ (f a + g a)` for all `x` in that `l`-neighborhood. In other words, if `f` and `g` both reach their maximum values at `a` when restricted to the `l`-neighborhood of `a`, then their sum also attains its maximum at `a`.

For any ordered commutative monoids `β`, given functions `f` and `g` from type `α` to `β`, point `a` of type `α`, filter `l` on `α`, if `f(x) ≤ f(a)` and `g(x) ≤ g(a)` hold for all `x` in the `l`-neighborhood of `a`, then `(f(x) + g(x)) ≤ (f(a) + g(a))` for all `x` in that `l`-neighborhood.


theorem Set.Icc_inter_Icc :
    ∀ {α : Type u_1} [inst : Lattice α] {a₁ a₂ b₁ b₂ : α},
      Set.Icc a₁ b₁ ∩ Set.Icc a₂ b₂ = Set.Icc (a₁ ⊔ a₂) (b₁ ⊓ b₂) :=
  by sorry

This theorem states that for any lattice structure α, and any four elements `a₁`, `a₂`, `b₁`, `b₂` of α, the intersection of the closed interval from `a₁` to `b₁` and the closed interval from `a₂` to `b₂` is equal to the closed interval from the supremum (`⊔`) of `a₁` and `a₂` to the infimum (`⊓`) of `b₁` and `b₂`. In other words, when two closed intervals on a lattice intersect, the resulting set is also a closed interval whose lower bound is the larger of the two original lower bounds and whose upper bound is the smaller of the two original upper bounds.

For any lattice α and elements a₁, a₂, b₁, b₂, the intersection of the closed intervals [a₁, b₁] and [a₂, b₂] is equal to the closed interval [⊔(a₁, a₂), ⊓(b₁, b₂)], where ⊔ and ⊓ denote the lattice supremum and infimum, respectively.


FiniteDimensional.complete

theorem FiniteDimensional.complete :
    ∀ (𝕜 : Type u_1) (E : Type u_2) [inst : NontriviallyNormedField 𝕜] [inst_1 : CompleteSpace 𝕜]
      [inst_2 : AddCommGroup E] [inst_3 : UniformSpace E] [inst_4 : T2Space E] [inst_5 : UniformAddGroup E]
      [inst_6 : Module 𝕜 E] [inst_7 : ContinuousSMul 𝕜 E] [inst : FiniteDimensional 𝕜 E], CompleteSpace E :=
  by sorry

This theorem states that, for any non-trivially normed field 𝕜 and any type E, given that 𝕜 is a complete space, E is an additive commutative group, E is a uniform space, E is a T2 space (also known as a Hausdorff space), E is a uniform additive group, 𝕜 is a module for E, 𝕜 scalar multiplication on E is continuous, and E is a finite-dimensional 𝕜-vector space, then E is a complete space.

In simpler terms, it states that any finite-dimensional vector space over a complete field is itself a complete space.

A finite-dimensional vector space over a complete field is a complete space.


theorem Int.negOnePow_neg : ∀ (n : ℤ), (-n).negOnePow = n.negOnePow := by sorry

This theorem states that for all integers `n`, the negation of `n` raised to the power of negative one is equal to `n` raised to the power of negative one. In other words, negating the base does not affect the result when the base is raised to the power of negative one. This is expressed in mathematical notation as $(-n)^{-1} = n^{-1}$ for all integers `n`.

For all integers `n`, the negative of the base raises to the power of negative one is equal to the base raised to the power of negative one, i.e., $(-n)^{-1} = n^{-1}$.


theorem Real.log_inv : ∀ (x : ℝ), Real.log x⁻¹ = -Real.log x := by sorry

This theorem states that for every real number 'x', the logarithm of the reciprocal of 'x' is equal to the negation of the logarithm of 'x'. In other words, the logarithm of the inverse of a real number equals the negative of the logarithm of the number itself, formally written as $\log(x^{-1}) = -\log(x)$. This property is crucial in the manipulation and simplification of logarithmic expressions.

The logarithm function satisfies the property that that $\log(x^{-1}) = -\log(x)$ for all real numbers $x$.


theorem ENNReal.top_mul' : ∀ {a : ENNReal}, ⊤ * a = if a = 0 then 0 else ⊤ := by sorry

The theorem `ENNReal.top_mul'` states that for any extended nonnegative real number 'a', the multiplication of '⊤' (which represents infinity) and 'a' is equal to '⊤' if 'a' is not zero. If 'a' is zero, then the result of the multiplication is zero. This mirrors the conventional mathematical understanding that multiplying infinity by any non-zero number results in infinity, and multiplying infinity by zero results in zero.

For any extended non-negative real number 'a', '⊤ * a = ⊤' if 'a' is non-zero, and '⊤ * 0 = 0'.


/-- An additive subgroup is finitely generated if
and only if it is finitely generated as an additive submonoid. -/
theorem AddSubgroup.fg_iff_addSubmonoid_fg :
    ∀ {G : Type u_3} [inst : AddGroup G] (P : AddSubgroup G), AddSubgroup.FG P ↔ AddSubmonoid.FG P.toAddSubmonoid := by
  sorry

This theorem states that for any additive subgroup `P` of a group `G`, `P` is finitely generated as an additive subgroup if and only if it is finitely generated as an additive submonoid. In other words, `P` is the closure of a finite subset of `G` both when considered as a subgroup and a submonoid.

A subgroup `P` of a group `G` is finitely generated as an additive subgroup if and only if it is finitely generated as an additive submonoid.


theorem MeasureTheory.Measure.map_add :
    ∀ {α : Type u_1} {β : Type u_2} {m0 : MeasurableSpace α} [inst : MeasurableSpace β] (μ ν : MeasureTheory.Measure α)
      {f : α → β},
      Measurable f →
        MeasureTheory.Measure.map f (μ + ν) = MeasureTheory.Measure.map f μ + MeasureTheory.Measure.map f ν :=
  by sorry

The theorem `MeasureTheory.Measure.map_add` states that for any two measures `μ` and `ν` on a measurable space `α`, and a measurable function `f` from `α` to another measurable space `β`, the pushforward of the sum of `μ` and `ν` under `f` is the same as the sum of the pushforwards of `μ` and `ν` under `f`. In other words, the operation of measure pushforward distributes over the addition of measures.

For measurable functions between measurable spaces and measures thereon, the pushforward of the sum of two measures is equal to the sum of their pushforwards.


theorem Real.deriv_log' : deriv Real.log = Inv.inv := by sorry

This theorem states that the derivative of the real logarithmic function is the inverse function. In mathematical terms, if `Real.log` represents the log function and `Inv.inv` represents the inverse function, then the derivative of the log function (`deriv Real.log`) is equal to the inverse function (`Inv.inv`). This corresponds to the well-known calculus result that the derivative of ln(x) is 1/x.

The derivative of the real logarithmic function is equal to its inverse. (i.e., `deriv Real.log = Inv.inv`)


/-- Special case of the sandwich theorem; see `tendsto_of_tendsto_of_tendsto_of_le_of_le'` for the
general case.  -/
theorem squeeze_zero' :
    ∀ {α : Type u_3} {f g : α → ℝ} {t₀ : Filter α},
      (∀ᶠ (t : α) in t₀, 0 ≤ f t) →
        (∀ᶠ (t : α) in t₀, f t ≤ g t) → Filter.Tendsto g t₀ (nhds 0) → Filter.Tendsto f t₀ (nhds 0) :=
  by sorry

This theorem, often known as the Squeeze Theorem, relates to the limit of a real-valued function `f` at a point in its domain under a filter `t₀`. The theorem states that if, for every `t` in the domain of `f` and `g` such that `t` is in the neighborhood of `t₀`, the value of `f(t)` is greater than or equal to 0 and less than or equal to `g(t)`, and if the function `g` tends to 0 as `t` approaches `t₀`, then the function `f` also tends to 0 as `t` approaches `t₀`. This is a special case of the more general Sandwich Theorem.

If a real-valued function `f` is sandwiched between a positive function `g` that tends to 0 at a point `t₀`, then `f` also tends to 0 at `t₀`. (Squeeze Theorem)


theorem Mathlib.Algebra.Pointwise.Stabilizer._auxLemma.10 :
    ∀ {G : Type u_1} {α : Type u_3} [inst : Group G] [inst_1 : MulAction G α] {a : G} {s : Set α},
      (a ∈ MulAction.stabilizer G s) = ∀ (b : α), a • b ∈ s ↔ b ∈ s :=
  by sorry

The theorem `Mathlib.Algebra.Pointwise.Stabilizer._auxLemma.10` states that, for any types `G` and `α`, with `G` a group and `α` a set on which `G` acts multiplicatively, for any element `a` of `G` and any set `s` of `α`, `a` belongs to the stabilizer of `s` under the action of `G` if and only if for every element `b` of `α`, `a` acting on `b` results in an element in `s` if and only if `b` is in `s`. In mathematical terms, this means that the stabilizing element `a` leaves every element in the set `s` invariant under the group action.

For any group action of `G` on a set `α`, an element `a` in `G` stabilizes a set `s` if and only if for all `b` in `s`, `a` maps `b` to an element in `s`.


theorem Metric.closedBall_compl_subset_of_mem_cocompact :
    ∀ {α : Type u} [inst : PseudoMetricSpace α] {s : Set α},
      s ∈ Filter.cocompact α → ∀ (c : α), ∃ r, (Metric.closedBall c r)ᶜ ⊆ s :=
  by sorry

The theorem `Metric.closedBall_compl_subset_of_mem_cocompact` states that for any type `α` that forms a pseudo metric space, and for any set `s` of type `α` that belongs to the filter generated by the complements of compact sets in this space, we can state the following: For any element `c` of type `α`, there exists a real number `r` such that the complement of the closed ball around `c` with radius `r` is a subset of `s`. In other words, you can always find a closed ball around any point in such a way that everything outside this ball is in the specified set `s` from the filter of complements to compact sets.

For any pseudo metric space `α` and set `s` generated by complements of compact sets, there exists a radius `r` such that for all `c` in `α`, the complement of the closed ball around `c` with radius `r` is contained in `s`.


/-- `lift.{max u v, u}` equals `lift.{v, u}`.  -/
theorem Ordinal.lift_umax : Ordinal.lift.{max u v, u} = Ordinal.lift.{v, u} := by sorry

The theorem `Ordinal.lift_umax` states that the "lift" operation on ordinals is commutative with respect to the maximum of two universe levels. Specifically, lifting an ordinal from universe level `u` to the maximum of `u` and `v` is the same as lifting it directly to universe level `v`. This theorem ensures the consistency of ordinal lifting across different universe levels.

For any ordinal `α` and universes `u` and `v` such that `u <= v`, the lift of `α` from `u` to `u` is equal to its lift from `u` to `v`.


theorem MeasureTheory.quasiMeasurePreserving_neg :
    ∀ {G : Type u_1} [inst : MeasurableSpace G] [inst_1 : AddGroup G] [inst_2 : MeasurableAdd₂ G]
      (μ : MeasureTheory.Measure G) [inst_3 : MeasureTheory.SigmaFinite μ] [inst_4 : MeasurableNeg G]
      [inst_5 : MeasureTheory.Measure.IsAddLeftInvariant μ], MeasureTheory.Measure.QuasiMeasurePreserving Neg.neg μ μ :=
  by sorry

This theorem, named `MeasureTheory.quasiMeasurePreserving_neg`, states that for any type `G` that is a measurable space, an add group, and for which the addition of two elements is measurable, the negation operation (i.e., producing the additive inverse of a number) is a quasi-measure preserving transformation with respect to any sigma-finite measure `μ` on `G`. In other words, if `μ` is a measure on `G` that is add-left-invariant (the measure of a set is unchanged if we add the same element to every point in the set), and if the negation operation is also measurable in `G`, then applying the negation operation doesn't significantly change the measure as defined by `μ`.

Given a measurable space `(G, Σ, μ)` where `G` is an add group with measurable addition, the negation operation on `G` is a quasi-measure preserving transformation with respect to `μ`.


/-- The recurrence relation for the `Γ` function.  -/
theorem Complex.Gamma_add_one : ∀ (s : ℂ), s ≠ 0 → Complex.Gamma (s + 1) = s * Complex.Gamma s := by sorry

This theorem states the recurrence relation for the Gamma function over complex numbers. Specifically, for any complex number `s` that is not zero, the value of the Gamma function at `s + 1` is equal to `s` multiplied by the value of the Gamma function at `s`. In mathematical notation, this could be written as Γ(s + 1) = s * Γ(s) for any complex s ≠ 0.

For complex numbers `s` not equal to zero, the Gamma function satisfies the recurrence relation Γ(s + 1) = s * Γ(s).


theorem List.nodup_nil : ∀ {α : Type u}, List.Nodup [] := by sorry

This theorem states that an empty list, regardless of its type `α`, always has no duplicates. In other words, the property of having no duplicates, or `List.Nodup`, is always satisfied by an empty list.

For all types `α`, the empty list of type `List α` has no duplicates.


theorem PiLp.norm_eq_of_L2 :
    ∀ {ι : Type u_2} [inst : Fintype ι] {β : ι → Type u_5} [inst_1 : (i : ι) → SeminormedAddCommGroup (β i)]
      (x : PiLp 2 β), ‖x‖ = Real.sqrt (Finset.sum Finset.univ fun i => ‖x i‖ ^ 2) :=
  by sorry

This theorem states that for any finite type `ι`, any type `β` that is a function from `ι` to a seminormed commutative additive group, and any `x` which is a function from `ι` to `β` (i.e., `x` is a vector in `PiLp 2 β`), the norm of `x` is equal to the square root of the sum of the squares of the norms of the elements of `x`. This is essentially a generalization of the Pythagorean theorem: the norm of `x` is calculated in the same way as the Euclidean distance in `R^n`.

For any finite type `ι`, given a function `β` from `ι` to a seminormed commutative additive group, and a function `x : ι → β`, the norm of `x` equals the square root of the sum of the squares of the element-wise norms of `x`.


/-- The other direction does not hold because of the `u`-`u` cross terms on the RHS.  -/
theorem Set.image2_distrib_subset_right :
    ∀ {α : Type u_1} {α' : Type u_2} {β : Type u_3} {β' : Type u_4} {γ : Type u_5} {δ : Type u_7} {ε : Type u_9}
      {s : Set α} {t : Set β} {u : Set γ} {f : δ → γ → ε} {g : α → β → δ} {f₁ : α → γ → α'} {f₂ : β → γ → β'}
      {g' : α' → β' → ε},
      (∀ (a : α) (b : β) (c : γ), f (g a b) c = g' (f₁ a c) (f₂ b c)) →
        Set.image2 f (Set.image2 g s t) u ⊆ Set.image2 g' (Set.image2 f₁ s u) (Set.image2 f₂ t u) :=
  by sorry

The theorem `Set.image2_distrib_subset_right` states that for any sets `s`, `t`, and `u` of types `α`, `β`, and `γ` respectively, and any mappings `f : δ → γ → ε`, `g : α → β → δ`, `f₁ : α → γ → α'`, `f₂ : β → γ → β'` and `g' : α' → β' → ε`, such that for all elements `a` in `s`, `b` in `t`, and `c` in `u`, the function application `f (g a b) c` is equal to `g' (f₁ a c) (f₂ b c)`, the image of the function `f` over the image of the function `g` on the Cartesian product `s × t` and the set `u` is a subset of the image of the function `g'` over the image of function `f₁` on the Cartesian product `s × u` and the image of function `f₂` on the Cartesian product `t × u`.

Stated more simply, this theorem is about the conditions under which one can interchange two pairs of nested mappings applied over certain sets. The theorem does not hold in the opposite direction due to the presence of cross terms on the right-hand side.

For sets `s`, `t`, `u` and mappings `f`, `g`, `f₁`, `f₂`, `g'`, if `f (g a b) c = g' (f₁ a c) (f₂ b c)` for all `a ∈ s`, `b ∈ t`, and `c ∈ u`, then `Set.image2 (g ∘ f) (s × t × u) ⊆ Set.image2 (g' ∘ f₁ ∘ f₂) (s × u × u)`.


Subsemigroup.ext

/-- Two subsemigroups are equal if they have the same elements.  -/
theorem Subsemigroup.ext : ∀ {M : Type u_1} [inst : Mul M] {S T : Subsemigroup M}, (∀ (x : M), x ∈ S ↔ x ∈ T) → S = T :=
  by sorry

This theorem states that two subsemigroups of a multiplicative type `M` are equal if and only if they have the same elements. In other words, for any type `M` equipped with a multiplication operation, if for every element `x` of `M` the condition of `x` being in subsemigroup `S` is equivalent to `x` being in subsemigroup `T`, then `S` and `T` must be the same subsemigroup.

Two subsemigroups of a multiplicative type equal if and only if they have the same elements.


/-- The first part of the third simplicial identity  -/
theorem SimplexCategory.δ_comp_σ_self :
    ∀ {n : ℕ} {i : Fin (n + 1)},
      CategoryTheory.CategoryStruct.comp (SimplexCategory.δ (Fin.castSucc i)) (SimplexCategory.σ i) =
        CategoryTheory.CategoryStruct.id (SimplexCategory.mk n) :=
  by sorry

This theorem states the first part of the third simplicial identity in the context of the Simplex Category. Specifically, for any natural number `n` and any element `i` of the finite set `Fin(n + 1)`, the composition of the `i`-th face map from `[n]` to `[n+1]` applied to the successor of `i`, and the `i`-th degeneracy map from `[n+1]` to `[n]`, is equal to the identity morphism on the `n`-th object of the Simplex Category. In other words, it asserts that applying first a face map and then a degeneracy map results in no change to the original object.

For any natural number `n` and element `i` of `Fin(n + 1)`, the composition of the `i`-th face map from `[n]` to `[n+1]` and the `i`-th degeneracy map from `[n+1]` to `[n]` is the identity morphism on `[n]` in the Simplex Category.


theorem NNReal.sqrt_eq_rpow : ∀ (x : NNReal), NNReal.sqrt x = x ^ (1 / 2) := by sorry

This theorem states that for any nonnegative real number `x`, the square root of `x` is equal to `x` raised to the power of one-half. In mathematical terms, this theorem is saying that for all `x` in the set of nonnegative real numbers, √x = x^(1/2). This is a property that captures the relationship between the operation of taking a square root and the operation of exponentiation in the realm of nonnegative real numbers.

For all non-negative real numbers x, √x = x^(1/2).


theorem Mathlib.Topology.Instances.NNReal._auxLemma.6 :
    ∀ {α : Type u_1} {f : α → NNReal}, (Summable fun a => ↑(f a)) = Summable f := by sorry

This theorem states that for any type `α` and any function `f` from `α` to nonnegative real numbers (notated as `NNReal`), the property that the function mapped to its real number equivalents (using the `↑` operator) is summable is equivalent to the property that the function `f` itself is summable. In other words, `f` is summable over its values in `NNReal` if and only if its real number equivalents are also summable. Summability, in this context, meaning there exists an (infinite) sum of the sequence generated by the function. The proof of this theorem is not provided (`by sorry`).

For any type `α` and function `f` from `α` to nonnegative real numbers, `f` is summable if and only if its real number equivalents are summable.


theorem lt_of_eq_of_lt : ∀ {α : Type u} {a b c : α} [inst : LT α], a = b → b < c → a < c := by sorry

This theorem states that for any type `α` that has a less than operation, if you have three instances of this type `a`, `b`, and `c` such that `a` is equal to `b` and `b` is less than `c`, then `a` is less than `c`. This captures the intuitive idea that equality and the less than relation can be combined: if one thing equals another, and that other thing is less than a third thing, then the first thing is also less than the third thing.

For any type `α` with a total order, if `a = b` and `b < c`, then `a < c`.


/-- **Alias** of `sub_add_cancel_left`. -/
theorem sub_add_cancel' : ∀ {G : Type u_3} [inst : AddCommGroup G] (a b : G), a - (a + b) = -b := by sorry

This theorem, referred to as `sub_add_cancel'`, is an alias of `sub_add_cancel_left`. It states that for any type `G` that forms an additive commutative group, for any elements `a` and `b` of this group, subtracting `(a + b)` from `a` yields the additive inverse of `b`. In mathematical notation, this can be expressed as $a - (a + b) = -b$.

For any additive commutative group (G, +), for all a, b ∈ G, a + b - a = b.


theorem BoxIntegral.Box.coe_splitLower :
    ∀ {ι : Type u_1} {I : BoxIntegral.Box ι} {i : ι} {x : ℝ},
      ↑(BoxIntegral.Box.splitLower I i x) = ↑I ∩ {y | y i ≤ x} :=
  by sorry

The theorem `BoxIntegral.Box.coe_splitLower` states that for any type `ι`, any box `I` of type `BoxIntegral.Box ι`, any `i` of type `ι`, and any real number `x`, the co-domain of the function `BoxIntegral.Box.splitLower I i x` is equal to the intersection of the co-domain of `I` and the set of all `y` such that `y i` is less than or equal to `x`. In other words, it demonstrates that splitting the box `I` at a hyperplane defined by `y i = x` results in a new box that contains all points of `I` where `y i` is less than or equal to `x`.

The theorem `BoxIntegral.Box.coe_splitLower` asserts that the co-domain of `BoxIntegral.Box.splitLower I i x` is equal to the intersection of the co-domain of box `I` and the set of `y` for which `y i ≤ x`.


theorem EMetric.ball_subset_ball :
    ∀ {α : Type u} [inst : PseudoEMetricSpace α] {x : α} {ε₁ ε₂ : ENNReal},
      ε₁ ≤ ε₂ → EMetric.ball x ε₁ ⊆ EMetric.ball x ε₂ :=
  by sorry

This theorem states that for any pseudo emetric space (a type of metric space where the distance between two points can be infinite), any point 'x' in that space, and any two extended nonnegative real numbers 'ε₁' and 'ε₂', if 'ε₁' is less than or equal to 'ε₂', then the ε-metric ball surrounding 'x' with radius 'ε₁' is a subset of the ε-metric ball surrounding 'x' with radius 'ε₂'. In simpler terms, a smaller or equal-sized sphere is always contained within a larger sphere when both spheres have the same center. The ε-metric ball is a set of all points 'y' such that the extended distance between 'y' and 'x' is less than 'ε', where 'ε' can be any nonnegative real number including infinity.

For any pseudo-metric space and any point x, if B(x, ε₁) is the ε₁-ball and B(x, ε₂) is the ε₂-ball with the same center x, then B(x, ε₁) ⊆ B(x, ε₂) when ε₁ ≤ ε₂.


theorem zpow_sub : ∀ {G : Type w} [inst : Group G] (a : G) (m n : ℤ), a ^ (m - n) = a ^ m * (a ^ n)⁻¹ := by sorry

This theorem states that for any group `G` and an element `a` of `G`, the power of `a` raised to the difference of two integers `m` and `n` is equal to the product of `a` raised to the `m` and the inverse of `a` raised to the `n`. In mathematical notation, this would be written as \(a^{(m - n)} = a^m * (a^n)^{-1}\).

For any group `G` and its element `a`, the power of `a` raised to the difference of two integers `m` and `n` equals the product of `a` raised to the power of `m` and the inverse of `a` raised to the power of `n`: `(a^m)*(a^n)^-1 = a^(m-n)`.


theorem RingHom.IsIntegralElem.of_mem_closure :
    ∀ {R : Type u_1} {S : Type u_4} [inst : CommRing R] [inst_1 : CommRing S] (f : R →+* S) {x y z : S},
      RingHom.IsIntegralElem f x →
        RingHom.IsIntegralElem f y → z ∈ Subring.closure {x, y} → RingHom.IsIntegralElem f z :=
  by sorry

This theorem states that if we have two elements `x` and `y` of a commutative ring `S` that are integral over a commutative ring `R` with respect to a ring homomorphism `f` from `R` to `S`, then any element `z` that is in the subring of `S` generated by `{x, y}` is also integral over `R` with respect to `f`. In other words, `z` is a root of a monic polynomial `p` from `R[X]` when evaluated under `f`.

If `x` and `y` are elements of a commutative ring `S` that are integral over a commutative ring `R` with respect to a ring homomorphism `f` from `R` to `S`, then any element `z` in the subring generated by `{x, y}` is also integral over `R` with respect to `f`.


theorem Zsqrtd.norm_mul : ∀ {d : ℤ} (n m : ℤ√d), Zsqrtd.norm (n * m) = Zsqrtd.norm n * Zsqrtd.norm m := by sorry

This theorem states that for any integer `d` and any two elements `n` and `m` of the set of integers adjoined with the square root of `d` (denoted as `ℤ√d`), the norm of the product of `n` and `m` is equal to the product of the norms of `n` and `m`. In other words, the norm function in the `ℤ√d` number field is multiplicative. This can be described mathematically as `∀ d ∈ ℤ, ∀ n, m ∈ ℤ√d, norm(n*m) = norm(n) * norm(m)`. Here, `norm(n)` refers to the norm of an element `n` in `ℤ√d`, which is defined as the difference between the square of `n`'s real part and `d` times the square of `n`'s imaginary part.

For any integers $d, n, m$ in the number field $\mathbb{Z}[\sqrt{d}],$ the norm of their product $n \cdot m$ equals the product of their individual norms, i.e., $\|n \cdot m\| = \|n\| \cdot \|m\|.$


theorem ModuleCat.coe_comp :
    ∀ {R : Type u} [inst : Ring R] {M N U : ModuleCat R} (f : M ⟶ N) (g : N ⟶ U),
      ⇑(CategoryTheory.CategoryStruct.comp f g) = ⇑g ∘ ⇑f :=
  by sorry

The theorem `ModuleCat.coe_comp` states that for any type `R` with a ring structure, and for any three `R`-modules `M`, `N`, and `U`, the composition of two morphisms `f : M ⟶ N` and `g : N ⟶ U` (in the category of `R`-modules) is equal to the composition of the corresponding functions. In other words, if we apply the coercion (`⇑`) to the composition of `f` and `g`, we get the same result as if we first apply `⇑` to `f` and `g` separately and then compose them as regular functions. This theorem justifies working with elements of modules in the same way we work with functions when it comes to composition.

For any ring `R` and `R`-module morphisms `f : M ⟶ N` and `g : N ⟶ U`, `⇑(g ∘ f) = ⇑g ∘ ⇑f` in the category of `R`-modules.


theorem MeasureTheory.integral_union :
    ∀ {X : Type u_1} {E : Type u_3} [inst : MeasurableSpace X] [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace ℝ E] {f : X → E} {s t : Set X} {μ : MeasureTheory.Measure X},
      Disjoint s t →
        MeasurableSet t →
          MeasureTheory.IntegrableOn f s μ →
            MeasureTheory.IntegrableOn f t μ →
              ∫ (x : X) in s ∪ t, f x ∂μ = ∫ (x : X) in s, f x ∂μ + ∫ (x : X) in t, f x ∂μ :=
  by sorry

The theorem `MeasureTheory.integral_union` states that for any two disjoint measurable sets `s` and `t` in a given measurable space `X` and any function `f` from `X` to a normed additive commutative group `E` (which is also a normed space over the real numbers), if `f` is integrable on both `s` and `t` with respect to a given measure `μ`, then the integral of `f` over the union of `s` and `t` is equal to the sum of the integral of `f` over `s` and the integral of `f` over `t`. In mathematical terms, this can be written as:

∀ s, t ⊂ X, f : X → E, μ : Measure,

If s ∩ t = ∅, f is μ-integrable on s and t, then ∫ₛ ∪ t f dμ = ∫ₛ f dμ + ∫ₜ f dμ.

If two disjoint measurable sets `s` and `t` in a measurable space `X` and a function `f` from `X` to a normed additive commutative group `E`, integrable over `s` and `t` with respect to a measure `μ`, then the integral of `f` over their union equals the sum of the integrals over `s` and `t`.


theorem isGLB_iInf :
    ∀ {α : Type u_1} {ι : Sort u_5} [inst : CompleteLattice α] {f : ι → α}, IsGLB (Set.range f) (⨅ j, f j) := by sorry

The theorem `isGLB_iInf` states that for any type `α` which is a complete lattice, and any function `f` from some type `ι` to `α`, the greatest lower bound (GLB) of the range of `f` is equal to the infimum of the set of all `f j` as `j` varies over the type `ι`. In other words, the smallest element that is greater than or equal to every element in the range of `f` is the same as the least element of the set of all `f j`. This property holds in the setting of complete lattices, which are partially ordered sets in which every subset has both a greatest lower bound and a least upper bound.

In a complete lattice, the greatest lower bound of the range of a function equals the infimum of its values.


theorem Set.projIcc_of_mem :
    ∀ {α : Type u_1} [inst : LinearOrder α] {a b : α} (h : a ≤ b) {x : α} (hx : x ∈ Set.Icc a b),
      Set.projIcc a b h x = { val := x, property := hx } :=
  by sorry

The theorem `Set.projIcc_of_mem` states that for any type `α` equipped with a linear order, and for any two elements `a` and `b` in `α` where `a` is less than or equal to `b`, if an element `x` belongs to the closed interval from `a` to `b` (denoted by `Set.Icc a b`), then the projection of `x` onto the same interval (`Set.projIcc a b h x`) is the same as the pair consisting of `x` along with the proof that `x` is in the interval `Set.Icc a b`. In other words, if `x` is already in the interval, its projection to the interval is just itself.

For any type `α` with a linear order and elements `a ≤ b`, if `x ∈ Set.Icc a b`, then `Set.projIcc a b x = (x, ⟨h: x ∈ Set.Icc a b⟩)`.


theorem Mathlib.Topology.UniformSpace.Equicontinuity._auxLemma.19 :
    ∀ {α : Type u_1} {β : Type u_2} {p : α × β → Prop}, (∀ (x : α × β), p x) = ∀ (a : α) (b : β), p (a, b) := by sorry

This theorem states that for any property `p` which applies to pairs of elements from types `α` and `β`, stating that this property holds for all pairs `(x : α × β)` is equivalent to stating that the property holds for all possible pairs constructed as `(a : α) (b : β)`. In other words, the property applies to all individual combinations of elements from `α` and `β`.

The theorem asserts that a property `p` defined on pairs from types `α × β` is equivalent to the same property on individual elements `(a : α) (b : β)`.


theorem AddMonoidHom.liftOfRightInverse_comp_apply :
    ∀ {G₁ : Type u_5} {G₂ : Type u_6} {G₃ : Type u_7} [inst : AddGroup G₁] [inst_1 : AddGroup G₂] [inst_2 : AddGroup G₃]
      (f : G₁ →+ G₂) (f_inv : G₂ → G₁) (hf : Function.RightInverse f_inv ⇑f)
      (g : { g // AddMonoidHom.ker f ≤ AddMonoidHom.ker g }) (x : G₁),
      ((AddMonoidHom.liftOfRightInverse f f_inv hf) g) (f x) = ↑g x :=
  by sorry

The theorem `AddMonoidHom.liftOfRightInverse_comp_apply` states that for any three groups `G₁`, `G₂`, and `G₃` and a given additive monoid homomorphism `f: G₁ →+ G₂`, if we have a function `f_inv: G₂ → G₁` that is a right inverse to `f` (i.e., `f ∘ f_inv = id`), then for any homomorphism `g` whose kernel is a subset of the kernel of `f`, and for any element `x` of `G₁`, the composition of `f` with the lift of `g` with respect to `f_inv` and `hf` evaluated at `x` equals the evaluation of `g` at `x`. In other words, it says the lifted homomorphism behaves the same as the original homomorphism `g` on the image of `f`.

For additive monoid homomorphisms $f: G\_1 \to G\_2$ and given a right inverse $f\_{inv}: G\_2 \to G\_1$ such that $f \circ f\_{inv} = id\_{G\_2}$, if homomorphism $g: G\_1 \to G\_3$ has a kernel contained in $f$'s kernel, then $g(x) = (g \circ (f\_{inv} \circ f))(x)$ for all $x \in G\_1$.


theorem Zspan.fract_eq_self :
    ∀ {E : Type u_1} {ι : Type u_2} {K : Type u_3} [inst : NormedLinearOrderedField K] [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace K E] {b : Basis ι K E} [inst_3 : FloorRing K] [inst_4 : Fintype ι] {x : E},
      Zspan.fract b x = x ↔ x ∈ Zspan.fundamentalDomain b :=
  by sorry

The theorem `Zspan.fract_eq_self` states that for any type `E`, `ι`, and `K`, where `K` is a normed linear ordered field, `E` is a normed add commutative group, and `E` is a normed space over `K`, given a basis `b` of type `Basis ι K E` (i.e., a basis of `E` over `K` indexed by `ι`), a floor ring over `K`, and a `Fintype ι`, a vector `x` in `E` is in the fundamental domain of the lattice spanned by `b` if and only if applying the `Zspan.fract` operation to `x` results in `x` itself. Here, the `Zspan.fract` operation is defined as the vector `x` minus an integral vector obtained via the `Zspan.floor` function. The fundamental domain of a lattice is the set of all vectors `m` such that for all indices `i`, the `i`-th coordinate of the representation of `m` in the basis `b` lies in the half-open interval `[0, 1)`.

Given a normed linear ordered field `K`, a normed add commutative group `E` that is a normed space over `K`, a basis `b` of `E` over `K`, and a vector `x` in `E`, `x` lies in the fundamental domain of the lattice spanned by `b` if and only if `x = Zspan.fract x`.


theorem himp_inf_distrib :
    ∀ {α : Type u_2} [inst : GeneralizedHeytingAlgebra α] (a b c : α), a ⇨ b ⊓ c = (a ⇨ b) ⊓ (a ⇨ c) := by sorry

This theorem, `himp_inf_distrib`, states that for any type `α`, which forms a Generalized Heyting Algebra, and for any elements `a`, `b`, and `c` of that type, the operation `a` implies `(b` and `c)` is equal to `(a` implies `b)` and `(a` implies `c)`. In mathematical terms, it shows that implication distributes over the infimum (logical AND) operation in a Generalized Heyting Algebra.

In a Generalized Heyting Algebra, the implication operation distributes over the infimum (logical AND) operation: `a implies (b and c) <-> (a implies b) and (a implies c)`.


theorem Decidable.not_imp_not : ∀ {a b : Prop} [inst : Decidable a], ¬a → ¬b ↔ b → a := by sorry

This theorem states that for any two propositions `a` and `b`, given that `a` is decidable, the statement "not `a` implies not `b`" is logically equivalent to "if `b` then `a`". This theorem is essentially a formalization of the contrapositive law in propositional logic, which states that given two propositions `p` and `q`, the statement "if not `p` then not `q`" is equivalent to "if `q` then `p`". The condition that `a` is decidable is needed in the context of constructive logic, where not all propositions are assumed to be either true or false.

In constructive logic, `not a` is logically equivalent to `∥a → b∥` given the decidability of `a`, where `→` denotes logical implication.


/-- When `p` is prime, then the totient of `p ^ n` is `p ^ (n - 1) * (p - 1)`  -/
theorem Nat.totient_prime_pow :
    ∀ {p : ℕ}, Nat.Prime p → ∀ {n : ℕ}, 0 < n → Nat.totient (p ^ n) = p ^ (n - 1) * (p - 1) := by sorry

The theorem `Nat.totient_prime_pow` states that for a prime number `p` and any natural number `n` greater than 0, Euler's totient function of `p` to the power of `n` is equal to `p` to the power of `(n - 1)` multiplied by `(p - 1)`. In mathematical notation, this is equivalent to the formula $\phi(p^n) = p^{n-1}(p - 1)$, where $\phi$ is Euler's totient function, which counts the number of natural numbers less than `n` that are coprime with `n`.

Euler's totient function of a prime number `p` raised to the power `n` equals `p` raised to the power `(n - 1)` multiplied by `(p - 1)`. In other words, $\phi(p^n) = p^{n-1}(p - 1)$, where $\phi$ is Euler's totient function.


theorem Opposite.op_unop : ∀ {α : Sort u} (x : αᵒᵖ), Opposite.op x.unop = x := by sorry

The theorem `Opposite.op_unop` asserts that for any type `α` and any element `x` of the opposite type `αᵒᵖ`, applying the function `Opposite.op` to the `unop` of `x` (i.e., the original element in `α` from which `x` was derived) will yield `x` itself. In simpler terms, this theorem states that 'unopping' an opposite element and then 'opping' it again brings us back to the original opposite element.

For any type `α` and its opposite `αᵒᵖ,` applying the opposite operation twice to an element `x` of `αᵒᵖ` yields the original element `x.` In Lean notation, `Opposite.op (Opposite.unop x) = x.`


theorem hnot_hnot_le : ∀ {α : Type u_2} [inst : CoheytingAlgebra α] {a : α}, ￢￢a ≤ a := by sorry

This theorem, `hnot_hnot_le`, states that for all types `α` in a Coheyting algebra, the double negation of any element `a` of type `α` is less than or equal to `a` itself. In more mathematical terms, given any Coheyting algebra and any element `a` in that algebra, the inequality `￢￢a ≤ a` holds.

In a Coheyting algebra, the double negation of any element is less than or equal to the element itself. (i.e. ⊥⊥a ≤ a for all a : α)


RingCon.mul

theorem RingCon.mul :
    ∀ {R : Type u_2} [inst : Add R] [inst_1 : Mul R] (c : RingCon R) {w x y z : R}, c w x → c y z → c (w * y) (x * z) :=
  by sorry

The theorem `RingCon.mul` states that for any type `R` that has addition and multiplication operations, given a structure `c` of type `RingCon R` and elements `w`, `x`, `y`, and `z` of `R`, if `c` relates `w` to `x` and `y` to `z`, then `c` must also relate the product of `w` and `y` to the product of `x` and `z`. In other words, it guarantees the compatibility of the relation `c` with the ring multiplication operation in this context.

For any commutative ring `R` and `RingCon` structure `c` on `R`, if `c` relates `w` to `x` and `y` to `z`, then `c` relates `w * y` to `x * z`.


theorem Finsupp.fun_support_eq :
    ∀ {α : Type u_1} {M : Type u_5} [inst : Zero M] (f : α →₀ M), Function.support ⇑f = ↑f.support := by sorry

The theorem `Finsupp.fun_support_eq` states that for any type `α` and a type `M` with a zero element (denoted by `Zero M`), and for any function `f` from `α` to `M` that is finitely supported (denoted by `f : α →₀ M`), the support of the function `f` (represented as `Function.support ⇑f`) is exactly equal to the support of the `f` considered as a finitely supported function (denoted by `↑f.support`). In other words, the set of points `x` in type `α` such that `f(x)` is non-zero is the same whether we consider `f` as an ordinary function or as a finitely supported function.

For any type `α` and type `M` with a zero element, and for any finitely supported function `f : α →₀ M`, the set of points in `α` where `f` is non-zero is equal to the support of `f` as both an ordinary function and as a finitely supported function.


theorem Int.neg_add_cancel_right : ∀ (a b : ℤ), a + -b + b = a := by sorry

This theorem, `Int.neg_add_cancel_right`, states that for all integers `a` and `b`, if you add the negation of `b` to `a` and then add `b`, you will get back `a`. In mathematical notation, it asserts that ∀(a, b ∈ ℤ), a + (-b) + b = a. Essentially, this is a statement about the canceling property of addition with negation in the set of integers.

For all integers `a` and `b`, `a + (-b) = a + b`. In other words, adding the negation of a number to a number is equivalent to not adding that number.


/-- **Alias** of the reverse direction of `convexHull_eq_self`. -/
theorem Convex.convexHull_eq :
    ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : OrderedSemiring 𝕜] [inst_1 : AddCommMonoid E] [inst_2 : Module 𝕜 E]
      {s : Set E}, Convex 𝕜 s → (convexHull 𝕜) s = s :=
  by sorry

This theorem states that for any ordered semiring `𝕜` and any set `s` in an additive commutative monoid `E` over which `𝕜` is a module, if `s` is a convex set, then the convex hull of `s` is equal to `s` itself. In other words, a convex set contains all the points in its convex hull.

For any ordered semiring `𝕜` and additive commutative monoid `E` over which `𝕜` is a module, if `s` is a convex subset of `E`, then `s` is equal to its convex hull.


theorem IsometryEquiv.image_ball :
    ∀ {α : Type u} {β : Type v} [inst : PseudoMetricSpace α] [inst_1 : PseudoMetricSpace β] (h : α ≃ᵢ β) (x : α)
      (r : ℝ), ⇑h '' Metric.ball x r = Metric.ball (h x) r :=
  by sorry

This theorem states that for every pseudometric spaces `α` and `β`, every isometry `h` from `α` to `β`, every point `x` in `α`, and every real number `r`, the image of the open ball of radius `r` centered at `x` under the isometry `h` is exactly the open ball of radius `r` centered at `h(x)`. In other words, an isometry preserves open balls: it takes every point inside an open ball around `x` in `α` to a point inside the corresponding open ball around `h(x)` in `β`, and vice versa.

For every isometry between pseudometric spaces and every point and radius in those spaces, the image of the open ball centered at under is the open ball centered at in with the same radius.


/-- The (open) `δ`-thickening `Metric.thickening δ E` of a subset `E` in a metric space equals the
union of balls of radius `δ` centered at points of `E`.  -/
theorem Metric.thickening_eq_biUnion_ball :
    ∀ {X : Type u} [inst : PseudoMetricSpace X] {δ : ℝ} {E : Set X}, Metric.thickening δ E = ⋃ x ∈ E, Metric.ball x δ :=
  by sorry

This theorem states that for any set `E` in a pseudo-metric space (a space where distance between two points is defined), the δ-thickening of `E` (the set of points that are less than δ distance away from any point in `E`) is equivalent to the union of δ-radius balls centered at each point in `E`. In other words, if we take each point in `E` and draw a ball (or sphere) of radius δ around it, the union of all these balls is exactly the δ-thickening of `E`. This theorem holds for any pseudo-metric space `X` and any real number δ.

In a pseudo-metric space, the δ-thickening of a set is equal to the union of δ-radius balls centered at each point in the set.


theorem SimplicialObject.Splitting.ι_desc :
    ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] {X : CategoryTheory.SimplicialObject C}
      (s : SimplicialObject.Splitting X) {Z : C} (Δ : SimplexCategoryᵒᵖ)
      (F : (A : SimplicialObject.Splitting.IndexSet Δ) → s.N (SimplexCategory.len A.fst.unop) ⟶ Z)
      (A : SimplicialObject.Splitting.IndexSet Δ),
      CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.Cofan.inj (SimplicialObject.Splitting.cofan s Δ) A)
          (SimplicialObject.Splitting.desc s Δ F) =
        F A :=
  by sorry

This theorem, `SimplicialObject.Splitting.ι_desc`, states that for a given category `C`, a simplicial object `X` in `C`, a splitting `s` of `X`, an object `Z` in `C`, a contravariant object `Δ` in `SimplexCategory` and a function `F` mapping from the `IndexSet` of the splitting to a morphism from `s.N (SimplexCategory.len A.fst.unop)` to `Z`, the composition of the cofan injection of the splitting with respect to `A` and the description of the splitting equals to the function `F` evaluated at `A`. In other words, it describes how the function `F` relates to the structure of the simplicial object.

For any simplicial object X in category C, splitting s, object Z in C, contravariant Δ in SimplexCategory, and function F from the splitting's index set to morphisms from s.N to Z, the composition of the coface injection of s with respect to A and the description of the splitting equals F evaluated at A.


/-- `∧` distributes over `∨` (on the right).  -/
theorem or_and_right : ∀ {a b c : Prop}, (a ∨ b) ∧ c ↔ a ∧ c ∨ b ∧ c := by sorry

This theorem, named `or_and_right`, states the distributive property of logical conjunction (`∧`) over logical disjunction (`∨`) on the right side. In other words, for any three propositions `a`, `b`, and `c`, the statement "`a OR b` AND `c`" is logically equivalent to the statement "`a AND c` OR `b AND c`". This is a fundamental theorem in propositional logic.

The theorem `or_and_right` asserts that for all propositions `a`, `b`, and `c`, `(a ∨ b) ∧ c` is logically equivalent to `(a ∧ c) ∨ (b ∧ c)`.


theorem CategoryTheory.ShortComplex.opcyclesMap_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.opcyclesMap (CategoryTheory.CategoryStruct.id S) =
        CategoryTheory.CategoryStruct.id (CategoryTheory.ShortComplex.opcycles S) :=
  by sorry

This theorem states that, for any given category `C` with zero morphisms, and any short complex `S` with right homology, the operation `opcyclesMap`, when applied to the identity morphism of `S`, gives the same result as applying the identity morphism to the operation `opcycles` of `S`.

In other words, the `opcyclesMap` operation preserves the identity morphism in the category of short complexes, which is a crucial property needed for the definition of a category. This property ensures that the structures and relations between objects in the category are maintained under the `opcyclesMap` operation.

For any short complex `S` in a category with zero morphisms, `opcyclesMap` applied to the identity morphism of `S` equals the identity morphism on its homology `opcycles`.


theorem Matrix.charmatrix_apply_eq :
    ∀ {R : Type u_1} [inst : CommRing R] {n : Type u_4} [inst_1 : DecidableEq n] [inst_2 : Fintype n] (M : Matrix n n R)
      (i : n), Matrix.charmatrix M i i = Polynomial.X - Polynomial.C (M i i) :=
  by sorry

The theorem `Matrix.charmatrix_apply_eq` states that for any commutative ring `R`, any finite type `n` with decidable equality, and any square matrix `M` of type `n` with entries in `R` and any index `i` of type `n`, the `i`-`i` entry of the characteristic matrix of `M` is equal to the polynomial variable `X` minus the constant polynomial of the `i`-`i` entry of `M`. In mathematical terms, it says that the diagonal entry of the characteristic matrix of a square matrix is `X - M[i,i]`, where `X` is the polynomial variable and `M[i,i]` is the `i`-`i`th entry of the matrix `M`.

The characteristic matrix of a square matrix over a commutative ring with decidable equality has the `i`-`th` diagonal entry equal to `X` minus the entry in the `i`-`th` row and column.


ContDiffWithinAt.div

theorem ContDiffWithinAt.div :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type uE} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {s : Set E} {x : E} [inst_3 : CompleteSpace 𝕜] {f g : E → 𝕜} {n : ℕ∞},
      ContDiffWithinAt 𝕜 n f s x →
        ContDiffWithinAt 𝕜 n g s x → g x ≠ 0 → ContDiffWithinAt 𝕜 n (fun x => f x / g x) s x :=
  by sorry

The theorem `ContDiffWithinAt.div` states that for any non-trivially normed field 𝕜, normed add commutative group E, normed space over 𝕜, set of elements from E, point in E, complete space 𝕜, two functions from E to 𝕜, and natural number or infinity, given the conditions that the functions are continuously differentiable within the set at the point and the second function at the point is not zero, then the function which is the ratio of first function to the second is also continuously differentiable within the set at the point.

If two continuously differentiable functions from a normed space into a non-trivially normed field, with the second function not being the zero function at a point in a complete normed space, then their quotient is also continuously differentiable at that point.


/-- An alternative form of the equation, suitable for rewriting `d * y^2`.  -/
theorem Pell.Solution₁.prop_y :
    ∀ {d : ℤ} (a : Pell.Solution₁ d), d * Pell.Solution₁.y a ^ 2 = Pell.Solution₁.x a ^ 2 - 1 := by sorry

This theorem provides an alternative form of the Pell equation `x^2 - d*y^2 = 1` that is convenient for rewriting expressions involving `d * y^2`. Specifically, for any integer `d` and any solution `a` to the Pell equation with that `d`, the product of `d` and the square of the `y`-component of the solution (`d * y^2`) equals the square of the `x`-component of the solution minus one (`x^2 - 1`).

For any integer `d` and solution `(x, y)` to the Pell equation `x^2 - d*y^2 = 1`, we have `d * y^2 = x^2 - 1`.


theorem FiniteDimensional.lt_rank_of_lt_finrank :
    ∀ {R : Type u} {M : Type v} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] {n : ℕ},
      n < FiniteDimensional.finrank R M → ↑n < Module.rank R M :=
  by sorry

This theorem states that for any ring `R`, additive commutative group `M`, and module `M` over `R`, if a natural number `n` is less than the finite rank of the module `M` over `R` (denoted by `FiniteDimensional.finrank R M`), then the cardinality of `n` (denoted by `↑n`) is less than the rank of the module `M` over `R` (denoted by `Module.rank R M`). In more mathematical terms, for any module over a ring, if a natural number is less than the finite dimension of the module, then its cardinality is also less than the rank of the module.

For any ring `R`, additive commutative group `M` being an `R`-module, and natural number `n` with `n < FiniteDimensional.finrank R M`, we have `↑n < Module.rank R M`.


theorem iSup_sigma :
    ∀ {α : Type u_1} {β : Type u_2} [inst : CompleteLattice α] {p : β → Type u_9} {f : Sigma p → α},
      ⨆ x, f x = ⨆ i, ⨆ j, f { fst := i, snd := j } :=
  by sorry

This theorem states that for any types `α` and `β`, where `α` is a complete lattice, and any function `f` from a dependent pair (Sigma type) `p` of `β` to `α`, the supremum (maximum) value of `f` over all `x` (which is a dependent pair of `β` and `p`) is equal to the nested supremum of `f` over all `i` and `j`, where `i` is of type `β` and `j` is of type `p i`. In other words, this theorem establishes an equivalence between a direct supremum over a dependent pair and a nested supremum over each component of the pair.

For any complete lattice α and function f from a dependent Sigma type p of β to α, the supremum of f over all x (dependent pairs i, j of β and p) is equal to the nested supremum over all i in β of the supremum of f over j (p i).


theorem Fin.succ_injective : ∀ (n : ℕ), Function.Injective Fin.succ := by sorry

This theorem states that, for every natural number `n`, the `Fin.succ` function is injective. In other words, if `Fin.succ` is applied to two distinct values of the type `Fin n`, it will yield two distinct values of the type `Fin (Nat.succ n)`. In mathematical terms, if we have `Fin.succ x = Fin.succ y`, it necessarily follows that `x = y`.

For every natural number `n`, the function `Fin.succ : Fin n -> Fin (Nat.succ n)` is an injection.


theorem List.Ico.append_consecutive : ∀ {n m l : ℕ}, n ≤ m → m ≤ l → List.Ico n m ++ List.Ico m l = List.Ico n l := by
  sorry

The theorem `List.Ico.append_consecutive` states that for any natural numbers `n`, `m`, and `l`, if `n` is less than or equal to `m` and `m` is less than or equal to `l`, then the list of natural numbers from `n` to `m` (including `n` but excluding `m`), appended with the list of natural numbers from `m` to `l` (including `m` but excluding `l`), is equal to the list of natural numbers from `n` to `l` (including `n` but excluding `l`). This essentially means that we can concatenate two consecutive intervals to form a larger interval.

For any natural numbers `n`, `m`, and `l` with `n ≤ m ≤ l`, the list of natural numbers from `n` to `m` followed by the list of natural numbers from `m` to `l` is equal to the list of natural numbers from `n` to `l`.


/-- One direction of the **Borel-Cantelli lemma** (sometimes called the "*first* Borel-Cantelli
lemma"): if (sᵢ) is a sequence of sets such that `∑ μ sᵢ` is finite, then the limit superior of the
`sᵢ` is a null set.

Note: for the *second* Borel-Cantelli lemma (applying to independent sets in a probability space),
see `ProbabilityTheory.measure_limsup_eq_one`.  -/
theorem MeasureTheory.measure_limsup_eq_zero :
    ∀ {α : Type u_1} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} {s : ℕ → Set α},
      ∑' (i : ℕ), ↑↑μ (s i) ≠ ⊤ → ↑↑μ (Filter.limsup s Filter.atTop) = 0 :=
  by sorry

This theorem represents one direction of the Borel-Cantelli lemma, commonly known as the "first" Borel-Cantelli lemma. The theorem states that for any sequence of sets `(sᵢ)` in a measureable space with measure `μ`, if the series of the measures of the sets `(sᵢ)` is finite (i.e., `∑ μ sᵢ` is not infinite), then the measure of the limit superior of the sequence of sets `(sᵢ)` as it approaches infinity (i.e., `limsup sᵢ` as `i → ∞`) is equal to zero. This means that, under these conditions, the limit superior of the sequence of sets `(sᵢ)` is a null set.

Please note that there is also a "second" Borel-Cantelli lemma which applies to independent sets in a probability space. For that, refer to `ProbabilityTheory.measure_limsup_eq_one`.

If `(sᵢ)` is a sequence of measurable sets in a measure space with finite sum of measures `∑ μ sᵢ`, then `limsup sᵢ` has measure zero.


theorem Set.preimage_add_const_uIcc :
    ∀ {α : Type u_1} [inst : LinearOrderedAddCommGroup α] (a b c : α),
      (fun x => x + a) ⁻¹' Set.uIcc b c = Set.uIcc (b - a) (c - a) :=
  by sorry

The theorem `Set.preimage_add_const_uIcc` states that for any linearly ordered additive commutative group `α` and any elements `a`, `b`, and `c` of `α`, the preimage of the set of elements lying between `b` and `c` (inclusive) under the function that adds `a` to each element is the set of elements lying between `b - a` and `c - a` (inclusive). In other words, shifting all elements in a set by a constant `a` in this group corresponds to shifting the lower and upper bounds of the set by `-a`.

For any linearly ordered additive commutative group α and elements a, b, and c of α, the preimage of the set {x : α | b ≤ x ≤ c} under the function x => x + a is {x : α | b - a ≤ x ≤ c - a}.


theorem WithTop.one_ne_top : ∀ {α : Type u} [inst : One α], 1 ≠ ⊤ := by sorry

This theorem states that for any given type `α`, assuming that `α` has an identity element under multiplication (denoted as `1`), the identity element `1` is not equal to the top element, denoted as `⊤`. In other words, within the context of an algebraic structure where a multiplicative identity exists, that identity cannot be considered the top or maximum element.

In any algebraic structure with a multiplicative identity, the identity element is distinct from the top element.


IsGδ.iInter

/-- The intersection of an encodable family of Gδ sets is a Gδ set.  -/
theorem IsGδ.iInter :
    ∀ {X : Type u_1} {ι' : Sort u_4} [inst : TopologicalSpace X] [inst_1 : Countable ι'] {s : ι' → Set X},
      (∀ (i : ι'), IsGδ (s i)) → IsGδ (⋂ i, s i) :=
  by sorry

This theorem states that the intersection of an encodable family of Gδ sets is also a Gδ set. In more detail, given any type `X` with a topological space structure, and an encodable sort `ι'`, if we have a function `s` from `ι'` to the sets of `X` such that each `s i` (for every `i` in `ι'`) is a Gδ set, then the intersection of all the `s i` is also a Gδ set. Remember, a Gδ set is defined as a countable intersection of open sets in the given topology.

Given a topological space `X` and an encodable family `{s i | i ∈ ι'}` of Gδ sets, their intersection is also a Gδ set.


theorem WithLp.prod_norm_eq_add :
    ∀ {p : ENNReal} {α : Type u_2} {β : Type u_3} [inst : Norm α] [inst_1 : Norm β],
      0 < p.toReal → ∀ (f : WithLp p (α × β)), ‖f‖ = (‖f.1‖ ^ p.toReal + ‖f.2‖ ^ p.toReal) ^ (1 / p.toReal) :=
  by sorry

The theorem `WithLp.prod_norm_eq_add` states that for all extended nonnegative real numbers `p` greater than zero and for any function `f` with L^p norm in the product space of two types `α` and `β` (which have a norm structure), the norm of `f` is equal to the p-th root of the sum of the p-th powers of the norms of the first and second components of `f`. This is a statement about the calculation of L^p norms in product spaces.

For any function `f` in the product space of types `α` and `β` with L^p norm, where `p > 0`, the L^p norm of `f` equals the p-th root of the sum of the p-th powers of the L^p norms of its first and second components.


theorem periodic_expMapCircle : Function.Periodic (⇑expMapCircle) (2 * Real.pi) := by sorry

The theorem `periodic_expMapCircle` states that the function `expMapCircle`, which maps a real number `t` to the unit circle in the complex plane via the expression `exp(t * I)`, is periodic. The period of this function is `2 * Real.pi`, i.e., twice the mathematical constant π. In other words, for all real numbers `t`, the value of `expMapCircle` at `t + 2π` is the same as its value at `t`.

The complex function `exp(z => t * I)` (where `I` is the imaginary unit and `t` is a real number), denoted `expMapCircle`, is a periodic function with period `2 * Real.pi`.


theorem ZFSet.mem_wf : WellFounded fun x x_1 => x ∈ x_1 := by sorry

This theorem, `ZFSet.mem_wf`, states that the membership relation "∈" on Zermelo-Fraenkel sets is well-founded. This means that there are no infinite descending chains of elements, i.e., there does not exist an infinite sequence {x1, x2, x3, ...} of sets such that x_{n+1} ∈ x_n for all natural numbers n. This property is essential in the set theory to avoid paradoxes such as Russell's paradox.

The theorem `ZFSet.mem_wf` asserts that the membership relation on Zermelo-Fraenkel sets is well-founded, ensuring the absence of infinite descending chains.


theorem locallyConnectedSpace_of_connected_bases :
    ∀ {α : Type u} [inst : TopologicalSpace α] {ι : Type u_3} (b : α → ι → Set α) (p : α → ι → Prop),
      (∀ (x : α), Filter.HasBasis (nhds x) (p x) (b x)) →
        (∀ (x : α) (i : ι), p x i → IsPreconnected (b x i)) → LocallyConnectedSpace α :=
  by sorry

The theorem `locallyConnectedSpace_of_connected_bases` states that for any type `α` equipped with a `TopologicalSpace` instance, and any indexing type `ι`, given a family of sets `b` indexed by `α` and `ι`, and a property `p` dependent on `α` and `ι`, under the conditions that for every `x` in `α`, the neighborhood filter `nhds x` has a basis given by the sets `b x i` for which `p x i` holds, and for each `x` in `α` and `i` in `ι`, if `p x i` holds, then `b x i` is preconnected, then `α` is a locally connected space. In simpler terms, if a topological space has a basis of preconnected sets for every point's neighborhood filter, then it is a locally connected space.

If for every point in a topological space and every neighborhood filter, there exists a basis of preconnected sets, then the space is locally connected.


/-- The Lusin-Souslin theorem: if `s` is Borel-measurable in a Polish space, then its image under
a continuous injective map is also Borel-measurable.  -/
theorem MeasurableSet.image_of_continuousOn_injOn :
    ∀ {γ : Type u_3} {β : Type u_4} [tβ : TopologicalSpace β] [inst : T2Space β] [inst : MeasurableSpace β] {s : Set γ}
      {f : γ → β} [inst_1 : OpensMeasurableSpace β] [tγ : TopologicalSpace γ] [inst_2 : PolishSpace γ]
      [inst_3 : MeasurableSpace γ] [inst_4 : BorelSpace γ],
      MeasurableSet s → ContinuousOn f s → Set.InjOn f s → MeasurableSet (f '' s) :=
  by sorry

The Lusin-Souslin theorem states that if a set `s` is Borel-measurable in a Polish space (a complete, separable metric space), then the image of `s` under a continuous, injective function is also Borel-measurable. This theorem is applicable for any set `s` in a topological space `γ` and function `f` from `γ` to another topological space `β`. The conditions are that `s` must be measurable, the function `f` must be continuous on `s`, and `f` must be injective on `s`. The theorem then concludes that the image of `s` under `f` is also a measurable set.

If `s` is a Borel-measurable subset of a Polish space and `f` is a continuous, injective function, then the image `f(s)` is a Borel-measurable subset of the range space.


theorem MeasureTheory.inv_absolutelyContinuous :
    ∀ {G : Type u_1} [inst : MeasurableSpace G] [inst_1 : Group G] [inst_2 : MeasurableMul₂ G]
      (μ : MeasureTheory.Measure G) [inst_3 : MeasureTheory.SigmaFinite μ] [inst_4 : MeasurableInv G]
      [inst_5 : MeasureTheory.Measure.IsMulLeftInvariant μ],
      MeasureTheory.Measure.AbsolutelyContinuous (MeasureTheory.Measure.inv μ) μ :=
  by sorry

The theorem `MeasureTheory.inv_absolutelyContinuous` states that for any group `G` with a measurable space structure, a measurable multiplication operation, an inversion operation, and any `sigma-finite` measure `μ` on `G` that is left invariant under multiplication, the measure `A ↦ μ (A⁻¹)` (the pointwise inverse of `A`) is absolutely continuous with respect to `μ`. In other words, if a set `A` has measure `0` under `μ`, then its inverse also has measure `0` under `μ`.

If `μ` is a `σ-finite`, left-invariant, measurable measure on the measurable group `(G, Σ, μ)` with measurable multiplication and inversion operations, then the measure of the inverse of a set of measure 0 is also 0: `A ↦ μ(A⁻¹)` is absolutely continuous with respect to `μ`.


OpenEmbedding.comp

theorem OpenEmbedding.comp :
    ∀ {X : Type u_1} {Y : Type u_2} {Z : Type u_3} {f : X → Y} {g : Y → Z} [inst : TopologicalSpace X]
      [inst_1 : TopologicalSpace Y] [inst_2 : TopologicalSpace Z],
      OpenEmbedding g → OpenEmbedding f → OpenEmbedding (g ∘ f) :=
  by sorry

This theorem states that for all types X, Y, and Z, and for all functions f from X to Y and g from Y to Z, if they are equipped with topological spaces, then if g is an open embedding and f is also an open embedding, the composition of g and f (i.e., g ∘ f) is also an open embedding. In the context of topology, an open embedding is a function between two topological spaces that is an embedding (i.e., injective and homeomorphic to its image) and its image is an open subset.

If two open embeddings between topological spaces compose them, the result is an open embedding.


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

This theorem asserts that for any given type `α`, relation `r` on `α` that is decidable, transitive, antisymmetric and total, and any multiset `s` of type `α`, the sorted list obtained from multiset `s` by using the `Multiset.sort` operation, when converted back to a multiset, is equivalent to the original multiset `s`. This essentially means that the sorting process doesn't alter the original collection of elements, it just rearranges them in an ordered manner.

For any decidable, transitive, antisymmetric and total relation `r` on type `α` and multiset `s` of type `α`, `Multiset.sort r s` is equivalent to `s`.


theorem Matrix.neg_dotProduct :
    ∀ {m : Type u_2} {α : Type v} [inst : Fintype m] [inst_1 : NonUnitalNonAssocRing α] (v w : m → α),
      Matrix.dotProduct (-v) w = -Matrix.dotProduct v w :=
  by sorry

The theorem `Matrix.neg_dotProduct` states that for any types `m` and `α`, where `m` is a finite type and `α` is a non-unital, non-associative ring, given any two functions `v` and `w` from `m` to `α`, the dot product of the negation of `v` and `w` is equal to the negation of the dot product of `v` and `w`. This means that the negation operator can be pulled out of the dot product operation, essentially asserting that the dot product operation is compatible with scalar multiplication in the underlying ring.

For any finite type `m` and non-unital, non-associative ring `α`, the negation of the dot product of functions `v` and `w` from `m` to `α` is equal to the dot product of the negation of `v` and `w`.


theorem Pretrivialization.proj_symm_apply :
    ∀ {B : Type u_2} {F : Type u_3} {Z : Type u_5} [inst : TopologicalSpace B] [inst_1 : TopologicalSpace F]
      {proj : Z → B} (e : Pretrivialization F proj) {x : B × F},
      x ∈ e.target → proj (↑(PartialEquiv.symm e.toPartialEquiv) x) = x.1 :=
  by sorry

This theorem states that for any types `B`, `F`, and `Z` that are equipped with the structure of a topological space, and given a function `proj` from `Z` to `B`, a pretrivialization `e` of `F` with respect to `proj`, and a pair `x` of `B` and `F`, if `x` lies in the target of `e`, then applying `proj` to the element obtained by applying the inverse of the partial equivalence associated with `e` to `x` gives back the first component of `x`. In simpler terms, under these conditions, the projection function `proj` undoes the effect of applying the inverse of the partial equivalence on `x` to retrieve its first component.

Given a continuous function `proj : Z -> B`, a pretrivialization `e : F -> E` of `F` over `B`, and `x : B x F` such that `x_1 : B` is in the image of `proj` and `x = e.pi._1 x_1 ⊗ x.2`, then `proj (e.pi._2 x) = x_1`.


theorem HasDerivAtFilter.add_const :
    ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {F : Type v} [inst_1 : NormedAddCommGroup F]
      [inst_2 : NormedSpace 𝕜 F] {f : 𝕜 → F} {f' : F} {x : 𝕜} {L : Filter 𝕜},
      HasDerivAtFilter f f' x L → ∀ (c : F), HasDerivAtFilter (fun y => f y + c) f' x L :=
  by sorry

The theorem `HasDerivAtFilter.add_const` states that for any function `f` from a nontrivially normed field `𝕜` to a normed add commutative group `F` (with the associated normed space structure), if `f` has a derivative `f'` at a point `x` with respect to a filter `L`, then addition of a constant `c` from `F` to the function (i.e., the function `g` defined as `g(y) = f(y) + c`) does not change the derivative at that point with respect to the same filter. In other words, the derivative of the sum of a function and a constant is the same as the derivative of the original function with respect to the same point and filter.

If a function from a nontrivially normed field to a normed add commutative group has a derivative at a point with respect to a filter, then the derivative of the function at that point with respect to the filter is equal to the derivative of the function's constant addition to it.


theorem DenseInducing.extend_eq :
    ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] {i : α → β}
      (di : DenseInducing i) [inst_2 : TopologicalSpace γ] [inst_3 : T2Space γ] {f : α → γ},
      Continuous f → ∀ (a : α), DenseInducing.extend di f (i a) = f a :=
  by sorry

This theorem states that for any types `α`, `β`, and `γ` with `α`, `β`, and `γ` being topological spaces and `γ` also being a T2 space (Hausdorff space), for any function `i` from `α` to `β` which is a dense inducing function, and any continuous function `f` from `α` to `γ`, the value of the extension of `f` by `i` at `i(a)` is equal to `f(a)` for each `a` in `α`. Essentially, if you have a continuous function `f` and a dense inducing function `i`, you can extend `f` using `i` without changing its values.

For any dense inducing function `i` from a topological space `α` to another topological space `β`, and any continuous function `f` from `α` to a Hausdorff space `γ`, the extension of `f` by `i` equals `f` on the domain of `i`.


theorem Mathlib.Data.List.Sublists._auxLemma.4 :
    ∀ {α : Type u} {s t : List α}, (s ∈ List.sublists' t) = List.Sublist s t := by sorry

The theorem `Mathlib.Data.List.Sublists._auxLemma.4` states that for any type `α` and any lists `s` and `t` of type `α`, `s` is a member of the list of all (non-contiguous) sublists of `t` (as generated by `List.sublists'`) if and only if `s` is a sublist of `t`. Here, a sublist means a sequence of elements from the original list in the original order but not necessarily contiguous.

The theorem `Mathlib.Data.List.Sublists._auxLemma.4` in Lean 4 asserts that for all types `α` and lists `s` and `t` of `α`, `s` is a sublist of `t` if and only if `s` is a non-contiguous sublist of `t` as generated by `List.sublists'`.


theorem differentiableAt_inverse :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {R : Type u_6} [inst_1 : NormedRing R]
      [inst_2 : NormedAlgebra 𝕜 R] [inst_3 : CompleteSpace R] {x : R}, IsUnit x → DifferentiableAt 𝕜 Ring.inverse x :=
  by sorry

This theorem states that for every nontrivially normed field 𝕜 and a complete normed ring R over 𝕜, the function that sends a unit element `x` in R to its multiplicative inverse is differentiable at `x`. In simpler terms, the function that calculates the inverse of a unit in a certain complete normed ring is smooth at that unit point.

The function sending a unit in a complete normed ring over a nontrivially normed field to its multiplicative inverse is differentiable.


theorem Complex.exp_conj : ∀ (x : ℂ), Complex.exp ((starRingEnd ℂ) x) = (starRingEnd ℂ) (Complex.exp x) := by sorry

The theorem `Complex.exp_conj` states that for all complex numbers `x`, the complex exponential function applied to the complex conjugate of `x` is equal to the complex conjugate of the complex exponential function applied to `x`. In other words, taking the complex conjugate commutes with the complex exponential function. It can be written in mathematical notation as follows: ∀ x ∈ ℂ, exp(x*) = (exp(x))* where 'exp' is the complex exponential function and '*' denotes the complex conjugate.

For all complex numbers x, the complex conjugate of the complex exponential function equals the complex exponential function of the complex conjugate: exp(x\*). = (exp(x))\*.


theorem unitInterval.symm.proof_1 : ∀ (t : ↑unitInterval), 1 - ↑t ∈ unitInterval := by sorry

This theorem states that for every real number `t` in the unit interval `[0,1]`, the number `1 - t` is also in the unit interval. In other words, if you subtract any number from the unit interval `[0,1]` from `1`, the result will still be within the unit interval `[0,1]`.

For every real number `t` in the interval `[0, 1]`, `1 - t` also belongs to the interval `[0, 1]`.


theorem Ne.ite_eq_left_iff :
    ∀ {α : Sort u_2} {P : Prop} [inst : Decidable P] {a b : α}, a ≠ b → ((if P then a else b) = a ↔ P) := by sorry

The theorem states that for any two elements `a` and `b` of a certain type `α`, and a proposition `P` that is decidable (meaning its truth value can be determined), if `a` is not equal to `b`, then the if-then-else statement "if `P` then `a` else `b`" is equal to `a` if and only if `P` is true. This theorem characterizes the conditions under which an if-then-else statement with distinct cases is equal to one of its branches.

For any `α`, `a` and `b` in `α`, and decidable proposition `P` over `α`, if `a ≠ b` then `if P then a else b = a <=> P`.


theorem Ordinal.cof_le_card : ∀ (o : Ordinal.{u_2}), Ordinal.cof o ≤ Ordinal.card o := by sorry

The theorem `Ordinal.cof_le_card` states that for every ordinal `o`, the cofinality of `o` is less than or equal to the cardinality of `o`. In other words, the smallest cardinality of an unbounded subset of the ordinal `o` (cofinality) is always less than or equal to the cardinality of the type on which a relation with the order type defined by `o` exists (cardinality). This is applicable to all ordinals.

The cofinality of every ordinal is less than or equal to its cardinality.


theorem StructureGroupoid.LocalInvariantProp.congr_iff_nhdsWithin :
    ∀ {H : Type u_1} {H' : Type u_3} [inst : TopologicalSpace H] [inst_1 : TopologicalSpace H']
      {G : StructureGroupoid H} {G' : StructureGroupoid H'} {P : (H → H') → Set H → H → Prop},
      StructureGroupoid.LocalInvariantProp G G' P →
        ∀ {s : Set H} {x : H} {f g : H → H'}, f =ᶠ[nhdsWithin x s] g → f x = g x → (P f s x ↔ P g s x) :=
  by sorry

This theorem states that for any two types `H` and `H'` equipped with topological spaces, along with respective structure groupoids `G` and `G'`, and a property `P` that is a local invariant of these structure groupoids, then for any set `s` of type `H`, any element `x` of type `H`, and any two functions `f` and `g` from `H` to `H'`, if `f` and `g` are equal within the neighborhood of `x` intersected with `s` (i.e., equal almost everywhere in this neighborhood) and `f(x)` equals `g(x)`, then the property `P` holds for `f` at `x` in `s` if and only if it holds for `g` at `x` in `s`. In other words, the property `P` is invariant under almost-everywhere equality of functions in the neighborhood of a point.

If two functions between topological spaces with local invariant property `P` are equal almost everywhere in a neighborhood of a point `x` and have equal values at `x`, then `P` holds for both functions at `x`.


theorem MeasureTheory.Measure.map_def :
    ∀ {α : Type u_8} {β : Type u_9} [inst : MeasurableSpace β] [inst_1 : MeasurableSpace α] (f : α → β)
      (μ : MeasureTheory.Measure α),
      MeasureTheory.Measure.map f μ =
        if hf : AEMeasurable f μ then (MeasureTheory.Measure.mapₗ (AEMeasurable.mk f hf)) μ else 0 :=
  by sorry

The theorem `MeasureTheory.Measure.map_def` states that for any types `α` and `β` each equipped with a `MeasurableSpace` structure, and any function `f` from `α` to `β`, the pushforward of a measure `μ` under `f` is defined as follows: If `f` is almost everywhere measurable with respect to `μ`, then the pushforward is the same as applying the linear map version of the pushforward (`MeasureTheory.Measure.mapₗ`) to the measurable function that is equivalent to `f` almost everywhere. If `f` is not almost everywhere measurable, then the pushforward of `μ` is simply defined to be `0`.

If `f` is a almost everywhere measurable function between measurable spaces `(α, Σα, μ)` and `(β, Σβ, ν)`, then the pushforward measure `f_*μ` is equal to the application of the linear map version of pushforward to the equivalent measurable function of `f`. Otherwise, `f_*μ = 0`.


theorem Array.extract_loop_zero :
    ∀ {α : Type u_1} (as bs : Array α) (start : ℕ), Array.extract.loop as 0 start bs = bs := by sorry

The theorem `Array.extract_loop_zero` states that for any type `α`, and any arrays `as` and `bs` of this type, and any natural number `start`, when we execute the `Array.extract.loop` function with `as` as the input array, `0` as the iteration count, `start` as the starting index, and `bs` as the base case array, the result is just the base case array `bs`. Essentially, this theorem is asserting that if we don't run any iterations of the `Array.extract.loop` function, the output will be the initial array `bs`.

For any type `α`, and arrays `as:` `α`\[], `bs:` `α`\[], the result of applying `Array.extract.loop as 0 start bs` is equal to `bs`.


theorem MeasureTheory.Measure.zero_le :
    ∀ {α : Type u_1} {_m0 : MeasurableSpace α} (μ : MeasureTheory.Measure α), 0 ≤ μ := by sorry

This theorem states that for any type `α` with a measurable space `_m0` and any measure `μ` from the measure theory, the measure `μ` is always greater than or equal to zero. In other words, in the context of measure theory, a measure defined on a measurable space cannot be negative.

For any measurable space `(α, _m0)` and measure `μ` defined on it, `μ : ∀ (A : set α), 0 ≤ μ A`.


theorem Finset.Ico_disjoint_Ico_consecutive :
    ∀ {α : Type u_2} [inst : PartialOrder α] [inst_1 : LocallyFiniteOrder α] (a b c : α),
      Disjoint (Finset.Ico a b) (Finset.Ico b c) :=
  by sorry

The theorem `Finset.Ico_disjoint_Ico_consecutive` states that for any type `α` that is a partial order and locally finite order, and for any elements `a`, `b`, and `c` of `α`, the set of elements `x` such that `a ≤ x` and `x < b` is disjoint from the set of elements `x` such that `b ≤ x` and `x < c`. In other words, there is no element `x` that belongs to both sets, where belonging to a set is defined as `x` being greater than or equal to the lower bound and less than the upper bound of the set.

For any locally finite partial order type `α` and elements `a < b < c` in `α`, there are no elements sharing the same position in the sets `{x | a ≤ x < b}` and `{x | b ≤ x < c}`.


theorem decide_eq_true_iff : ∀ (p : Prop) [inst : Decidable p], decide p = true ↔ p := by sorry

This theorem states that for any proposition `p` and given that `p` is decidable (i.e., there exists a proof that `p` is either true or false), the `decide` function on `p` equals `true` if and only if `p` is true. In other words, the `decide` function accurately reflects the truth value of `p` – it returns `true` when `p` is true, and something other than `true` when `p` is not true.

For any decidable proposition `p` in Lean, `decide p = tt` if and only if `p` is true.


theorem Monoid.CoprodI.induction_on :
    ∀ {ι : Type u_1} {M : ι → Type u_2} [inst : (i : ι) → Monoid (M i)] {C : Monoid.CoprodI M → Prop}
      (m : Monoid.CoprodI M),
      C 1 →
        (∀ (i : ι) (m : M i), C (Monoid.CoprodI.of m)) → (∀ (x y : Monoid.CoprodI M), C x → C y → C (x * y)) → C m :=
  by sorry

This theorem, named `Monoid.CoprodI.induction_on`, is a principle of induction for the free product of an indexed family of monoids. In detail, it states that for any type `ι`, any indexed family of monoids `M` indexed by `ι`, and any property `C` pertaining to the elements of the free product of `M`, if the property `C` holds for the multiplicative identity `1`, for any element obtained by the inclusion of a summand into the free product, and is closed under multiplication, then `C` must hold for any element of the free product of `M`.

Given an indexed family of monoids `M` and a property `C` that holds for the multiplicative identity of each monoid and is closure under multiplication, `C` holds for any element in the free product of `M`.


/-- An auxiliary lemma that combines two “exponential of a power” estimates into a similar estimate
on the difference of the functions.  -/
theorem PhragmenLindelof.isBigO_sub_exp_rpow :
    ∀ {E : Type u_1} [inst : NormedAddCommGroup E] {a : ℝ} {f g : ℂ → E} {l : Filter ℂ},
      (∃ c < a, ∃ B, f =O[Bornology.cobounded ℂ ⊓ l] fun z => Real.exp (B * Complex.abs z ^ c)) →
        (∃ c < a, ∃ B, g =O[Bornology.cobounded ℂ ⊓ l] fun z => Real.exp (B * Complex.abs z ^ c)) →
          ∃ c < a, ∃ B, (f - g) =O[Bornology.cobounded ℂ ⊓ l] fun z => Real.exp (B * Complex.abs z ^ c) :=
  by sorry

The theorem `PhragmenLindelof.isBigO_sub_exp_rpow` is an auxiliary lemma in the context of complex analysis and big O notation regarding estimation of exponential functions of powers. It states that given two functions `f` and `g` that map from Complex numbers to a Normed Additive Commutative Group `E`, and a filter `l` on Complex numbers, if there exists a real number `B` and an exponent `c` less than a given real number `a` such that both `f` and `g` are bounded by the function `z => Real.exp (B * Complex.abs z ^ c)` under the filter obtained by intersecting the cobounded filter of the bornology of Complex numbers with `l`, then there also exists a such a real number `B` and an exponent `c` less than `a` for the difference of the functions `f` and `g`.

If functions `f` and `g` are bounded by `Real.exp(B * |z|^c)` under filter `l` for some `B` and `c` (with `c < a`), then `f - g` is also bounded by `Real.exp(B' * |z|^{c'})` for some `B'` and `c'` (with `c' < a`).


ContDiffWithinAt.inv

theorem ContDiffWithinAt.inv :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type uE} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {s : Set E} {x : E} {𝕜' : Type u_4} [inst_3 : NormedField 𝕜']
      [inst_4 : NormedAlgebra 𝕜 𝕜'] [inst_5 : CompleteSpace 𝕜'] {f : E → 𝕜'} {n : ℕ∞},
      ContDiffWithinAt 𝕜 n f s x → f x ≠ 0 → ContDiffWithinAt 𝕜 n (fun x => (f x)⁻¹) s x :=
  by sorry

This theorem, named `ContDiffWithinAt.inv`, states that for any nontrivially normed field `𝕜`, normed additive commutative group `E`, normed space `𝕜 E`, set `s` of elements of type `E`, element `x` of type `E`, normed field `𝕜'`, normed algebra `𝕜 𝕜'`, and complete space `𝕜'`, given a function `f` mapping elements of type `E` to `𝕜'` and a natural number `n` (possibly infinity), if this function `f` is continuously differentiable within the set `s` at the point `x` to order `n`, and the value of the function `f` at the point `x` is not equal to zero, then the function which maps `x` to the reciprocal of `f(x)` will also be continuously differentiable within the set `s` at the point `x` to order `n`. In other words, the reciprocal of a function that is continuously differentiable at a point, where the function's value is non-zero, is also continuously differentiable at that point.

If a function from a normed space to a normed field is continuously differentiable to order `n` at a point where its value is non-zero, then the reciprocal function is also continuously differentiable to order `n` at that point.


theorem FiniteDimensional.finrank_le_finrank_of_rank_le_rank :
    ∀ {R : Type u} {M : Type v} {N : Type w} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M]
      [inst_3 : AddCommGroup N] [inst_4 : Module R N],
      Cardinal.lift.{w, v} (Module.rank R M) ≤ Cardinal.lift.{v, w} (Module.rank R N) →
        Module.rank R N < Cardinal.aleph0 → FiniteDimensional.finrank R M ≤ FiniteDimensional.finrank R N :=
  by sorry

The theorem states that for any ring `R` and two modules `M` and `N` over this ring, if the rank of the module `M` is less than or equal to the rank of the module `N` when considering their cardinalities in possibly different universes, and if the rank of module `N` is less than the cardinality of the smallest infinite cardinal (ℵ₀), then the finite rank of `M` is less than or equal to the finite rank of `N`. The finite rank of a module is defined to be the cardinality of the module's rank converted to a natural number and is conventionally set to `0` if the module has infinite rank.

If `R` is a ring, `M` and `N` are `R`-modules with finite ranks, and the rank of `M` is less than or equal to the rank of `N` when considering their cardinalities in possibly different universes, and the rank of `N` is less than the smallest infinite cardinal, then the finite rank of `M` is less than or equal to the finite rank of `N`.


theorem csSup_le' :
    ∀ {α : Type u_1} [inst : ConditionallyCompleteLinearOrderBot α] {s : Set α} {a : α},
      a ∈ upperBounds s → sSup s ≤ a :=
  by sorry

This theorem, `csSup_le'`, states that for any type `α` that has a structure of a conditionally complete linear order with a least element (expressed as `ConditionallyCompleteLinearOrderBot α`), for any set `s` of elements of type `α`, and for any element `a` of type `α`, if `a` is in the set of upper bounds of `s` (expressed as `a ∈ upperBounds s`), then the supremum of `s` (expressed as `sSup s`) is less than or equal to `a`. In simpler terms, it says that the supremum of a set is always less than or equal to any of the set's upper bounds.

For any conditionally complete linear order `α` with a least element, and any set `s` of elements from `α` with upper bound `a`, the supremum of `s` is less than or equal to `a`.


theorem Multiset.filter_add :
    ∀ {α : Type u_1} (p : α → Prop) [inst : DecidablePred p] (s t : Multiset α),
      Multiset.filter p (s + t) = Multiset.filter p s + Multiset.filter p t :=
  by sorry

The theorem `Multiset.filter_add` states that for any type `α`, a predicate `p` (that can be decided for every element of type `α`), and two multisets `s` and `t` of type `α`, the result of filtering (i.e., keeping only those elements that satisfy the predicate `p`) the multiset formed by adding `s` and `t` (denoted as `s + t`) is the same as the result of adding the multisets obtained by filtering `s` and `t` separately (denoted as `Multiset.filter p s + Multiset.filter p t`). In simpler words, filtering a combined multiset is the same as combining the filtered multisets.

For any type `α` and predicate `p`, the multiset obtained by filtering `p` on the sum of two multisets `s` and `t` equals the sum of the multisets obtained by filtering `p` on `s` and `t` separately.


theorem gaugeRescale_zero :
    ∀ {E : Type u_1} [inst : AddCommGroup E] [inst_1 : Module ℝ E] (s t : Set E), gaugeRescale s t 0 = 0 := by sorry

The theorem `gaugeRescale_zero` states that for any given type `E` which is an additive commutative group and also a real number module, and for any two sets `s` and `t` of type `E`, the gauge rescale of 0 with respect to these sets is also 0. In other words, when you apply the function `gaugeRescale` with the sets `s` and `t` to the element 0 in `E`, the result is always 0. This function `gaugeRescale` is defined to map each point `x` to a point `y` on the same ray that has the same gauge (a measure of size in a certain sense) with respect to `t` as `x` has with respect to `s`.

For any additive commutative group `E` that is a real number module, and for any sets `s` and `t` of elements in `E`, the gauge rescale of 0 with respect to `s` and `t` is equal to 0.


theorem MeasureTheory.withDensityᵥ_add :
    ∀ {α : Type u_1} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} {E : Type u_3} [inst : NormedAddCommGroup E]
      [inst_1 : NormedSpace ℝ E] {f g : α → E},
      MeasureTheory.Integrable f μ →
        MeasureTheory.Integrable g μ →
          MeasureTheory.Measure.withDensityᵥ μ (f + g) =
            MeasureTheory.Measure.withDensityᵥ μ f + MeasureTheory.Measure.withDensityᵥ μ g :=
  by sorry

The theorem `MeasureTheory.withDensityᵥ_add` states that for a measurable space `α`, equipped with a measure `μ`, and a normed add commutative group `E` that also forms a normed space over the real numbers, if two functions `f` and `g` from `α` to `E` are both integrable with respect to `μ`, then the measure with density of the sum of `f` and `g` is equal to the sum of the measure with density of `f` and the measure with density of `g`. This is essentially a linearity property of the operation of forming a measure with density.

For measurable functions `f` and `g` from a measurable space `(α, Σ, μ)` to a normed add commutative group `E` over the real numbers, their sum `f + g` has the same measure with density as the sum of their individual measures with density, i.e., `∫(f + g) dμ = ∫f dμ + ∫g dμ`.


Function.Involutive.rightInverse

theorem Function.Involutive.rightInverse :
    ∀ {α : Sort u} {f : α → α}, Function.Involutive f → Function.RightInverse f f := by sorry

The theorem `Function.Involutive.rightInverse` states that for any type `α` and any function `f` from `α` to `α`, if `f` is involutive (meaning applying `f` twice to any input yields the original input), then `f` is also a right inverse to itself. That is, composing `f` with itself yields the identity function. In mathematical terms, if for all `x` in `α`, `f(f(x)) = x`, then `f ∘ f = id`, where `id` is the identity function.

If a function `f` from type `α` to `α` is involutive (i.e., `f(f(x)) = x` for all `x` in `α`), then `f` is its own right inverse (i.e., `f ∘ f = id`).


/-- The recursion `hermite (n+1) = (x - d/dx) (hermite n)`  -/
theorem Polynomial.hermite_succ :
    ∀ (n : ℕ),
      Polynomial.hermite (n + 1) = Polynomial.X * Polynomial.hermite n - Polynomial.derivative (Polynomial.hermite n) :=
  by sorry

This theorem establishes a recursive relation for the Hermite polynomials, which are commonly used in probability theory. For any given natural number `n`, the `(n + 1)`th Hermite polynomial can be computed as the product of the polynomial variable `X` and the `n`th Hermite polynomial, subtracted by the derivative of the `n`th Hermite polynomial. Formally, this relationship can be expressed as `hermite (n+1) = X * hermite(n) - d/dx (hermite n)`.

The Hermite polynomial of degree `n+1` is given recursively as `X * hermite(n) - d/dx (hermite n)`, where `X` is a polynomial variable and `hermite` denotes the Hermite polynomial function.