theorem Finset.image_univ_of_surjective :
    ∀ {α : Type u_1} {β : Type u_2} [inst : Fintype α] [inst_1 : DecidableEq α] [inst_2 : Fintype β] {f : β → α},
      Function.Surjective f → Finset.image f Finset.univ = Finset.univ :=
  by sorry

This theorem states that for any two types `α` and `β`, given that `α` and `β` are finite types (`Fintype`), `α` has decidable equality (`DecidableEq`), and `f` is a function from `β` to `α`, if `f` is surjective (i.e., for every element in `α`, there is an element in `β` such that the function `f` maps this element of `β` to that element of `α`), then the image of the universal finite set of `β` under the function `f` is equal to the universal finite set of `α`. In other words, applying `f` to every element of `β` gives us every element of `α`.

If `α` and `β` are finite types with decidable equality, `f` is a surjective function from `β` to `α`, then the image of the universal set of `β` under `f` equals the universal set of `α`.


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

The theorem `PiNat.mem_cylinder_firstDiff` states that for any two sequences `x` and `y` in a product space `Π n, E n` (where `E` is a function from the set of natural numbers to some type), the sequence `x` belongs to the cylinder set around `y` of length equal to the first index at which `x` and `y` differ, as indicated by `PiNat.firstDiff x y`. In other words, the sequences `x` and `y` are identical up to the index given by `PiNat.firstDiff x y`, and this index is the length of the cylinder set that `x` belongs to.

For any sequences `x` and `y` in a product space `Π n, E n`, `x` belongs to the cylinder set around `y` of length `PiNat.firstDiff x y`.


Wbtw.collinear

theorem Wbtw.collinear :
    ∀ {R : Type u_1} {V : Type u_2} {P : Type u_4} [inst : LinearOrderedField R] [inst_1 : AddCommGroup V]
      [inst_2 : Module R V] [inst_3 : AddTorsor V P] {x y z : P}, Wbtw R x y z → Collinear R {x, y, z} :=
  by sorry

This theorem states that for any given types `R`, `V`, `P` where `R` is a linear ordered field, `V` is an additive commutative group, `P` is a type with a torsor structure over `V`, and given any three points `x`, `y`, `z` of type `P`, if `y` is weakly between `x` and `z` (that is, `y` belongs to the affine segment between `x` and `z`), then the set of points `{x,y,z}` is collinear. In other words, if `y` lies between `x` and `z`, then `x`, `y`, and `z` all lie on the same line.

Given a linear ordered field `R`, an additive commutative group `V`, and a torsor `P` over `V`, if `y` is weakly between `x` and `z` in `P`, then `x`, `y`, and `z` are collinear points in `P`.


theorem Polynomial.mem_map_rangeS :
    ∀ {R : Type u} {S : Type v} [inst : Semiring R] [inst_1 : Semiring S] (f : R →+* S) {p : Polynomial S},
      p ∈ RingHom.rangeS (Polynomial.mapRingHom f) ↔ ∀ (n : ℕ), Polynomial.coeff p n ∈ RingHom.rangeS f :=
  by sorry

This theorem states that for any semirings `R` and `S`, any ring homomorphism `f` from `R` to `S`, and any polynomial `p` with coefficients from `S`, `p` belongs to the range of the semiring induced by the ring homomorphism `f` mapped over the polynomials (`RingHom.rangeS (Polynomial.mapRingHom f)`) if and only if all the coefficients of `p` (`Polynomial.coeff p n` for all natural numbers `n`) belong to the range of the semiring induced by `f` (`RingHom.rangeS f`). In other words, a polynomial is in the range of the polynomial map of a ring homomorphism if and only if its coefficients are in the range of the original ring homomorphism.

A polynomial lies in the range of the polynomial map of a ring homomorphism if and only if all its coefficients are in the image of the homomorphism.


theorem Rat.nonneg_iff_zero_le : ∀ {a : ℚ}, Rat.Nonneg a ↔ 0 ≤ a := by sorry

The theorem `Rat.nonneg_iff_zero_le` states that for every rational number 'a', 'a' is nonnegative (as defined by the function `Rat.Nonneg`) if and only if 'a' is greater than or equal to zero. In other words, a rational number 'a' is nonnegative if its numerator is nonnegative, and this is equivalent to 'a' being greater than or equal to zero.

For every rational number 'a', 'a' is nonnegative if and only if its numerator is nonnegative or equivalently, 'a' is greater than or equal to zero.


FreeGroup.map.unique

theorem FreeGroup.map.unique :
    ∀ {α : Type u} {β : Type v} {f : α → β} (g : FreeGroup α →* FreeGroup β),
      (∀ (x : α), g (FreeGroup.of x) = FreeGroup.of (f x)) → ∀ {x : FreeGroup α}, g x = (FreeGroup.map f) x :=
  by sorry

This theorem states that for any two types `α` and `β`, and any function `f` from `α` to `β`, if we have a group homomorphism `g` from the free group over `α` to the free group over `β` such that `g` when applied to any element `x` of `α` (considered as an element of the free group over `α` via the canonical injection `FreeGroup.of`) gives the same result as first applying the function `f` to `x` and then considering the result as an element of the free group over `β` (also via `FreeGroup.of`), then this group homomorphism `g` is equal to the unique group homomorphism from the free group over `α` to the free group over `β` that extends the function `f`, i.e., `g` equals `FreeGroup.map f` applied to any element of the free group over `α`. In short, any function from `α` to `β` extends uniquely to a group homomorphism from the free group over `α` to the free group over `β`.

Given any function between types `α` and `β`, there exists a unique group homomorphism from the free group over `α` to the free group over `β` extending that function.


theorem LinearMap.funLeft_id :
    ∀ (R : Type u_1) (M : Type u_9) [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {n : Type u_21}
      (g : n → M), (LinearMap.funLeft R M id) g = g :=
  by sorry

This theorem states that for any semiring `R`, an additive commutative monoid `M`, and a module `M` over `R`, given a function `g` from an arbitrary type `n` to `M`, applying the function `LinearMap.funLeft R M id` to `g` results in `g` itself. In other words, the function `LinearMap.funLeft R M id` acts as an identity for any function from `n` to `M`.

For any semiring R, additive commutative monoid M, and R-module M, the function `LinearMap.funLeft R M id` is the identity for any function from an arbitrary type to M.


theorem MeasureTheory.Content.outerMeasure_eq_iInf :
    ∀ {G : Type w} [inst : TopologicalSpace G] (μ : MeasureTheory.Content G) [inst_1 : R1Space G] (A : Set G),
      ↑(MeasureTheory.Content.outerMeasure μ) A =
        ⨅ U, ⨅ (hU : IsOpen U), ⨅ (_ : A ⊆ U), MeasureTheory.Content.innerContent μ { carrier := U, is_open' := hU } :=
  by sorry

The theorem `MeasureTheory.Content.outerMeasure_eq_iInf` states that for all types `G` equipped with a `TopologicalSpace` instance, for a given measure content `μ` and for a `Set` `A` of type `G`, the outer measure of `A` under the measure content `μ` is equal to the infimum of the inner content of all open sets `U` that contain `A`. The inner content of a set in this context is the supremum of the content of all its compact subsets. In other words, the outer measure of a set can be calculated as the infimum of the inner content of all open supersets of the set.

The outer measure of a set in a topological space, with respect to a measure content, is equal to the infimum of the inner contents of all open sets containing the set.


theorem le_iSup_inf_iSup :
    ∀ {α : Type u_1} {ι : Sort u_5} [inst : CompleteLattice α] (f g : ι → α), ⨆ i, f i ⊓ g i ≤ (⨆ i, f i) ⊓ ⨆ i, g i :=
  by sorry

This theorem, `le_iSup_inf_iSup`, states that for any type `α` that forms a complete lattice, and for any two functions `f` and `g` from some index type `ι` to `α`, the supremum (i.e., least upper bound) over the index `i` of the infimum (greatest lower bound) of `f i` and `g i` is less than or equal to the infimum of the suprema of `f i` and `g i`. In mathematical terms, it's saying that `⨆ i, (f i ⊓ g i) ≤ (⨆ i, f i) ⊓ (⨆ i, g i)`.

For any complete lattice `α` and functions `f` and `g` from an index type `ι` to `α`, the infimum of the suprema of `f(i)` and `g(i)` over all `i` is greater than or equal to the supremum of the infima of `f(i)` and `g(i)` for all `i`. (The original statement is equivalent but negated and has a different focus on bounds.)


theorem Polynomial.roots_X :
    ∀ {R : Type u} [inst : CommRing R] [inst_1 : IsDomain R], Polynomial.roots Polynomial.X = {0} := by sorry

This theorem states that for all types `R` that have a commutative ring structure and are integral domains, the roots of the polynomial `X` (which represents the polynomial variable or indeterminate) are given by the singleton set containing only the number zero. In other words, the only root (solution) of the polynomial `X` in any integral domain is zero.

In an integral domain with a commutative ring structure, the polynomial `X` has only the number zero as a root.


theorem CategoryTheory.ShortComplex.RightHomologyData.ι_g' :
    ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
      {S : CategoryTheory.ShortComplex C} (h : CategoryTheory.ShortComplex.RightHomologyData S),
      CategoryTheory.CategoryStruct.comp h.ι (CategoryTheory.ShortComplex.RightHomologyData.g' h) = 0 :=
  by sorry

This theorem states that in any category `C` endowed with zero morphisms, given any short complex `S` of `C` and any right homology data `h` pertaining to `S`, the composition of `h.ι` and `g'` related to `h` is zero. Here `h.ι` is a morphism from `h.I` to `h.Q` and `CategoryTheory.ShortComplex.RightHomologyData.g' h` is the morphism from `h.Q` to `S.X₃` induced by `S.g` and the fact that `h.Q` is a cokernel of `S.f`. In essence, it's stating a property of the commutativity of the diagram involving those objects and morphisms in the category `C`.

In any abelian category with zero morphisms, the composition of the right homology morphism with the connecting morphism induced by a short exact sequence is zero.


theorem norm_cexp_neg_mul_sq : ∀ (b : ℂ) (x : ℝ), ‖Complex.exp (-b * ↑x ^ 2)‖ = Real.exp (-b.re * x ^ 2) := by sorry

This theorem states that for any complex number `b` and any real number `x`, the norm of the complex exponential function applied to the product of `-b` and the square of `x` is equal to the real exponential function applied to the product of the negative of the real part of `b` and the square of `x`. In mathematical terms, for all complex `b` and real `x`, we have ||exp(-b * x^2)|| = exp(-Re(b) * x^2).

 For all complex numbers `b` and real numbers `x`, ||exp(-b * x^2)|| = exp(-Re(b) * x^2).

Alternatively, the norm of the complex exponential function of `-b * x^2` equals the real exponential function of `-Re(b) * x^2`.


theorem Monoid.Coprod.lift_comp_swap :
    ∀ {M : Type u_1} {N : Type u_2} {P : Type u_3} [inst : MulOneClass M] [inst_1 : MulOneClass N] [inst_2 : Monoid P]
      (f : M →* P) (g : N →* P),
      MonoidHom.comp (Monoid.Coprod.lift f g) (Monoid.Coprod.swap N M) = Monoid.Coprod.lift g f :=
  by sorry

The theorem `Monoid.Coprod.lift_comp_swap` states that for any types `M`, `N`, and `P`, where `M` and `N` are instances of the class `MulOneClass` and `P` is an instance of `Monoid`, and given two monoid homomorphisms `f : M →* P` and `g : N →* P`, the composition of the function `Monoid.Coprod.lift f g` with the function `Monoid.Coprod.swap N M` is equal to `Monoid.Coprod.lift g f`. In other words, swapping the inputs of the operation `Monoid.Coprod.lift` and then applying the original operation is the same as directly applying the operation to the swapped inputs.

For any types `M`, `N`, and `P` where `M` and `N` are monoids with one, and `P` is a monoid, the functions `Monoid.Coprod.lift f g` and `Monoid.Coprod.lift g f` are equal as maps from `M × N` to `P`, where `f : M →* P` and `g : N →* P` are homomorphisms.


theorem Lists'.cons_subset :
    ∀ {α : Type u_1} {a : Lists α} {l₁ l₂ : Lists' α true}, Lists'.cons a l₁ ⊆ l₂ ↔ a ∈ l₂ ∧ l₁ ⊆ l₂ := by sorry

This theorem states that for any type `α`, any ZFA list `a` of type `α`, and any two proper ZFA prelists `l₁` and `l₂` of type `α`, appending `a` to the front of `l₁` is a subset of `l₂` if and only if `a` is an element of `l₂` and `l₁` is a subset of `l₂`. In other words, the ZFA list `a` and the prelist `l₁` must both be subsets of, or included in, the prelist `l₂` for the operation of appending `a` to `l₁` to result in a prelist that is also a subset of `l₂`.

For any type `α`, ZFA list `a` of type `α`, and proper ZFA prelists `l₁` and `l₂` of type `α`, if `a ∈ l₂` and `l₁ ⊆ l₂`, then `a :: l₁ ⊆ l₂`, where `::` denotes the operation of appending an element to the front of a list.


theorem holderOnWith_univ :
    ∀ {X : Type u_1} {Y : Type u_2} [inst : PseudoEMetricSpace X] [inst_1 : PseudoEMetricSpace Y] {C r : NNReal}
      {f : X → Y}, HolderOnWith C r f Set.univ ↔ HolderWith C r f :=
  by sorry

This theorem is about the equivalence of the two definitions of Hölder continuity in the context of pseudo-emetric spaces. For all pseudo-emetric spaces `X` and `Y`, a non-negative real number `C`, a non-negative real number `r`, and a function `f` from `X` to `Y`, the theorem states that `f` is Hölder continuous with constant `C` and exponent `r` on the universal set of `X` (which includes all elements of `X`) if and only if `f` is Hölder continuous with constant `C` and exponent `r` on `X`. In other words, a function is Hölder continuous on the entire space `X` if and only if it is Hölder continuous for every pair of points in `X`.

A function between pseudo-metric spaces is Hölder continuous with constant C and exponent r on the entire space if and only if it is Hölder continuous with that constant and exponent between any two points in the space.


/-- The "monotone chain condition" below is sometimes a convenient form of well foundedness.  -/
theorem WellFounded.monotone_chain_condition :
    ∀ {α : Type u_1} [inst : PartialOrder α],
      (WellFounded fun x x_1 => x > x_1) ↔ ∀ (a : ℕ →o α), ∃ n, ∀ (m : ℕ), n ≤ m → a n = a m :=
  by sorry

This theorem, known as the "monotone chain condition", states that for any type `α` with a partial order, the well-foundedness of the "greater than" relation is equivalent to the following condition: for any strictly increasing sequence `a` of elements of `α` indexed by natural numbers, there exists a natural number `n` such that for all natural numbers `m` greater than or equal to `n`, the `m`-th element of the sequence `a` is the same as the `n`-th element. In mathematical terms, this condition states that any non-decreasing sequence of elements in `α` eventually becomes constant.

The monotone chain condition in a partially ordered type `α` asserts that a well-founded "greater than" relation implies that every strictly increasing sequence has a minimal element.


theorem Int.le.dest_sub : ∀ {a b : ℤ}, a ≤ b → ∃ n, b - a = ↑n := by sorry

This theorem states that for any two integer values 'a' and 'b', if 'a' is less than or equal to 'b', then there exists a natural number 'n' such that the difference of 'b' and 'a' is equal to 'n'. In other words, every nonnegative difference between two integers can be expressed as a natural number.

For any integers 'a' and 'b' with 'a' ≤ 'b', there exists a natural number 'n' such that 'b' = 'a' + 'n'.


theorem CategoryTheory.ShortComplex.Homotopy.eq_add_nullHomotopic :
    ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
      {S₁ S₂ : CategoryTheory.ShortComplex C} {φ₁ φ₂ : S₁ ⟶ S₂} (h : CategoryTheory.ShortComplex.Homotopy φ₁ φ₂),
      φ₁ = φ₂ + CategoryTheory.ShortComplex.nullHomotopic S₁ S₂ h.h₀ ⋯ h.h₁ h.h₂ h.h₃ ⋯ :=
  by sorry

This theorem states that in the context of a category `C`, which is preadditive (i.e., has a structure of an additive category), for any two morphisms `φ₁` and `φ₂` from one short complex `S₁` to another `S₂` such that there exists a homotopy `h` between them, `φ₁` is equal to the sum of `φ₂` and a "null-homotopic" morphism. The null-homotopic morphism is defined using `h.h₀`, `h.h₁`, `h.h₂`, `h.h₃`, etc., which are presumably the data defining the homotopy `h`. In other words, any morphism can be decomposed into another morphism and a null-homotopic one, given that there exists a homotopy between them.

In a preadditive category `C`, any two morphisms between complexes with a homotopy between them can be expressed as the sum of one morphism and a null-homotopic morphism using the homotopy data.


theorem selfAdjoint.val_smul :
    ∀ {R : Type u_1} {A : Type u_2} [inst : Star R] [inst_1 : TrivialStar R] [inst_2 : AddGroup A]
      [inst_3 : StarAddMonoid A] [inst_4 : SMul R A] [inst_5 : StarModule R A] (r : R) (x : ↥(selfAdjoint A)),
      ↑(r • x) = r • ↑x :=
  by sorry

The theorem `selfAdjoint.val_smul` states that for any type `R` equipped with a star operation and a trivial star operation, and for any type `A` equipped with an additive group structure, a star-addition operation, scalar multiplication, and a star module structure, the scalar multiplication of any scalar `r` from `R` and any element `x` from the set of self-adjoint elements in `A` is unchanged when the operation is carried out within the set of self-adjoint elements or in the larger set `A`. More precisely, if `x` is a self-adjoint element of `A` and `r` is a scalar, then the scalar multiplication of `r` and `x` in the subgroup of self-adjoint elements is equal to the scalar multiplication of `r` and `x` in the group `A`.

For any self-adjoint element `x` in an additive group `A` equipped with a star operation and a star module structure over a commutative ring `R` with a trivial star operation, and for any scalar `r` in `R`, the scalar multiplication `r * x` is the same in the subgroup of self-adjoint elements as in `A`.


/-- **Minkowski inequality**: the `L_p` seminorm of the infinite sum of two vectors is less than or
equal to the infinite sum of the `L_p`-seminorms of the summands, if these infinite sums both
exist. A version for `NNReal`-valued functions. For an alternative version, convenient if the
infinite sums are already expressed as `p`-th powers, see `Lp_add_le_hasSum_of_nonneg`.  -/
theorem NNReal.Lp_add_le_tsum :
    ∀ {ι : Type u} {f g : ι → NNReal} {p : ℝ},
      1 ≤ p →
        (Summable fun i => f i ^ p) →
          (Summable fun i => g i ^ p) →
            (Summable fun i => (f i + g i) ^ p) ∧
              (∑' (i : ι), (f i + g i) ^ p) ^ (1 / p) ≤
                (∑' (i : ι), f i ^ p) ^ (1 / p) + (∑' (i : ι), g i ^ p) ^ (1 / p) :=
  by sorry

The theorem states the **Minkowski inequality** for non-negative real-valued functions. Specifically, given any type `ι`, two functions `f` and `g` from `ι` to non-negative real numbers, and a real number `p` greater than or equal to 1, if the p-th powers of `f` and `g` are both summable, then the p-th power of the sum of `f` and `g` is also summable. Furthermore, the p-th root of the sum of these p-th powers is less than or equal to the sum of the p-th roots of the sum of the p-th powers of `f` and `g` individually. In mathematical terms, assume ∑(f(i)^p) and ∑(g(i)^p) are both convergent, then ∑((f(i) + g(i))^p) is also convergent. Moreover, (∑(f(i) + g(i))^p)^(1/p) ≤ (∑f(i)^p)^(1/p) + (∑g(i)^p)^(1/p). This theorem is a version of the Minkowski inequality for `NNReal`-valued functions, and is useful when the infinite sums are already expressed as p-th powers.

Given two non-negative real-valued functions `f` and `g` from an index type `ι` and real number `p ≥ 1`, if the p-th powers of `f` and `g` are summable, then the p-th power of their sum is also summable and their p-th roots of the sum of the p-th powers satisfy the inequality (∑((f(i) + g(i))^p))^(1/p) ≤ (∑(f(i)^p)^(1/p) + ∑(g(i)^p)^(1/p)).


IsLeast.unique

theorem IsLeast.unique :
    ∀ {α : Type u} [inst : PartialOrder α] {s : Set α} {a b : α}, IsLeast s a → IsLeast s b → a = b := by sorry

The theorem `IsLeast.unique` states that for any type `α` equipped with a partial order, a set `s` of type `α`, and any two elements `a` and `b` of type `α`, if `a` and `b` are both least elements of the set `s` (i.e., each belongs to `s` and is a lower bound of `s`), then `a` and `b` must be equal. This corresponds to the uniqueness property of the least element in a partially ordered set.

In a partially ordered set, if two elements are both the least elements, then they are equal.


theorem Int.add_lt_add : ∀ {a b c d : ℤ}, a < b → c < d → a + c < b + d := by sorry

This theorem states that for any four integers `a`, `b`, `c`, and `d`, if `a` is less than `b` and `c` is less than `d`, then the sum of `a` and `c` is less than the sum of `b` and `d`. This is a property of integer addition and comparison, asserting that the order of the numbers is preserved when adding two pairs of integers where each pair has a smaller and a larger number.

For all integers a, b, c, and d, if a < b and c < d then a + c < b + d.


theorem expMapCircle_add : ∀ (x y : ℝ), expMapCircle (x + y) = expMapCircle x * expMapCircle y := by sorry

This theorem states that for all real numbers `x` and `y`, the value of the function `expMapCircle` at the point `x + y` is equal to the product of `expMapCircle` evaluated at `x` and `expMapCircle` evaluated at `y`. In other words, the function `expMapCircle`, which maps real numbers to the unit circle in the complex plane using the exponential function, satisfies the property that the image of the sum of two real numbers is the product of their individual images. This property parallels the familiar one from trigonometry that the sum of two angles corresponds to the product of their complex exponentials.

For all real numbers x and y, expMapCircle (x + y) = expMapCircle x * expMapCircle y.


theorem HasSum.smul_const :
    ∀ {ι : Type u_5} {R : Type u_7} {M : Type u_9} [inst : Semiring R] [inst_1 : TopologicalSpace R]
      [inst_2 : TopologicalSpace M] [inst_3 : AddCommMonoid M] [inst_4 : Module R M] [inst_5 : ContinuousSMul R M]
      {f : ι → R} {r : R}, HasSum f r → ∀ (a : M), HasSum (fun z => f z • a) (r • a) :=
  by sorry

This theorem states that, for all types `ι`, `R`, and `M`, with `R` being a semiring and also topological space, `M` being a topological space, an additive commutative monoid, and a module over `R`, and the multiplication between `R` and `M` being continuous, if a function `f` from `ι` to `R` has a sum `r`, then for any element `a` of `M`, the function defined as the product of `f(z)` and `a` also has a sum, specifically `r • a`. This theorem relates the concept of sum in the case of functions with scalar multiplication.

For any semiring `R` that is a topological space, any topological space and additive commutative monoid `M` that is an `R`-module with continuous scalar multiplication, and any function `f` from a type `ι` to `R` with sum `r`, the function `x => r * a * f x` has sum `r * a`, where `a` is any element of `M`.


theorem SmoothBumpFunction.support_mem_nhds :
    ∀ {E : Type uE} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [inst_2 : FiniteDimensional ℝ E]
      {H : Type uH} [inst_3 : TopologicalSpace H] {I : ModelWithCorners ℝ E H} {M : Type uM}
      [inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] {c : M} (f : SmoothBumpFunction I c),
      Function.support ↑f ∈ nhds c :=
  by sorry

The theorem `SmoothBumpFunction.support_mem_nhds` states that for any Smooth Bump Function `f` defined on a finite dimensional normed vector space `E` over the real numbers, with a model with corners `I`, a topological space `H`, and a charted space `M` with corresponding topological space, the support of `f`, which is the set of points where `f` is not zero, is a neighborhood of `c`. In other words, the support of `f` is in the neighborhood filter of `c`. This means that around the point `c`, we can find an open set where `f` is non-zero.

The support of a Smooth Bump Function on a finite dimensional normed vector space is contained in the neighborhood filter of any point in its domain.


theorem Valuation.IsEquiv.val_eq :
    ∀ {R : Type u_3} {Γ₀ : Type u_4} {Γ'₀ : Type u_5} [inst : Ring R] [inst_1 : LinearOrderedCommMonoidWithZero Γ₀]
      [inst_2 : LinearOrderedCommMonoidWithZero Γ'₀] {v₁ : Valuation R Γ₀} {v₂ : Valuation R Γ'₀},
      Valuation.IsEquiv v₁ v₂ → ∀ {r s : R}, v₁ r = v₁ s ↔ v₂ r = v₂ s :=
  by sorry

This theorem, `Valuation.IsEquiv.val_eq`, states that for any arbitrary types `R`, `Γ₀`, and `Γ'₀`, where `R` is a ring and `Γ₀`, `Γ'₀` are linear ordered commutative monoids both having a zero element, if two valuations `v₁` and `v₂` on `R` with values in `Γ₀` and `Γ'₀` respectively are equivalent (meaning they induce the same preorder on `R`), then for any two elements `r` and `s` of `R`, `v₁ r = v₁ s` if and only if `v₂ r = v₂ s`. In other words, if two valuations are equivalent, then they agree on when they assign the same valuation to two elements in the ring.

If two valuations on a ring with values in commutative monoids having a zero element, inducing the same preorder on the ring, then they agree on the valuation of any two elements in the ring.


/-- If a function `f a b` is such that `y ↦ f a b` is continuous for all `a`, and `a` lives in a
discrete space, then `f` is continuous, and vice versa.  -/
theorem continuous_prod_of_discrete_left :
    ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β]
      [inst_2 : TopologicalSpace γ] [inst_3 : DiscreteTopology α] {f : α × β → γ},
      Continuous f ↔ ∀ (a : α), Continuous fun x => f (a, x) :=
  by sorry

This theorem states that for three types `α`, `β`, and `γ`, given that `α` has a discrete topology and `f` is a function from the Cartesian product of `α` and `β` to `γ`, `f` is continuous if and only if, for every element `a` of `α`, the function that maps `y` to `f(a, y)` is continuous. In mathematical terms, this is saying that if a function `f : α × β → γ` is such that the function `y ↦ f(a, y)` is continuous for all `a` in a discrete space `α`, then `f` is continuous, and the converse is also true.

A function between two discrete spaces is continuous if and only if the projection functions to each coordinate are continuous.


theorem PiTensorProduct.liftAux_tprod :
    ∀ {ι : Type u_1} {R : Type u_4} [inst : CommSemiring R] {s : ι → Type u_7} [inst_1 : (i : ι) → AddCommMonoid (s i)]
      [inst_2 : (i : ι) → Module R (s i)] {E : Type u_9} [inst_3 : AddCommMonoid E] [inst_4 : Module R E]
      (φ : MultilinearMap R s E) (f : (i : ι) → s i), (PiTensorProduct.liftAux φ) ((PiTensorProduct.tprod R) f) = φ f :=
  by sorry

The theorem `PiTensorProduct.liftAux_tprod` states that for any type `ι`, any commutative semiring `R`, any type-valued function `s` from `ι`, and any type `E` (where the types `s i` and `E` are both additive commutative monoids and `R`-modules), given a multilinear map `φ` from `s` to `E` and a function `f` from `ι` to `s i`, the result of applying the auxiliary lift function `PiTensorProduct.liftAux` on the tensor product `PiTensorProduct.tprod R f` equals the result of applying the multilinear map `φ` on `f`. In other words, the auxiliary lift function `PiTensorProduct.liftAux` preserves the structure of the tensor product when applied to `PiTensorProduct.tprod R f`.

Given a commutative semiring R, a type ι, an additive commutative monoid and R-module E, a multilinear map φ from ι to E, and a function f from ι to the type s with s i an additive commutative monoid and R-module, the auxiliary lift function PiTensorProduct.liftAux preserves the structure of the tensor product, i.e., PiTensorProduct.liftAux (PiTensorProduct.tprod R f) = φ (f).


theorem Subgroup.leftTransversals.diff_self :
    ∀ {G : Type u_1} [inst : Group G] {H : Subgroup G} {A : Type u_2} [inst_1 : CommGroup A] (ϕ : ↥H →* A)
      (T : ↑(Subgroup.leftTransversals ↑H)) [inst_2 : Subgroup.FiniteIndex H],
      Subgroup.leftTransversals.diff ϕ T T = 1 :=
  by sorry

The theorem `Subgroup.leftTransversals.diff_self` states that for any group `G`, any subgroup `H` of `G`, any commutative group `A`, any morphism `ϕ` from `H` to `A`, and any left transversal `T` of `H` in `G`, the difference between `T` and itself (according to the defined left transversal difference operation) is the identity element of the group `A`. This theorem holds when the index of the subgroup `H` in `G` is finite. In terms of algebra, it means that the difference of a left transversal with itself, under a certain defined operation involving group homomorphism, always results in the identity of the target group.

For any group `G`, subgroup `H`, commutative group `A`, morphism `ϕ` from `H` to `A`, and left transversal `T` of `H` in `G` (with finite index), the difference `ϕ(T \ T)` equals the identity element of `A`.


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

This theorem states that for any commutative ring `R`, a submonoid `S` of `R`, a commutative ring `P` that is an `R`-algebra, a fractional ideal `I` of `P` over `S`, and an element `x` of `P`, `x` is an element of the coercive version of `I` (i.e., `I` viewed as a subset of `P`) if and only if `x` is an element of `I`. Essentially, this theorem confirms that the membership of an element `x` in the fractional ideal `I` is preserved when `I` is coerced to a subset of `P`.

For any commutative ring `R`, submonoid `S` of `R`, commutative `R`-algebra `P`, fractional ideal `I` of `P` over `S`, and element `x` in `P`, `x` belongs to `I` if and only if `x` belongs to the coercion of `I` to a subset of `P`.


theorem Fin.coe_cast : ∀ {n m : ℕ} (h : n = m) (i : Fin n), ↑(Fin.cast h i) = ↑i := by sorry

The theorem `Fin.coe_cast` states that for any two natural numbers `n` and `m`, and for any equality `h` that asserts that `n` equals `m`, and for any value `i` in the finite set of natural numbers less than `n` (denoted `Fin n`), the coercion of `i` to a natural number remains the same after it is embedded into the finite set of natural numbers less than `m` via `Fin.cast` function using the equality `h`. In other words, the casting operation preserves the original numerical value of `i`.

For any natural numbers `n`, `m`, equality `h` between `n` and `m`, and `i` in `Fin n`, the coercion of `i` to a natural number is equal to its coercion when embedded into `Fin m` via `Fin.cast` with `h`.


/-- If a series `f` on `β × γ` has sum `a` and for each `b` the
restriction of `f` to `{b} × γ` has sum `g b`, then the series `g` has sum `a`. -/
theorem HasSum.prod_fiberwise :
    ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : AddCommMonoid α] [inst_1 : TopologicalSpace α]
      [inst_2 : ContinuousAdd α] [inst_3 : RegularSpace α] {f : β × γ → α} {g : β → α} {a : α},
      HasSum f a → (∀ (b : β), HasSum (fun c => f (b, c)) (g b)) → HasSum g a :=
  by sorry

The theorem states that if we have a series `f` which is defined on the product of two types `β` and `γ` with sum `a`, and for each element `b` of type `β`, the series `f` restricted to `{b} × γ` (which is a cross product of the singleton set `{b}` and `γ`) has sum `g b`, then the series `g` will also have sum `a`. This theorem holds for any types `α`, `β`, and `γ` provided `α` is an additive commutative monoid, a topological space, supports continuous addition, and is a regular space.

Given a series `f` on the product of additive commutative monoid and topological space `α × βγ`, where `βγ` is the product of types `β` and `γ`, such that for each `b ∈ β`, the series `f` restricted to `{b} × γ` has sum `g b`, then `g` has sum equal to the sum of `f`.


theorem Mathlib.Data.Nat.Parity._auxLemma.3 : ∀ {α : Type u} [inst : NonAssocSemiring α] (n : α), n + n = 2 * n := by
  sorry

This theorem, `Mathlib.Data.Nat.Parity._auxLemma.3`, states that for any type `α` that has a non-associative semiring structure, the sum of any element `n` with itself is equal to twice `n`. In terms of mathematical notation, this theorem expresses the equation `n + n = 2 * n` for all `n` in the non-associative semiring.

In any non-associative semiring, the sum of any element with itself equals twice that element.


theorem Mathlib.Analysis.BoxIntegral.Partition.Basic._auxLemma.15 :
    ∀ {α : Type u_1} {a : α} {s : Finset α}, (a ∈ ↑s) = (a ∈ s) := by sorry

This theorem, named `_auxLemma.15` in the `Mathlib.Analysis.BoxIntegral.Partition.Basic` module, states that for all types `α`, for all `a` of type `α`, and for all finite sets `s` of type `α`, `a` is an element of the set `s` coerced to a set (`↑s`) if and only if `a` is an element of the set `s`. The coercion here refers to the type conversion from `Finset α` (finite set) to `Set α` in Lean 4.

For any type `α`, element `a` of `α`, and finite set `s` of type `α`, `a` is in the set `s` if and only if `a` is in the set `↑s`. (Here, `↑s` denotes the set `{x : α | x ∈ s}`.)


theorem Mathlib.Data.Nat.Parity._auxLemma.13 : ∀ {n : ℕ}, Even (n + 1) = ¬Even n := by sorry

This theorem states that for any natural number `n`, the number `n + 1` is even if and only if `n` is not even. In other words, if `n` is an odd number, then `n + 1` is an even number, and vice versa.

For any natural number `n`, `n + 1` is even if and only if `n` is odd.


/-- Note: the assumption `hs` cannot be dropped. For a counterexample, see
Walter Rudin *Real and Complex Analysis*, example (c) in section 8.9.  -/
theorem MeasureTheory.Measure.measure_prod_null :
    ∀ {α : Type u_1} {β : Type u_3} [inst : MeasurableSpace α] [inst_1 : MeasurableSpace β]
      {μ : MeasureTheory.Measure α} {ν : MeasureTheory.Measure β} [inst_2 : MeasureTheory.SFinite ν] {s : Set (α × β)},
      MeasurableSet s →
        (↑↑(MeasureTheory.Measure.prod μ ν) s = 0 ↔
          (fun x => ↑↑ν (Prod.mk x ⁻¹' s)) =ᶠ[MeasureTheory.Measure.ae μ] 0) :=
  by sorry

The theorem `MeasureTheory.Measure.measure_prod_null` states that for any given types `α` and `β` equipped with measure spaces, any measures `μ` and `ν` on `α` and `β` respectively (with `ν` being sigma-finite), and any measurable set `s` of pairs from `α` and `β`, the measure of `s` under the product measure of `μ` and `ν` is zero if and only if the measure of the preimage of `s` under the function that pairs each element of `α` with `β` is almost everywhere zero with respect to the measure `μ`. Here, "almost everywhere" is in reference to the filter of co-null sets in the measure space. The theorem also notes that the measurability assumption on `s` cannot be omitted, referencing an example in Walter Rudin's book *Real and Complex Analysis*.

The product measure of two sigma-finite measures is zero on a set in the product space if and only if the preimage of that set under the diagonal function is almost everywhere null with respect to the first measure.


theorem isRadical_iff_pow_one_lt :
    ∀ {R : Type u_1} {y : R} [inst : MonoidWithZero R] (k : ℕ), 1 < k → (IsRadical y ↔ ∀ (x : R), y ∣ x ^ k → y ∣ x) :=
  by sorry

The theorem `isRadical_iff_pow_one_lt` states that for any type `R` that is a monoid with zero, and any element `y` from `R`, and any natural number `k` greater than 1, `y` is a radical if and only if for any element `x` from `R`, whenever `y` divides `x` raised to the power `k`, `y` divides `x`. A radical element in this context is defined as an element that divides another whenever it can divide a power of the other.

For any monoid with zero `R` and `y` in `R` with `k` a natural number greater than 1, `y` is a radical if and only if for all `x` in `R`, `y` divides `x^k` implies `y` divides `x`.


theorem Subgroup.isComplement_univ_singleton :
    ∀ {G : Type u_1} [inst : Group G] {g : G}, Subgroup.IsComplement Set.univ {g} := by sorry

This theorem states that for any given type `G` that has a group structure and for any element `g` of `G`, the universal set in `G` and the singleton set containing only `g` are complements. In other words, the function that takes a pair of elements from the universal set and the singleton set, respectively, and multiplies them (following group operation) is a bijection. This extends to saying that every element in the group can be uniquely expressed as a product of an element from the universal set and `g`.

For any group `G` and its element `g`, the functions from `G` to the universal set of `G` and the singleton set containing `g` are mutually inverse bijections.


padicNorm.mul

/-- The `p`-adic norm is multiplicative.  -/
theorem padicNorm.mul :
    ∀ {p : ℕ} [hp : Fact (Nat.Prime p)] (q r : ℚ), padicNorm p (q * r) = padicNorm p q * padicNorm p r := by sorry

The theorem 'padicNorm.mul' states that the `p`-adic norm is multiplicative for any prime number `p` and any two rational numbers `q` and `r`. In other words, the `p`-adic norm of the product of `q` and `r` is equal to the product of the `p`-adic norms of `q` and `r`. This is an important property of `p`-adic norms in number theory, and it highlights their behavior under multiplication.

The `p`-adic norm of the product of two rational numbers is equal to the product of their individual `p`-adic norms.


theorem Int.add_emod_self : ∀ {a b : ℤ}, (a + b) % b = a % b := by sorry

This theorem states that for any two integers `a` and `b`, the remainder of the sum of `a` and `b` divided by `b` is the same as the remainder of `a` divided by `b`. In mathematical notation, this theorem is expressed as `(a + b) mod b = a mod b`. It is a property of modulo operations in the set of integers.

For any integers `a` and `b`, the remainder of `a + b` when divided by `b` equals the remainder of `a` when divided by `b`. In other words, `(a + b) % b = a % b`.


theorem Matrix.linfty_opNNNorm_col :
    ∀ {m : Type u_3} {α : Type u_5} [inst : Fintype m] [inst_1 : SeminormedAddCommGroup α] (v : m → α),
      ‖Matrix.col v‖₊ = ‖v‖₊ :=
  by sorry

The theorem `Matrix.linfty_opNNNorm_col` states that for any type `m` and any semi-normed add commutative group `α`, and for any function `v` from `m` to `α`, the non-negative norm (denoted by ‖‖₊) of the column matrix whose entries are given by `v` is equal to the non-negative norm of the function `v` itself. Essentially, it indicates that the non-negative norm remains unchanged when a function is transformed into a column matrix.

For any semi-normed add commutative group α and type m, the non-negative norm of a function from m to α equals the non-negative norm of the column matrix formed by its values.


theorem heq_of_cast_eq : ∀ {α β : Sort u_1} {a : α} {a' : β} (e : α = β), cast e a = a' → HEq a a' := by sorry

This theorem, `heq_of_cast_eq`, states that for any two types `α` and `β` and any two values `a` of type `α` and `a'` of type `β`, if `α` equals `β` (denoted as `e : α = β`) and the value `a` becomes `a'` after being cast from type `α` to `β` (denoted as `cast e a = a'`), then `a` and `a'` are heterogeneously equal, represented as `HEq a a'`. In other words, if we can cast an element of one type to an element of another type, and these types turn out to be the same, then the original and the casted element are heterogeneously equal. This theorem is involved in the area of type theory in mathematics.

If `α = β` and `cast : α → β` is a type-preserving function with `cast (x : α) = a'`, then `x` and `a'` are heterogeneously equal, denoted as `HEq x a'`.


theorem ENat.top_sub_coe : ∀ (a : ℕ), ⊤ - ↑a = ⊤ := by sorry

This theorem states that for any natural number `a`, the difference between the top element of the extended natural numbers (notated as `⊤`) and the natural number `a` is just `⊤`. In other words, subtracting any natural number from infinity still results in infinity.

For any natural number `a`, `⊤ - a = ⊤` in the extended natural numbers.


/-- Any category with products and equalizers has all limits.

See <https://stacks.math.columbia.edu/tag/002N>.
 -/
theorem CategoryTheory.Limits.has_limits_of_hasEqualizers_and_products :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasProducts C]
      [inst_2 : CategoryTheory.Limits.HasEqualizers C], CategoryTheory.Limits.HasLimitsOfSize.{w, w, v, u} C :=
  by sorry

This theorem states that, for any category `C`, if this category has products and equalizers, then the category has all limits. The "products" in this context refer to the existence of a product for every collection of objects in the category, and "equalizers" refer to the existence of an equalizer for every pair of morphisms in the category. Therefore, this theorem is essentially stating a sufficient condition for a category to have all limits: having both products and equalizers. The link provided references a proof of this theorem in the Stacks Project.

In any category with products and equalizers, all limits exist.


theorem NumberField.InfinitePlace.card_complex_embeddings :
    ∀ (K : Type u_2) [inst : Field K] [inst_1 : NumberField K],
      Fintype.card { φ // ¬NumberField.ComplexEmbedding.IsReal φ } = 2 * NumberField.InfinitePlace.NrComplexPlaces K :=
  by sorry

This theorem states that for any number field `K`, the number of complex embeddings that are not real, i.e., they are not fixed by complex conjugation, is twice the number of infinite complex places of the number field `K`. Here, an infinite place of a number field is complex if its residue field is the complex numbers. In mathematical terms, given a number field `K`, the cardinality of the set of complex embeddings not fixed by complex conjugation equals twice the number of infinite complex places of `K`.

The number of complex embeddings of a number field `K` not fixed by complex conjugation equals twice the number of its infinite complex places.


theorem Complex.continuous_cos : Continuous Complex.cos := by sorry

This theorem states that the cosine function for complex numbers is continuous. In other words, for every point in the complex plane, small changes in the input result in arbitrarily small changes in the output of the complex cosine function. This function is defined via the exponential function (exp), where for a given complex number `z`, `Complex.cos z` is computed as `(Complex.exp (z * Complex.I) + Complex.exp (-z * Complex.I)) / 2`.

The complex cosine function, defined as the real part of the complex number ((exp (z * I) + exp (-z * I)) / 2) for complex number z, is a continuous function.


theorem true_ne_false : ¬True = False := by sorry

This theorem states that `True` is not equal to `False`. In the context of propositional logic, `True` and `False` represent distinct truth values. Hence, they can't be equal, and this theorem formalizes that fact in Lean 4.

The theorem asserts that `True` and `False` are distinct propositions in Lean 4.


theorem List.map_uncurry_zip_eq_zipWith :
    ∀ {α : Type u} {β : Type u_1} {γ : Type u_2} (f : α → β → γ) (l : List α) (l' : List β),
      List.map (Function.uncurry f) (List.zip l l') = List.zipWith f l l' :=
  by sorry

The theorem `List.map_uncurry_zip_eq_zipWith` states that for any function `f` with two arguments from types `α` and `β` producing a result of type `γ`, and for any two lists `l` of type `α` and `l'` of type `β`, the result of mapping the uncurried version of `f` over the zipped version of `l` and `l'` is equivalent to zipping `l` and `l'` with the function `f`. In other words, it states that applying the function to each pair of elements from the zipped lists is the same as creating a new list of the results of applying the function to corresponding elements of the two lists.

For any function $f : \alpha \times \beta \rightarrow \gamma$, the application of $f$ to the zipped lists $(x\_i, y\_i)_{i < length(l)} \text{ and } (x'\_i, y'_i)_{i < length(l')}$ is equal to the list obtained by applying $f$ to the corresponding elements of the lists $l$ and $l'$, i.e., $(f(x\_i, y\_i))_{i < length(l)} = \text{zipWith}(f)(l)(l')$.


theorem Ordinal.lt_nadd_iff :
    ∀ {a b c : Ordinal.{u}},
      a < Ordinal.nadd b c ↔ (∃ b' < b, a ≤ Ordinal.nadd b' c) ∨ ∃ c' < c, a ≤ Ordinal.nadd b c' :=
  by sorry

This theorem establishes a property of the natural addition (also known as the Hessenberg sum) operation on ordinals. For any three ordinals `a`, `b`, and `c`, it states that `a` is less than the natural addition of `b` and `c` if and only if there exists an ordinal `b'` less than `b` such that `a` is less than or equal to the natural addition of `b'` and `c`, or there exists an ordinal `c'` less than `c` such that `a` is less than or equal to the natural addition of `b` and `c'`. This theorem essentially explains the recursive definition of the Hessenberg sum by identifying the conditions under which one ordinal is less than the Hessenberg sum of two others.

For any ordinals `a`, `b`, and `c`, `a` is less than `b + c` if and only if there exists an ordinal `b' < b` such that `a <= b' + c` or there exists an ordinal `c' < c` such that `a <= b + c'`.


theorem AlgebraicTopology.DoldKan.identity_N₂_objectwise :
    ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
      [inst_2 : CategoryTheory.Limits.HasFiniteCoproducts C]
      (P : CategoryTheory.Idempotents.Karoubi (CategoryTheory.SimplicialObject C)),
      CategoryTheory.CategoryStruct.comp (AlgebraicTopology.DoldKan.N₂Γ₂.inv.app (AlgebraicTopology.DoldKan.N₂.obj P))
          (AlgebraicTopology.DoldKan.N₂.map (AlgebraicTopology.DoldKan.Γ₂N₂.natTrans.app P)) =
        CategoryTheory.CategoryStruct.id (AlgebraicTopology.DoldKan.N₂.obj P) :=
  by sorry

This theorem, named `AlgebraicTopology.DoldKan.identity_N₂_objectwise`, asserts that for any category `C` which is preadditive and has finite coproducts, and for any object `P` in the Karoubi envelope of the category of simplicial objects in `C`, the composition of the inverse of the application of `N₂Γ₂` to `N₂.obj P` and the map of `N₂` applied to `Γ₂N₂.natTrans.app P` is the identity on `N₂.obj P`. In simpler terms, this theorem is about the interaction of certain functors and natural transformations within the area of algebraic topology known as Dold-Kan correspondence.

For any preadditive category `C` with finite coproducts and any object `P` in the Karoubi envelope of the category of simplicial objects in `C`, the composition of `N₂.obj (Γ₂N₂.natTrans.app P)` and the inverse of `N₂Γ₂ (N₂.obj P)` is the identity on `N₂.obj P` in the Dold-Kan correspondence.


Ordnode.Valid'.valid

theorem Ordnode.Valid'.valid :
    ∀ {α : Type u_1} [inst : Preorder α] {t : Ordnode α} {o₁ : WithBot α} {o₂ : WithTop α},
      Ordnode.Valid' o₁ t o₂ → Ordnode.Valid t :=
  by sorry

This theorem states that for any type `α` under a preorder, for any `Ordnode` of type `α`, and for any `WithBot α` and `WithTop α`, if the `Ordnode` is valid in the sense of the `Ordnode.Valid'` predicate with respect to these boundary conditions, then the `Ordnode` is also valid in the sense of the `Ordnode.Valid` predicate. In other words, it ensures that the properties tested by `Ordnode.Valid'`, which includes the correctness of the `size` fields, the balance of the tree, and the organization of elements according to the ordering, are also implied by the `Ordnode.Valid` predicate.

For any type `α` under a preorder, if an `Ordnode` of type `α` is valid with respect to given boundary conditions `WithBot` and `WithTop` in the sense of `Ordnode.Valid'`, then it is also valid in the sense of `Ordnode.Valid`.


theorem ConjClasses.mem_carrier_iff_mk_eq :
    ∀ {α : Type u} [inst : Monoid α] {a : α} {b : ConjClasses α}, a ∈ ConjClasses.carrier b ↔ ConjClasses.mk a = b := by
  sorry

This theorem states that for any type `α` that forms a monoid and any elements `a` in this monoid and `b` in the conjugacy classes of the monoid, the element `a` belongs to the carrier of `b` if and only if the conjugacy class of `a` is equal to `b`. In more mathematical terms, it relates the membership of an element in a particular conjugacy class to the equivalence of the said class to the conjugacy class of the element itself.

For any monoid type `α` and elements `a` in `α` and `b` in its conjugacy classes, `a` belongs to the carrier of `b` if and only if `a` and `b` are equal as conjugacy classes.


theorem Fin.coe_eq_castSucc : ∀ {n : ℕ} {a : Fin n}, ↑↑a = Fin.castSucc a := by sorry

The theorem `Fin.coe_eq_castSucc` states that for any natural number `n` and any element `a` of the finite set `Fin n`, converting `a` to a natural number and then embedding it back into `Fin (n+1)` (i.e., `↑↑a`) is equivalent to directly embedding `a` into `Fin (n+1)` using the `Fin.castSucc` function. In other words, it asserts the equivalence of two ways of embedding an element of `Fin n` into `Fin (n+1)`.

For any natural number `n` and element `a` of `Fin n`, `↑↑a` equals `Fin.castSucc a` in `Fin (n+1)`.


theorem tsum_subtype_eq_of_support_subset :
    ∀ {α : Type u_1} {β : Type u_2} [inst : AddCommMonoid α] [inst_1 : TopologicalSpace α] {f : β → α} {s : Set β},
      Function.support f ⊆ s → ∑' (x : ↑s), f ↑x = ∑' (x : β), f x :=
  by sorry

The theorem `tsum_subtype_eq_of_support_subset` states that for any types `α` and `β`, given an additive commutative monoid structure and a topological space structure on `α`, and any function `f` from `β` to `α`, and any set `s` of type `β`, if the support of the function `f` (the set of points `x` where `f x ≠ 0`) is a subset of `s`, then the sum of `f` over the subtype induced by `s` is equal to the sum of `f` over all elements of `β`. Here, the sum is expressed using the `tsum` notation, which denotes an infinite sum in the context of a topological space.

For any additive commutative monoid-valued function `f` on a topological space `β`, if the support of `f` is a subset of a set `s` in `β`, then the sum of `f` over the subtype induced by `s` equals the sum of `f` over all of `β`.


theorem ProbabilityTheory.kernel.indep_biSup_limsup :
    ∀ {α : Type u_1} {Ω : Type u_2} {ι : Type u_3} {_mα : MeasurableSpace α} {m0 : MeasurableSpace Ω}
      {κ : ↥(ProbabilityTheory.kernel α Ω)} {μα : MeasureTheory.Measure α} [inst : ProbabilityTheory.IsMarkovKernel κ]
      {s : ι → MeasurableSpace Ω} {p : Set ι → Prop} {f : Filter ι},
      (∀ (n : ι), s n ≤ m0) →
        ProbabilityTheory.kernel.iIndep s κ μα →
          (∀ (t : Set ι), p t → tᶜ ∈ f) →
            ∀ {t : Set ι}, p t → ProbabilityTheory.kernel.Indep (⨆ n ∈ t, s n) (Filter.limsup s f) κ μα :=
  by sorry

This theorem is a statement in probability theory and measure theory, specifically relating to concepts of independent sets, limsup, and kernels. The theorem states that for all types `α`, `Ω`, and `ι`, given a measurable space `α`, another measurable space `m0` of type `Ω`, a kernel `κ` from the measurable space `α` to `Ω`, a measure `μα` on `α`, and the kernel `κ` being a Markov kernel, if you have a collection of measurable spaces `s` indexed by `ι`, a property `p` on sets of indices, and a filter `f` on `ι`, then under the conditions that each measurable space `s[n]` is a subspace of `m0`, the collection of measurable spaces `s` is independent with respect to the kernel and measure, and the complement of any set `t` satisfying property `p` belongs to the filter `f`, then for any such set `t`, the kernel independence of the superset of measurable spaces indexed by elements in `t` and the limsup of the sequence of measurable spaces along the filter `f` holds with respect to the kernel and measure.

Given a measurable space `α`, a Markov kernel `κ` from `α` to another measurable space `m0`, a measure `μα` on `α`, a collection of subspaces `s[n]` of `m0` indexed by `ι`, a filter `f` on `ι`, and a property `p` on sets of indices, if each `s[n]` is independent of the limsup of `s` along `f` with respect to `κ` and `μα`, and the complement of any set `t` satisfying `p` belongs to `f`, then the same independence holds for the superset of `s[n]` indexed by elements in `t`.


theorem Mathlib.Data.Real.EReal._auxLemma.2 : ∀ {x y : ℝ}, (↑x < ↑y) = (x < y) := by sorry

This theorem, `Mathlib.Data.Real.EReal._auxLemma.2`, states that for any two real numbers `x` and `y`, the inequality between their eReal (extended real number) representations, `↑x < ↑y`, is equivalent to the inequality between the numbers themselves, `x < y`. Essentially, this theorem asserts the preservation of inequality when converting from real numbers to extended real numbers.

For any real numbers x and y, the extended real number inequalities ↑x < ↑y are equivalent to the real number inequalities x < y.


theorem List.eq_replicate_length :
    ∀ {α : Type u} {a : α} {l : List α}, l = List.replicate (List.length l) a ↔ ∀ b ∈ l, b = a := by sorry

This theorem states that for any type `α`, any element `a` of type `α`, and any list `l` of elements of type `α`, the list `l` equals the list obtained by replicating the element `a` for the length of the list `l` if and only if every element `b` in the list `l` is equal to `a`. In other words, a list is identical to a list made by repeating a single element for the length of the list if and only if every element in the original list is that single element.

For any type `α`, list `l` of length `n` over `α`, and element `a` of `α`, the list `l` equals the repeated list `[a | _ | _ ... | a]` of length `n` if and only if `l` equals the list `[a] ^ n`, where `^` denotes list repetition.


/-- If `α` is a preorder with no maximal elements, then there exists a strictly monotone function
`ℕ → α` with any prescribed value of `f 0`.  -/
theorem Nat.exists_strictMono' :
    ∀ {α : Type u} [inst : Preorder α] [inst_1 : NoMaxOrder α] (a : α), ∃ f, StrictMono f ∧ f 0 = a := by sorry

This theorem states that if `α` is a type with a preorder structure and it has no maximal elements (i.e., for any element, there is always another element that is larger), then for any given element `a` in `α`, there exists a strictly monotone function from the natural numbers `ℕ` to `α` such that the function's value at zero is `a`. In other words, we can always find a function that maps the natural numbers into `α` in strictly increasing order starting from any point.

If `α` is a preordered type without maximal elements, then for every `a` in `α`, there exists a strictly monotone function `f : ℕ → α` with `f 0 = a`.


theorem DFinsupp.mapRange_apply :
    ∀ {ι : Type u} {β₁ : ι → Type v₁} {β₂ : ι → Type v₂} [inst : (i : ι) → Zero (β₁ i)] [inst_1 : (i : ι) → Zero (β₂ i)]
      (f : (i : ι) → β₁ i → β₂ i) (hf : ∀ (i : ι), f i 0 = 0) (g : Π₀ (i : ι), β₁ i) (i : ι),
      (DFinsupp.mapRange f hf g) i = f i (g i) :=
  by sorry

This theorem states that for any types `ι`, `β₁`, and `β₂`, and for a family of functions `f` from `β₁ i` to `β₂ i` such that `f i 0 = 0` for all `i`, and for a function `g` with domain `ι` and values in `β₁ i`, applying the `mapRange` function of the `DFinsupp` (directed finitely-supported function) structure to `f`, `hf` and `g`, and then applying the result to `i`, is the same as applying `f` at `i` to the result of applying `g` to `i`. In other words, it asserts that the `mapRange` function of `DFinsupp` respects the function application operation.

For any types `ι`, `β₁`, and `β₂`, and functions `f: β₁ →β₂` and `g: ι → β₁` such that `f 0 = 0`, the application of `f` to `g i` is equal to the application of `mapRange f hf g` to `i`, where `hf` is the function equality witness for `f`.


/-- If `f : X → Y` is an `Inducing` map, the image `f '' s` of a set `s` is Lindelöf
if and only if `s` is compact.  -/
theorem Inducing.isLindelof_iff :
    ∀ {X : Type u} {Y : Type v} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {s : Set X} {f : X → Y},
      Inducing f → (IsLindelof s ↔ IsLindelof (f '' s)) :=
  by sorry

The theorem states that for any types `X` and `Y` with respective topological spaces, any set `s` of type `X`, and any function `f` from `X` to `Y`, if `f` is an `Inducing` map (meaning that it induces the same topological structure on its image as the original set), then `s` is a Lindelöf set if and only if the image of `s` under `f` is a Lindelöf set. In other words, a set is Lindelöf (every nontrivial filter with the countable intersection property that contains the set has a cluster point in the set) if and only if its image under the inducing function is also Lindelöf.

If `f` is a continuous function between topological spaces `X` and `Y` that induces the same topology on its image as `X`, then a set in `X` is Lindelöf if and only if its image under `f` is Lindelöf.


theorem Seminorm.smul_apply :
    ∀ {R : Type u_1} {𝕜 : Type u_3} {E : Type u_7} [inst : SeminormedRing 𝕜] [inst_1 : AddGroup E] [inst_2 : SMul 𝕜 E]
      [inst_3 : SMul R ℝ] [inst_4 : SMul R NNReal] [inst_5 : IsScalarTower R NNReal ℝ] (r : R) (p : Seminorm 𝕜 E)
      (x : E), (r • p) x = r • p x :=
  by sorry

This theorem, `Seminorm.smul_apply`, states that for any seminormed ring `𝕜`, add group `E`, and types `R`, `𝕜` and `E` with scalar multiplication (`SMul`) defined between them, the application of a scalar `r` from `R` to the seminorm `p` of the element `x` from `E` is equal to the scalar multiplication of `r` and the seminorm `p` of `x`. In other words, it asserts that scalar multiplication commutes with the seminorm operation. The `IsScalarTower R NNReal ℝ` instance indicates that scalar multiplication is associative between `R`, nonnegative real numbers (`NNReal`), and real numbers (`ℝ`).

For any seminormed ring `𝕜`, add group `E`, and types `R`, `𝕜`, and `E` with scalar multiplication, the scalar multiplication of `r` in `R` by the seminorm `p` of `x` in `E` is equal to the seminorm of the scalar multiplication of `r` and `x` in `E`.


theorem Int.cast_sum :
    ∀ {α : Type u_3} {β : Type u_4} [inst : AddCommGroupWithOne β] (s : Finset α) (f : α → ℤ),
      ↑(Finset.sum s fun x => f x) = Finset.sum s fun x => ↑(f x) :=
  by sorry

The theorem `Int.cast_sum` states that for any finite set `s` of elements of type `α` and any function `f` from `α` to integers, the cast of the sum of `f(x)` for all `x` in `s` to a type `β` (where `β` is an additive commutative group with unity) is equal to the sum of the cast of `f(x)` for all `x` in `s`. In other words, casting can be interchanged with summing over a finite set.

For any finite set `s` and function `f` from a commutative additive group with unity to another such group, the cast of the sum of `f(x)` for all `x` in `s` is equal to the sum of the casts of `f(x)` for all `x` in `s`.


theorem Nat.Subtype.exists_succ : ∀ {s : Set ℕ} [inst : Infinite ↑s] (x : ↑s), ∃ n, ↑x + n + 1 ∈ s := by sorry

This theorem states that for every set `s` of natural numbers `ℕ`, given that `s` is infinite (`Infinite ↑s`), for any element `x` in `s`, there exists a natural number `n` such that the sum of `x`, `n`, and 1 is also an element in the set `s`. In other words, we can always find a natural number `n` so that moving `n` plus one steps from any number in an infinite set of natural numbers will still keep us within the set.

For every infinite set `s` of natural numbers, for all `x` in `s`, there exists `n` in `ℕ` such that `x + n + 1` is also in `s`.


theorem Nat.min_le_left : ∀ (a b : ℕ), min a b ≤ a := by sorry

This theorem states that for all natural numbers `a` and `b`, the minimum of `a` and `b` is less than or equal to `a`. In other words, `a` is always greater than or equal to the smaller value between `a` and `b`. This makes intuitive sense because `a` must either be greater than `b`, equal to `b`, or be the smaller number itself.

For all natural numbers `a` and `b`, `a ≤ a` and `a ≤ b` imply `b ≤ a`. (In other words, `min a b ≤ a`.)


/-- General fencing theorem for continuous functions with an estimate on the derivative.
Let `f` and `B` be continuous functions on `[a, b]` such that

* `f a ≤ B a`;
* `B` has right derivative `B'` at every point of `[a, b)`;
* for each `x ∈ [a, b)` the right-side limit inferior of `(f z - f x) / (z - x)`
  is bounded above by a function `f'`;
* we have `f' x < B' x` whenever `f x = B x`.

Then `f x ≤ B x` everywhere on `[a, b]`.  -/
theorem image_le_of_liminf_slope_right_lt_deriv_boundary' :
    ∀ {f f' : ℝ → ℝ} {a b : ℝ},
      ContinuousOn f (Set.Icc a b) →
        (∀ x ∈ Set.Ico a b, ∀ (r : ℝ), f' x < r → ∃ᶠ (z : ℝ) in nhdsWithin x (Set.Ioi x), slope f x z < r) →
          ∀ {B B' : ℝ → ℝ},
            f a ≤ B a →
              ContinuousOn B (Set.Icc a b) →
                (∀ x ∈ Set.Ico a b, HasDerivWithinAt B (B' x) (Set.Ici x) x) →
                  (∀ x ∈ Set.Ico a b, f x = B x → f' x < B' x) → ∀ ⦃x : ℝ⦄, x ∈ Set.Icc a b → f x ≤ B x :=
  by sorry

This theorem, known as the General fencing theorem for continuous functions with an estimate on the derivative, states the following:

Let `f` and `B` be continuous functions defined on the closed interval `[a, b]` with the following properties:

- `f(a)` is less than or equal to `B(a)`,
- `B` has a right derivative `B'` at every point in the half-open interval `[a, b)`,
- for every `x` in the half-open interval `[a, b)`, the right-side limit inferior of `(f(z) - f(x)) / (z - x)` is bounded above by a function `f'`,
- and whenever `f(x)` is equal to `B(x)`, `f'(x)` is strictly less than `B'(x)`.

Then the theorem asserts that `f(x)` is less than or equal to `B(x)` for all `x` in the closed interval `[a, b]`.

If `f` is a continuous function on the closed interval `[a, b]` with `f(a) ≤ B(a)`, `B` is continuous on `[a, b]` with a right derivative `B'` on `[a, b)`, the right-limit inferiors of `(f(z) - f(x)) / (z - x)` are bounded above by a function `f'`, and `f(x) = B(x)` implies `f'(x) < B'(x)`, then `f(x) ≤ B(x)` for all `x` in `[a, b]`.


theorem Filter.nonempty_of_neBot : ∀ {α : Type u} (f : Filter α) [inst : Filter.NeBot f], Nonempty α := by sorry

This theorem states that for any type `α` and any filter `f` over this type, if the filter `f` is not the bottom filter (which intuitively means it's not "empty"), then the type `α` is nonempty. In other words, if we have some nontrivial filter on a type, then there must exist at least one element of that type.

If a filter over a type is non-bottom, then the type is nonempty.


theorem SetTheory.PGame.lf_iff_lt_or_fuzzy :
    ∀ {x y : SetTheory.PGame}, SetTheory.PGame.LF x y ↔ x < y ∨ SetTheory.PGame.Fuzzy x y := by sorry

This theorem in the context of Set Theory and Pregames states that for any two pre-games `x` and `y`, the "less or fuzzy" relation `LF` holds between `x` and `y` if and only if `x` is strictly less than `y` or `x` and `y` are in a fuzzy (or confused or incomparable) relation. In game-theoretic terms, this means that Left can win `x` as the first player if and only if `x` is a position that is strictly worse for Left than `y`, or neither player has a winning strategy in the comparison of `x` and `y` (i.e., the games `x` and `y` are fuzzy relative to each other).

For any pre-games x and y in Set Theory and Pregames, x is less or fuzzy related to y if and only if Left does not have a winning strategy in x against Right's best response, and x is not strictly better than y for Left.


theorem Ultrafilter.coe_inj : ∀ {α : Type u} {f g : Ultrafilter α}, ↑f = ↑g ↔ f = g := by sorry

This theorem states that for any given type `α` and ultrafilters `f` and `g` over that type, the mapping of `f` to the underlying type is equal to the mapping of `g` to the underlying type if and only if `f` is equal to `g`. In other words, two ultrafilters are equal if their mappings to the base type `α` are equal. This theorem is about the injectivity of the coe (coercion) function for ultrafilters.

Two ultrafilters over type `α` are equal if and only if their underlying types are equal as coerced values.


theorem MeasureTheory.pdf.IsUniform.pdf_eq :
    ∀ {E : Type u_1} [inst : MeasurableSpace E] {μ : MeasureTheory.Measure E} {Ω : Type u_2} {x : MeasurableSpace Ω}
      {ℙ : MeasureTheory.Measure Ω} {X : Ω → E} {s : Set E},
      MeasurableSet s →
        MeasureTheory.pdf.IsUniform X s ℙ μ →
          MeasureTheory.pdf X ℙ μ =ᶠ[MeasureTheory.Measure.ae μ] Set.indicator s ((↑↑μ s)⁻¹ • 1) :=
  by sorry

The theorem `MeasureTheory.pdf.IsUniform.pdf_eq` states that for any random variable `X` mapping from a measure space `Ω` to a measurable space `E`, with a probability measure `ℙ` on `Ω` and a measure `μ` on `E`, and for any measurable set `s` in `E`, if `X` has a uniform distribution on `s`, then the probability density function (pdf) of `X` is equal almost everywhere (with respect to the measure `μ`) to the indicator function of `s` scaled by the reciprocal of the measure of `s`. That is, for almost every point in `E`, the density of `X` at that point is equal to the indicator function of `s` at that point (which is 1 if the point is in `s` and 0 otherwise) times the reciprocal of the measure of `s`, effectively describing a uniform distribution on `s`.

For any measurable set `s` in a measurable space `(E, μ)` and a random variable `X` mapping from a measure space `(Ω, ℙ)` to `(E, μ)` with a uniform distribution on `s`, the probability density function of `X` almost everywhere equals the scaled indicator function of `s`. In other words, the density is almost everywhere equal to the indicator function multiplied by the reciprocal of the measure of `s`.


theorem mul_div_mul_right :
    ∀ {G₀ : Type u_3} [inst : GroupWithZero G₀] {c : G₀} (a b : G₀), c ≠ 0 → a * c / (b * c) = a / b := by sorry

This theorem states that for any non-zero element `c` in a group with zero (`G₀`), the equation `a * c / (b * c) = a / b` holds true for any elements `a` and `b` in the group. Essentially, this means that in such a group, the multiplication of `a` and `c` divided by the multiplication of `b` and `c` is equal to the division of `a` by `b`.

For any group with zero `G₀` and non-zero element `c`, the quotient of `a * c` by `b * c` equals the quotient of `a` by `b`, for all elements `a` and `b` in `G₀`.


theorem Real.norm_coe_nat : ∀ (n : ℕ), ‖↑n‖ = ↑n := by sorry

This theorem states that for any natural number 'n', the norm (or absolute value) of 'n' when it is coerced (or converted) into a real number is equal to 'n' itself as a real number. Essentially, this means that the absolute value of any natural number is just the number itself when both are considered as real numbers.

For any natural number n, |n| = n, where |.| denotes the absolute value function.


ContinuousLinearMap.lipschitz

/-- continuous linear maps are Lipschitz continuous.  -/
theorem ContinuousLinearMap.lipschitz :
    ∀ {𝕜 : Type u_1} {𝕜₂ : Type u_2} {E : Type u_4} {F : Type u_6} [inst : SeminormedAddCommGroup E]
      [inst_1 : SeminormedAddCommGroup F] [inst_2 : NontriviallyNormedField 𝕜] [inst_3 : NontriviallyNormedField 𝕜₂]
      [inst_4 : NormedSpace 𝕜 E] [inst_5 : NormedSpace 𝕜₂ F] {σ₁₂ : 𝕜 →+* 𝕜₂} [inst_6 : RingHomIsometric σ₁₂]
      (f : E →SL[σ₁₂] F), LipschitzWith ‖f‖₊ ⇑f :=
  by sorry

The theorem `ContinuousLinearMap.lipschitz` states that for every continuous linear map `f` from a seminormed additively commutative group `E` over a nontrivially normed field `𝕜` to a seminormed additively commutative group `F` over a nontrivially normed field `𝕜₂`, with `σ₁₂` being a ring homomorphism between `𝕜` and `𝕜₂`, the map `f` is Lipschitz continuous with Lipschitz constant being the norm of `f`. In mathematical terms, this means that for all `x,y` in `E`, the extended distance (`edist`) between `f(x)` and `f(y)` in `F` is less than or equal to the norm of `f` times the extended distance between `x` and `y` in `E`.

For every continuous linear map $f$ from a seminormed additively commutative group $E$ over a nontrivially normed field $\mathbb{K}$ to a seminormed additively commutative group $F$ over a nontrivially normed field $\mathbb{K}_2$, with $\sigma\_1\_2$ being a ring homomorphism from $\mathbb{K}$ to $\mathbb{K}_2$, the Lipschitz constant of $f$ is equal to the norm of $f$, i.e., $\text{edist}(f(x), f(y)) \leq \|f\| \cdot \text{edist}(x, y)$, for all $x, y \in E$.


theorem LinearIsometryEquiv.refl_trans :
    ∀ {R : Type u_1} {R₂ : Type u_2} {E : Type u_5} {E₂ : Type u_6} [inst : Semiring R] [inst_1 : Semiring R₂]
      {σ₁₂ : R →+* R₂} {σ₂₁ : R₂ →+* R} [inst_2 : RingHomInvPair σ₁₂ σ₂₁] [inst_3 : RingHomInvPair σ₂₁ σ₁₂]
      [inst_4 : SeminormedAddCommGroup E] [inst_5 : SeminormedAddCommGroup E₂] [inst_6 : Module R E]
      [inst_7 : Module R₂ E₂] (e : E ≃ₛₗᵢ[σ₁₂] E₂), LinearIsometryEquiv.trans (LinearIsometryEquiv.refl R E) e = e :=
  by sorry

The theorem `LinearIsometryEquiv.refl_trans` states that for any semirings `R` and `R₂`, seminormed additive commutative groups `E` and `E₂`, pair of ring homomorphisms `σ₁₂` and `σ₂₁` that are inverses of each other, and modules `E` over `R` and `E₂` over `R₂`, the composition of a linear isometry equivalence `e : E ≃ₛₗᵢ[σ₁₂] E₂` with the identity linear isometry equivalence on `E` is `e` itself. In other words, applying the identity map first does not change the result of the linear isometry equivalence `e`.

For any seminormed additive commutative groups `E` and `E₂`, semirings `R` and `R₂`, ring homomorphisms `σ₁₂` and `σ₂₁` that are inverses of each other, and modules `E` over `R` and `E₂` over `R₂`, the linear isometry equivalence `e : E ≃ₛₗᵢ[σ₁₂] E₂` satisfies `e ∘ id = e`, where `id` is the identity linear isometry equivalence on `E`.


theorem Mathlib.GroupTheory.DoubleCoset._auxLemma.10 :
    ∀ {G : Type u_1} [inst : Semigroup G] (a b c : G), a * (b * c) = a * b * c := by sorry

This theorem, `Mathlib.GroupTheory.DoubleCoset._auxLemma.10`, states that for any semigroup `G` and any three elements `a`, `b`, and `c` of `G`, the operation `a * (b * c)` is equal to `a * b * c`. In other words, it asserts the associativity of the semigroup operation, meaning that the way in which operations are grouped does not change the result.

For any semigroup G and all elements a, b, and c in G, the associative property holds, that is, a * (b * c) = a * b * c.


theorem List.get?_set_ne :
    ∀ {α : Type u_1} (a : α) {m n : ℕ} (l : List α), m ≠ n → List.get? (List.set l m a) n = List.get? l n := by sorry

The theorem `List.get?_set_ne` states that for all types `α`, for all elements `a` of type `α`, for all natural numbers `m` and `n`, and for all lists `l` of type `α`, if `m` and `n` are not equal, then the `n`th element of the list resulting from setting the `m`th element of `l` to `a` is the same as the `n`th element of the initial list `l`. In other words, changing the `m`th element of a list does not affect the `n`th element if `m` and `n` are different.

For all types `α`, lists `l` of length `m+1` in `α`, and natural numbers `m ≠ n`, the `n`th element of the list `l.set m a` is equal to the `n`th element of `l`, where `a` is an element of `α`.


theorem Commute.add_pow_prime_pow_eq :
    ∀ {R : Type u_1} [inst : Semiring R] {p : ℕ} {x y : R},
      Nat.Prime p →
        Commute x y →
          ∀ (n : ℕ),
            (x + y) ^ p ^ n =
              x ^ p ^ n + y ^ p ^ n +
                ↑p * Finset.sum (Finset.Ioo 0 (p ^ n)) fun k => x ^ k * y ^ (p ^ n - k) * ↑(Nat.choose (p ^ n) k / p) :=
  by sorry

This theorem states that for any semiring `R`, prime number `p`, and elements `x` and `y` from `R` that commute, for any natural number `n`, the power of the sum of `x` and `y` raised to the power `p ^ n` is equal to the sum of `x ^ p ^ n`, `y ^ p ^ n`, and the product of `p` and the sum over all `k` in the interval `(0, p ^ n)` of the product of `x ^ k`, `y ^ (p ^ n - k)`, and the binomial coefficient `Nat.choose (p ^ n) k` divided by `p`. In mathematical notation, this can be written as $(x + y)^{p^n} = x^{p^n} + y^{p^n} + p\sum_{k=0}^{p^n} x^k * y^{p^n - k} * \binom{p^n}{k}/p$.

For any semiring `R`, prime number `p`, and commuting elements `x`, `y` from `R`, $(x + y)^{p^n} = x^{p^n} + y^{p^n} + p\sum\_{k=0}^{p^n} \binom{p^n}{k}x^k y^{p^n-k}$.


theorem Set.Intersecting.ne_bot :
    ∀ {α : Type u_1} [inst : SemilatticeInf α] [inst_1 : OrderBot α] {s : Set α} {a : α},
      Set.Intersecting s → a ∈ s → a ≠ ⊥ :=
  by sorry

This theorem states that for any type `α` that is both a semilattice (a partially ordered set with a greatest lower bound for any two elements) and an ordered set with a least element (`OrderBot`), if a set `s` of elements of `α` has the property that every two elements in it have non-disjoint intersection (i.e., they have a common element), then for any element `a` of this set, `a` cannot be the least element of the order (denoted by `⊥`). In other words, in such a set, the least element of the order is not included.

In a semilattice with a least element where every pair of elements have non-empty intersection, no element is the least element.


theorem strictMono_toDual_comp_iff :
    ∀ {α : Type u} {β : Type v} [inst : Preorder α] [inst_1 : Preorder β] {f : α → β},
      StrictMono (⇑OrderDual.toDual ∘ f) ↔ StrictAnti f :=
  by sorry

This theorem states that for any two types `α` and `β` with preorder relations (i.e., they are partially ordered sets where every two elements are comparable), and given a function `f` from `α` to `β`, the function `f` is strictly anti-monotone (i.e., `f` reverses the order: if `a < b` then `f(b) < f(a)`) if and only if the function obtained by composing `f` with the identity on the order dual of `α` is strictly monotone (i.e., `f` preserves the order: if `a < b` then `f(a) < f(b)`). In other words, when we reverse the order in the domain, a strictly monotone function becomes strictly anti-monotone, and vice versa.

For any functions between partially ordered sets, a function is strictly anti-monotone if and only if the function composed with the order dual's identity is strictly monotone.


theorem isGLB_Icc : ∀ {α : Type u} [inst : Preorder α] {a b : α}, a ≤ b → IsGLB (Set.Icc a b) a := by sorry

The theorem `isGLB_Icc` states that for any type `α` which has a preorder relation, and any two elements `a` and `b` of type `α` such that `a` is less than or equal to `b`, `a` is the greatest lower bound of the closed interval from `a` to `b`. In other words, for any element `x` in the closed interval `[a, b]`, `a` is less than or equal to `x`. It should be noted that the notion of a "closed interval" is generalized for any preorder and not just the standard order on real numbers.

For any type `α` with a preorder relation and any `a, b ∈ α` with `a ≤ b`, `a` is the greatest lower bound of the interval `[a, b]` if and only if `a ≤ x` for all `x ∈ [a, b]`.


theorem ClosureOperator.closure_top :
    ∀ {α : Type u_1} [inst : PartialOrder α] [inst_1 : OrderTop α] (c : ClosureOperator α), c ⊤ = ⊤ := by sorry

This theorem states that for any given closure operator `c` defined on a partially ordered set `α` that also has a top element, the result of applying the closure operator `c` to the top element is always the top element itself. The partial order and the top element are given as preconditions in the theorem, and `c` is the closure operator being considered. The theorem is essentially saying that the closure of the top element under any closure operator in this context is still the top element.

For any closure operator `c` on a partially ordered set `α` with a top element, the closure of the top element under `c` equals the top element.


/-- The range of `toSpanSingleton x` is the span of `x`. -/
theorem LinearMap.span_singleton_eq_range :
    ∀ (R : Type u_1) (M : Type u_4) [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] (x : M),
      Submodule.span R {x} = LinearMap.range (LinearMap.toSpanSingleton R M x) :=
  by sorry

This theorem declares that for any semiring `R`, any additive commutative monoid `M` and any module `M` over `R`, for any element `x` in `M`, the span of `{x}` in `M` (i.e., the smallest submodule of `M` containing `{x}`) is equal to the range of the linear map `toSpanSingleton x` (i.e., the set of all scalar multiples of `x`). In other words, all scalar multiples of a given element `x` in a module `M` over a semiring `R` precisely form the smallest submodule of `M` that contains `x`.

The submodule generated by an element `x` in an `R`-module `M` is equal to the set of all scalar multiples of `x` in `M`, for any semiring `R` and additive commutative monoid `M`.


theorem Nat.divisor_le : ∀ {n m : ℕ}, n ∈ Nat.divisors m → n ≤ m := by sorry

The theorem `Nat.divisor_le` states that for any natural numbers `n` and `m`, if `n` is a divisor of `m` (i.e., `n` is in the set of divisors of `m`), then `n` is less than or equal to `m`. This is a fundamental property of division in the set of natural numbers, which states that a divisor cannot be larger than the number it divides.

If `n` is a divisor of `m` in the natural numbers, then `n` is less than or equal to `m`.


theorem ProbabilityTheory.kernel.indepSet_iff_indepSets_singleton :
    ∀ {α : Type u_1} {Ω : Type u_2} {_mα : MeasurableSpace α} {s t : Set Ω} {m0 : MeasurableSpace Ω},
      MeasurableSet s →
        MeasurableSet t →
          ∀ (κ : ↥(ProbabilityTheory.kernel α Ω)) (μ : MeasureTheory.Measure α)
            [inst : ProbabilityTheory.IsMarkovKernel κ],
            ProbabilityTheory.kernel.IndepSet s t κ μ ↔ ProbabilityTheory.kernel.IndepSets {s} {t} κ μ :=
  by sorry

This theorem states that for any types `α` and `Ω`, given `α` and `Ω` are both measurable spaces, two sets `s` and `t` from `Ω` that are measurable, and any kernel `κ` from `α` to `Ω` and any measure `μ` on `α`, if `κ` is a Markov kernel then the two sets `s` and `t` are independent if and only if the singleton sets `{s}` and `{t}` are independent with respect to the kernel `κ` and the measure `μ`. In the context of probability theory, this means that the probability of the intersection of two events equals the product of their probabilities.

Given measurable spaces `α` and `Ω`, measurable sets `s` and `t` in `Ω`, a Markov kernel `κ` from `α` to `Ω`, and a measure `μ` on `α`, sets `s` and `t` are independent if and only if `κ({s}) ⊤ {t} = κ({s}) ∘ κ({t})`, where `⊤` is the lifting of the measure `μ` to `Ω` and `∘` is functional composition.


theorem LipschitzOnWith.locallyBoundedVariationOn :
    ∀ {E : Type u_2} [inst : PseudoEMetricSpace E] {f : ℝ → E} {C : NNReal} {s : Set ℝ},
      LipschitzOnWith C f s → LocallyBoundedVariationOn f s :=
  by sorry

The theorem `LipschitzOnWith.locallyBoundedVariationOn` states that for any function `f` from real numbers to a type `E` (where `E` is a type equipped with a pseudo e-metric space structure), a nonnegative real number `C`, and a set `s` of real numbers, if the function `f` is Lipschitz continuous with constant `C` on the set `s`, then the function `f` has locally bounded variation on the set `s`. In more mathematical terms, for all `x, y` in `s`, if the extended distance between `f(x)` and `f(y)` is less than or equal to `C` times the extended distance between `x` and `y`, then for any interval `[a, b]` with endpoints in `s`, the function `f` has finite variation on the intersection of `s` and the closed interval from `a` to `b`.

If a Lipschitz continuous function `f` on a set `s` of real numbers, with constant `C`, has its extended distance less than or equal to `C` times the regular difference between any two points in `s`, then `f` has finite variation on every closed interval within `s`.


theorem Finset.sdiff_empty : ∀ {α : Type u_1} [inst : DecidableEq α] {s : Finset α}, s \ ∅ = s := by sorry

The theorem `Finset.sdiff_empty` states that for any type `α` equipped with a decidable equality relation, and for any finite set `s` of `α`, the set difference between `s` and the empty set is `s` itself. In other words, removing nothing from a set leaves the set unchanged. This concept is often denoted in mathematics as `s \ ∅ = s`.

For any finite set `s` in a type `α` with decidable equality, `s \ EmptySet = s`.


theorem Homeomorph.comp_continuous_iff' :
    ∀ {X : Type u_1} {Y : Type u_2} {Z : Type u_3} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y]
      [inst_2 : TopologicalSpace Z] (h : X ≃ₜ Y) {f : Y → Z}, Continuous (f ∘ ⇑h) ↔ Continuous f :=
  by sorry

This theorem states that for any three types `X`, `Y`, and `Z`, each equipped with a topological space structure, and a homeomorphism `h` from `X` to `Y`, a function `f` from `Y` to `Z` is continuous if and only if the composition of `f` and `h` (`f ∘ ⇑h`) is continuous. In other words, the continuity of a function `f` from space `Y` to `Z` is preserved under pre-composition with a homeomorphism from `X` to `Y`.

For any topological spaces `X`, `Y`, `Z`, a homeomorphism `h: X \to Y`, and a function `f: Y \to Z`, the continuity of `f` if and only if of `f �circ h`.


List.Nodup.dedup

theorem List.Nodup.dedup : ∀ {α : Type u} [inst : DecidableEq α] {l : List α}, List.Nodup l → List.dedup l = l := by
  sorry

The theorem `List.Nodup.dedup` states that for any type `α` that has decidable equality, and any list `l` of type `α`, if the list `l` has no duplicate elements (defined by `List.Nodup l`), then removing duplicates from `l` (using `List.dedup l`) results in a list that is identical to the original list `l`. In other words, if a list already has no duplicates, then running a duplicate-removal function on it has no effect.

If `α` has decidable equality and `l : List α` has no duplicates, then `List.dedup l = l`.


/-- `sinh` is injective, `∀ a b, sinh a = sinh b → a = b`.  -/
theorem Real.sinh_injective : Function.Injective Real.sinh := by sorry

The theorem `Real.sinh_injective` states that the real hyperbolic sine function (denoted as `Real.sinh`) is injective. This means that for any two real numbers `a` and `b`, if the hyperbolic sine of `a` is equal to the hyperbolic sine of `b` (expressed in Lean 4 as `sinh a = sinh b`), then `a` must be equal to `b` (expressed as `a = b`). In other words, no two different real numbers can have the same hyperbolic sine value.

The real hyperbolic sine function is a bijection (injective and surjective function). In other words, for all real numbers `a` and `b`, `sinh a = sinh b` implies `a = b`.


/-- An odd function on a linear ordered additive commutative group is strictly monotone on the whole
group provided that it is strictly monotone on `Set.Ici 0`.  -/
theorem strictMono_of_odd_strictMonoOn_nonneg :
    ∀ {G : Type u_1} {H : Type u_2} [inst : LinearOrderedAddCommGroup G] [inst_1 : OrderedAddCommGroup H] {f : G → H},
      (∀ (x : G), f (-x) = -f x) → StrictMonoOn f (Set.Ici 0) → StrictMono f :=
  by sorry

The theorem `strictMono_of_odd_strictMonoOn_nonneg` states that for any linear ordered additive commutative group `G` and any ordered additive commutative group `H`, if we have a function `f` from `G` to `H` that is odd (i.e., for all `x` in `G`, `f(-x)` equals `-f(x)`), and this function `f` is strictly monotone on the interval `Set.Ici 0` (i.e., the set of all `x` in `G` such that `0 <= x`), then `f` is strictly monotone on the whole group `G`. In other words, if `a` and `b` are elements of `G` such that `a < b`, then `f(a) < f(b)`. This theorem thus establishes a condition under which an odd function on a group is strictly monotone.

If `f` is an odd function from a linear ordered additive commutative group `G` that is strictly monotone on the non-negative part `Set.Ici 0`, then `f` is strictly monotone on the entire group `G`.


BoundedLatticeHom.ext

theorem BoundedLatticeHom.ext :
    ∀ {α : Type u_3} {β : Type u_4} [inst : Lattice α] [inst_1 : Lattice β] [inst_2 : BoundedOrder α]
      [inst_3 : BoundedOrder β] {f g : BoundedLatticeHom α β}, (∀ (a : α), f a = g a) → f = g :=
  by sorry

This theorem states that for any two bounded lattice homomorphisms `f` and `g` between two lattices `α` and `β`, if `f` and `g` have the same output for every element `a` in lattice `α`, then `f` and `g` are the same. Here, `α` and `β` are types that form lattices with a bounded order. A bounded lattice homomorphism is a function that preserves the lattice operations and the order.

If two bounded lattice homomorphisms between two bounded lattices agree on all lattice elements, then they are equal.


theorem Stream'.Seq.map_comp :
    ∀ {α : Type u} {β : Type v} {γ : Type w} (f : α → β) (g : β → γ) (s : Stream'.Seq α),
      Stream'.Seq.map (g ∘ f) s = Stream'.Seq.map g (Stream'.Seq.map f s) :=
  by sorry

The theorem `Stream'.Seq.map_comp` asserts that for all types `α`, `β`, and `γ`, and for all functions `f` from `α` to `β` and `g` from `β` to `γ`, and for any sequence `s` of type `α`, mapping the composition of `g` and `f` over the sequence `s` is equivalent to first mapping `f` over `s`, and then mapping `g` over the resulting sequence. This is a statement of function composition compatibility with sequence mapping, a property akin to one in function composition in standard mathematics: `(g ∘ f)(x) = g(f(x))` for all `x` in the domain of `f`.

For any types `α`, `β`, `γ`, functions `f : α → β` and `g : β → γ`, and sequences `s : Stream α`, the application of `g` followed by `f` to each element in `s` is equal to the application of `f` followed by `g` to `s`. In other words, `Stream.map (g ∘ f) s = Stream.map g (Stream.map f s)`.


theorem Multiset.filter_eq :
    ∀ {α : Type u_1} [inst : DecidableEq α] (s : Multiset α) (b : α),
      Multiset.filter (Eq b) s = Multiset.replicate (Multiset.count b s) b :=
  by sorry

This theorem, named `Multiset.filter_eq`, is stating a property about multisets in a given type `α` where equality is decidable. Specifically, it says that if we filter a multiset `s` with the equality predicate `Eq b`, effectively keeping only the elements equal to `b`, the result is the same as replicating `b` exactly as many times as it appears in `s`. In other words, the filtered multiset where we keep only the elements equal to `b` is exactly the same as creating a multiset consisting of only `b`, replicated `count b s` times. This theorem is universally quantified over all types `α` with decidable equality and all multisets `s` and elements `b` in `α`.

For all types `α` with decidable equality and for all multisets `s` and elements `b` in `α`, the multiset obtained by filtering `s` using the equality predicate `Eq b` is equal to the multiset with `b` replicated `count b s` times.


theorem HasFDerivWithinAt.mono_of_mem :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {f : E → F}
      {f' : E →L[𝕜] F} {x : E} {s t : Set E},
      HasFDerivWithinAt f f' t x → t ∈ nhdsWithin x s → HasFDerivWithinAt f f' s x :=
  by sorry

This theorem, `HasFDerivWithinAt.mono_of_mem`, states that for any non-trivially normed field `𝕜`, normed additively commutative groups `E` and `F` where `E` and `F` are both normed spaces over `𝕜`, a function `f` from `E` to `F`, its derivative `f'` at a point `x` in `E`, and two sets of elements in `E`, `s` and `t`. If `f` has derivative `f'` within the set `t` at the point `x` and `t` is in the neighborhood within the set `s` of point `x` (meaning that `t` intersected with a neighborhood of `x` is a subset of `s`), then `f` also has the derivative `f'` within the set `s` at the point `x`. In other words, if `f` has a derivative at a point within a certain set, and this set is in the neighborhood of the point within a larger set, then `f` also has a derivative at that point within the larger set.

If `f` has a derivative within set `t` at point `x` in normed spaces `E` and `F` over field `𝕜`, and `t` is in the neighborhood of `x` within set `s`, then `f` has a derivative within set `s` at point `x`.


theorem List.get?_set_eq :
    ∀ {α : Type u_1} (a : α) (n : ℕ) (l : List α), List.get? (List.set l n a) n = (fun x => a) <$> List.get? l n := by
  sorry

The theorem `List.get?_set_eq` states that for any type `α`, any element `a` of type `α`, any natural number `n`, and any list `l` of type `α`, obtaining the `n`-th element of the list obtained by setting the `n`-th element of `l` to `a` is equal to applying the function (that always returns `a`) on the `n`-th element of `l` (if it exists). In other words, it states that if you replace the `n`-th element of a list with a new value, then retrieving the `n`-th element of the updated list will give you this new value, provided that the `n`-th element existed in the original list.

For any type `α`, list `l` of length `n+1` in `α`, and `a` in `α`, if the `n`-th element of `l` exists, then `List.get! (List.set l n a) = a`.


RingCon.symm

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

This theorem, `RingCon.symm`, asserts that for any type `R` that has addition (Add) and multiplication (Mul) defined, given a relation `c` that's a congruence on the ring `R`, and any two elements `x` and `y` of `R`, if `x` is related to `y` under `c`, then `y` is also related to `x` under `c`. In other words, the congruence relation `c` is symmetric.

If `c` is a congruence relation on a ring `R` with addition and multiplication, then for all `x` and `y` in `R`, if `x ≡ y (mod c)`, then `y ≡ x (mod c)`.


/-- The diagonal map from the total space of the fiberwise product of two fiber bundles
`E₁`, `E₂` into `TotalSpace F₁ E₁ × TotalSpace F₂ E₂` is `Inducing`.  -/
theorem FiberBundle.Prod.inducing_diag :
    ∀ {B : Type u_1} (F₁ : Type u_2) (E₁ : B → Type u_3) (F₂ : Type u_4) (E₂ : B → Type u_5)
      [inst : TopologicalSpace (Bundle.TotalSpace F₁ E₁)] [inst_1 : TopologicalSpace (Bundle.TotalSpace F₂ E₂)],
      Inducing fun p => ({ proj := p.proj, snd := p.snd.1 }, { proj := p.proj, snd := p.snd.2 }) :=
  by sorry

The theorem `FiberBundle.Prod.inducing_diag` states that for any type `B` and any fiber bundles `E₁` and `E₂` over `B` with corresponding total spaces `F₁` and `F₂`, the diagonal map that takes a point in the fiberwise product of `E₁` and `E₂` to a pair of points in `F₁` and `F₂` (with the same projection to `B`) is inducing. Here, inducing refers to the property that the map induces the same topology on its source space as the subspace topology on its image under the map, in the target space.

The diagonal map from the fiberwise product of two fiber bundles over a base space to the product of their total spaces is a topological embedding.


theorem isLowerSet_sUnion :
    ∀ {α : Type u_1} [inst : LE α] {S : Set (Set α)}, (∀ s ∈ S, IsLowerSet s) → IsLowerSet (⋃₀ S) := by sorry

The theorem `isLowerSet_sUnion` states that for any type `α` that has a less than or equal to relation, and any collection `S` of sets of type `α`, if every set in `S` is a lower set, then the union over all sets in `S` is also a lower set. In other words, if every set in `S` has the property that any element less than or equal to one of its members is also a member of the set, then the same property holds for the union of all the sets in `S`.

If every set in a collection of lower sets over a type with a total order has the property that any element less than or equal to one of itsmembers is also a member of the set, then the union of all the sets is also a lower set.


theorem SimpleGraph.edgeSet_fromEdgeSet :
    ∀ {V : Type u} (s : Set (Sym2 V)), SimpleGraph.edgeSet (SimpleGraph.fromEdgeSet s) = s \ {e | Sym2.IsDiag e} := by
  sorry

This theorem states that for any set `s` of unordered pairs of type `V`, the edge set for the simple graph constructed from set `s` is equal to the original set `s` excluding any unordered pairs that are on the diagonal. In other words, when a `SimpleGraph` is constructed from a set of edges, all self-loops (edges where both endpoints are the same vertex) are removed, and the remaining set of edges is exactly those from the original set.

The set of edges in the simple graph constructed from a set of unordered pairs equals the original set without self-loops (diagonal elements).


theorem Order.isPredLimitRecOn.proof_1 :
    ∀ {α : Type u_1} [inst : PartialOrder α] (x : αᵒᵈ), Order.IsSuccLimit x → Order.IsPredLimit (OrderDual.toDual x) :=
  by sorry

The theorem `Order.isPredLimitRecOn.proof_1` states that for any type `α` that has a partial order, if an element `x` in the dual of the ordered set `α` is a successor limit (meaning there is no other element in the set that is less than `x` and close to `x`), then the dual of `x` is a predecessor limit in the original ordered set (meaning there is no other element in the set that is greater than the dual of `x` and close to the dual of `x`).

If `x` is a successor limit in the dual of a partially ordered type `α`, then the dual of `x` is a predecessor limit in `α`.


ContinuousLinearEquiv.differentiableAt

theorem ContinuousLinearEquiv.differentiableAt :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {x : E}
      (iso : E ≃L[𝕜] F), DifferentiableAt 𝕜 (⇑iso) x :=
  by sorry

The theorem `ContinuousLinearEquiv.differentiableAt` states that for any non-trivially normed field `𝕜` and normed additive commutative groups `E` and `F` which are also normed spaces over `𝕜`, and any point `x` in `E`, if there exists a continuous linear equivalence `iso` between `E` and `F`, then the function represented by this equivalence `(⇑iso)` is differentiable at point `x`. In other words, for a given continuous linear equivalence, the associated function has a derivative at every point in its domain.

If `iso` is a continuous linear equivalence between normed spaces `E` and `F` over a non-trivially normed field `𝕜`, then `(⇑iso)` is differentiable at every point `x` in `E`.


theorem Filter.isAtom_pure : ∀ {α : Type u} {a : α}, IsAtom (pure a) := by sorry

The theorem `Filter.isAtom_pure` states that for any type `α` and for any element `a` of type `α`, the pure filter of `a` is an atom. In terms of preorder theory, an atom is an element that is distinct from the bottom element and has no other elements between it and the bottom element. Therefore, in the context of this theorem, the pure filter of `a` is not equivalent to the bottom element, and there are no other filters between it and the bottom filter.

For any type `α` and element `a` of type `α`, the pure filter of `a` is a filter atom.


theorem DirectedOn.isLUB_sSup :
    ∀ {α : Type u_2} [inst : CompletePartialOrder α] {d : Set α},
      DirectedOn (fun x x_1 => x ≤ x_1) d → IsLUB d (sSup d) :=
  by sorry

The theorem `DirectedOn.isLUB_sSup` states that for any type `α` with a complete partial order, and any directed set `d` of type `α` where the direction is given by the less than or equal to relation, the supremum (`sSup`) of the set `d` is a least upper bound of `d`. This is the least element that is greater than or equal to all elements in `d`, and in a partial order, if it exists, it is unique. It's worth noting that the notion of `DirectedOn` ensures that for any pair of elements in the set, there is another element in the set that is greater than or equal to both.

For any complete partial order `α` and directed set `d ⊆ α` with respect to the less-than-or-equal relation, the supremum of `d` is the unique least upper bound of `d`.


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

This theorem states that in any category `C`, for any objects `X` and `Y` in `C`, and for any isomorphism `α` from `X` to `Y`, the composition of `α` with the identity isomorphism on `Y` is just `α`. In other words, when you follow the isomorphism `α` by doing nothing (applying the identity), you have effectively just applied `α`. This reflects the identity property of composition with the identity isomorphism in category theory.

In any category, the composition of an isomorphism with the identity isomorphism is equal to the isomorphism itself.


theorem hasFDerivWithinAt_congr_set' :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {f : E → F}
      {f' : E →L[𝕜] F} {x : E} {s t : Set E} (y : E),
      s =ᶠ[nhdsWithin x {y}ᶜ] t → (HasFDerivWithinAt f f' s x ↔ HasFDerivWithinAt f f' t x) :=
  by sorry

This theorem, named `hasFDerivWithinAt_congr_set'`, states that for any non-trivially normed field `𝕜`, normed additive commutative groups `E` and `F`, and normed spaces over `𝕜` of `E` and `F`, given two functions `f` and `f'` that are mappings from `E` to `F` and `E` to `F` respectively, a point `x` in `E` and two sets `s` and `t` of `E`, and another point `y` in `E`, if the set `s` is almost everywhere equal to the set `t` within the neighborhood of `x` that excludes `y`, then the statement "the function `f` has a derivative `f'` at the point `x` within the set `s`" is equivalent to the statement "the function `f` has a derivative `f'` at the point `x` within the set `t`". In other words, the existence and nature of the derivative of the function `f` at the point `x` does not depend on the sets that are almost everywhere equal within the neighborhood of `x` excluding `y`.

If two sets around a point exclude a third point and are almost everywhere equal, then a function has a derivative of the same value in both sets.


theorem Nat.gcd_mul_left : ∀ (m n k : ℕ), Nat.gcd (m * n) (m * k) = m * Nat.gcd n k := by sorry

This theorem states that for any three natural numbers `m`, `n`, and `k`, the greatest common divisor of `m * n` and `m * k` is equal to `m` times the greatest common divisor of `n` and `k`. This is a property of the gcd operation that shows how it interacts with multiplication, highlighting its distributive nature.

The greatest common divisor of `m * n` and `m * k` is equal to `m` times the greatest common divisor of `n` and `k`.


theorem Finset.disjiUnion_eq_biUnion :
    ∀ {α : Type u_1} {β : Type u_2} [inst : DecidableEq β] (s : Finset α) (f : α → Finset β)
      (hf : Set.PairwiseDisjoint (↑s) f), Finset.disjiUnion s f hf = Finset.biUnion s f :=
  by sorry

The theorem `Finset.disjiUnion_eq_biUnion` states that for any finite set `s` of type `α` and any function `f` from `α` to finite sets of type `β` (where `β` has decidable equality), if the sets resulting from applying `f` to distinct elements of `s` are pairwise disjoint, then the disjoint union of these sets as defined by `Finset.disjiUnion` is equal to the union of these sets as defined by `Finset.biUnion`. In other words, when the sets are guaranteed to be disjoint, the two methods of forming a union give the same result.

For any finite set `s` and function `f` from a set `α` to finite sets of `β` with decidable equality, if the sets `f x` and `f y` are disjoint for distinct `x` and `y` in `s`, then `Finset.disjiUnion (map f s) = Finset.biUnion (map f ``s``)`.