theorem Int.subNatNat_eq_coe : ∀ {m n : ℕ}, Int.subNatNat m n = ↑m - ↑n := by sorry

This theorem states that for all natural numbers `m` and `n`, the integer value obtained by the function `Int.subNatNat` applied to `m` and `n` is equivalent to the result of subtracting the integer equivalent of `n` from the integer equivalent of `m`. Here, the notation `↑m` and `↑n` denotes the integer equivalent of the natural numbers `m` and `n` respectively.

For all natural numbers m and n, Int.subNatNat m n equals the integer value obtained by subtracting ↑n from ↑m.


/-- The gaussian pdf is nonnegative.  -/
theorem ProbabilityTheory.gaussianPDFReal_nonneg :
    ∀ (μ : ℝ) (v : NNReal) (x : ℝ), 0 ≤ ProbabilityTheory.gaussianPDFReal μ v x := by sorry

This theorem states that the probability density function of the Gaussian distribution is always nonnegative. In other words, for any real number `μ` (the mean of the distribution), any nonnegative real number `v` (the variance of the distribution), and any real number `x`, the value of the Gaussian probability density function at `x` is greater than or equal to zero. This is consistent with the definition of a probability density function, as it should be nonnegative for all possible events (or values of `x`).

The Gaussian probability density function, defined by `x => 1 / (sqrt(2 *. pi) *. v) *. exp (-. ((x - μ) ^ 2) / (2 *. v ^ 2)),` where `μ` is the mean and `v` is the variance, is nonnegative for all real numbers `x`, `μ`, and `v` (`v` nonnegative).


theorem tendsto_subtype_rng :
    ∀ {X : Type u} [inst : TopologicalSpace X] {Y : Type u_5} {p : X → Prop} {l : Filter Y} {f : Y → Subtype p}
      {x : Subtype p}, Filter.Tendsto f l (nhds x) ↔ Filter.Tendsto (fun x => ↑(f x)) l (nhds ↑x) :=
  by sorry

The theorem `tendsto_subtype_rng` states that for any topological space `X`, any type `Y`, any property `p` of `X`, any filter `l` on `Y`, any function `f` from `Y` to `Subtype p` and any element `x` of `Subtype p`, the function `f` tends to the neighborhood filter of `x` if and only if the function which applies `f` and then takes the underlying element of `Subtype p` tends to the neighborhood filter of the underlying element of `x`. In other words, it asserts that the limit of a function into a subtype is equivalent to the limit of the same function composed with the subtype's inclusion function, into the original type.

For any topological space X, type Y, property p of X, filter l on Y, function f from Y to Subtype p over X, and element x of Subtype p, the function f tends to the neighborhood filter of x if and only if the composition of f with the inclusion function of Subtype p into X tends to the neighborhood filter of x's underlying element in X.


theorem IsLocallyConstant.comp₂ :
    ∀ {X : Type u_1} [inst : TopologicalSpace X] {Y₁ : Type u_5} {Y₂ : Type u_6} {Z : Type u_7} {f : X → Y₁}
      {g : X → Y₂},
      IsLocallyConstant f → IsLocallyConstant g → ∀ (h : Y₁ → Y₂ → Z), IsLocallyConstant fun x => h (f x) (g x) :=
  by sorry

The theorem `IsLocallyConstant.comp₂` states that, given any two functions `f` and `g` from a topological space `X` to `Y₁` and `Y₂` respectively, if both `f` and `g` are locally constant then for any function `h` from `Y₁` and `Y₂` to `Z`, the function composed by `h`, `f` and `g` is also locally constant. In other words, the theorem asserts the preservation of local constancy under function composition.

If `f` and `g` are locally constant functions from a topological space `X` to `Y₁` and `Y₂` respectively, then their composition `h ∘ f ∘ g` is also a locally constant function from `X` to `Z`, for any function `h` from `Y₁` to `Z`.


theorem CategoryTheory.MonoidalCategory.whiskerLeft_inv_hom :
    ∀ {C : Type u} [𝒞 : CategoryTheory.Category.{v, u} C] [inst : CategoryTheory.MonoidalCategory C] (X : C) {Y Z : C}
      (f : Y ≅ Z),
      CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategory.whiskerLeft X f.inv)
          (CategoryTheory.MonoidalCategory.whiskerLeft X f.hom) =
        CategoryTheory.CategoryStruct.id (CategoryTheory.MonoidalCategory.tensorObj X Z) :=
  by sorry

This theorem, named `CategoryTheory.MonoidalCategory.whiskerLeft_inv_hom`, states that for any Category `C` that is also a Monoidal Category, and for any objects `X`, `Y` and `Z` in `C`, if there is an isomorphism `f` from `Y` to `Z`, then the composition of `whiskerLeft` applied to `X` and `f.inv`, followed by `whiskerLeft` applied to `X` and `f.hom`, is equal to the identity on the tensor product of `X` and `Z`.

In more mathematical terms, the theorem is stating that $(f^{-1} * f) \otimes X = I_{X\otimes Z}$ in the context of a monoidal category, where $*$ denotes composition, $\otimes$ is the tensor product, and $I_{X\otimes Z}$ is the identity morphism on the tensor product of `X` and `Z`. This encapsulates one of the fundamental properties of monoidal categories.

In a monoidal category, the composition of the inverse and the morphism of any object with an isomorphism is equal to the identity morphism on their tensor product.


ContDiffBump.integrable

theorem ContDiffBump.integrable :
    ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [inst_2 : HasContDiffBump E]
      [inst_3 : MeasurableSpace E] {c : E} (f : ContDiffBump c) {μ : MeasureTheory.Measure E} [inst_4 : BorelSpace E]
      [inst_5 : FiniteDimensional ℝ E] [inst_6 : MeasureTheory.IsLocallyFiniteMeasure μ],
      MeasureTheory.Integrable (↑f) μ :=
  by sorry

The theorem `ContDiffBump.integrable` states that for any continuously differentiable bump function `f` centered at a point `c` in a normed additive commutative group `E` that is also a normed space over the real numbers, and for which `E` is a measurable space, a Borel space, and a finite-dimensional vector space over the real numbers, and given a measure `μ` on `E` that is locally finite, the function `f` is integrable with respect to the measure `μ`. In mathematical terms, the integral of the norm of `f` with respect to `μ` is finite and that `f` is almost everywhere strongly measurable.

A continuously differentiable bump function centered at a point in a locally finite, Borel measure on a finite-dimensional, normed additive commutative group that is also a normed space over the real numbers is integrable.


theorem Mathlib.Control.EquivFunctor.Instances._auxLemma.1 :
    ∀ {α : Sort u_1} [inst : Subsingleton α] (x y : α), (x = y) = True := by sorry

This theorem, named `Mathlib.Control.EquivFunctor.Instances._auxLemma.1`, states that for any sort `α` that has an instance of `Subsingleton` (which means there is at most one element of that type), for any two elements `x` and `y` of `α`, it's always true that `x = y`. In other words, in any type where there can be at most one instance, any two instances of that type must be the same.

In a type with at most one element (i.e., a subsingleton type), any two elements are equal.


/-- The complex cosine function is everywhere strictly differentiable, with the derivative
`-sin x`.  -/
theorem Complex.hasStrictDerivAt_cos : ∀ (x : ℂ), HasStrictDerivAt Complex.cos (-Complex.sin x) x := by sorry

The theorem `Complex.hasStrictDerivAt_cos` states that the complex cosine function is strictly differentiable at all points in the complex plane. The derivative at any point `x` in the complex plane is given by the negative of the complex sine of `x`, i.e., `-sin(x)`.

The complex cosine function is strictly differentiable with derivative $-i\sin(x)$ for all complex numbers $x$.


theorem Nat.floor_lt :
    ∀ {α : Type u_2} [inst : LinearOrderedSemiring α] [inst_1 : FloorSemiring α] {a : α} {n : ℕ},
      0 ≤ a → (⌊a⌋₊ < n ↔ a < ↑n) :=
  by sorry

This theorem states that for any type `α` that is a linear ordered semiring and a floor semiring, for any instance `a` of that type `α` and any natural number `n`, if `a` is greater than or equal to zero, then the floor of `a` is less than `n` if and only if `a` is less than the conversion of `n` to the type `α`. In other words, it establishes an equivalence between the comparison of the floor of a non-negative number `a` with a natural number `n` and the comparison of `a` itself with `n` in the context of the type `α`.

For any linear ordered semiring and floor semiring type `α`, with `a : α` non-negative, the floor of `a` is less than a natural number `n` if and only if `a` is strictly less than the conversion of `n` to `α`.


theorem tendsto_atTop_ciSup :
    ∀ {α : Type u_1} {ι : Type u_3} [inst : Preorder ι] [inst_1 : TopologicalSpace α]
      [inst_2 : ConditionallyCompleteLattice α] [inst_3 : SupConvergenceClass α] {f : ι → α},
      Monotone f → BddAbove (Set.range f) → Filter.Tendsto f Filter.atTop (nhds (⨆ i, f i)) :=
  by sorry

This theorem, named `tendsto_atTop_ciSup`, states that for any types `α` and `ι` where `α` has a topological space structure, is a conditionally complete lattice, and satisfies the supremum convergence class properties, and `ι` has a preorder structure, and given a function `f` from `ι` to `α` that is monotone and its range is bounded above, then the function `f` tends to the supremum of `f i` as `i` tends towards infinity. In other words, for any `α` in the supremum neighborhood, there exists an `i` such that for all `j` greater than or equal to `i`, `f(j)` is in `α`. The supremum here is the least upper bound of `f i` for all `i` in `ι`.

Given a monotone function `f` from a preordered type `ι` to a topological space `α` with a conditionally complete lattice structure and supremum convergence properties, if the range of `f` is bounded above, then for any `α` in the supremum neighborhood, there exists an `i` such that for all `j ≥ i`, `f(j)` is in `α`, i.e., `f` converges to the supremum of `f(i)` as `i` approaches infinity.


theorem Int.le_of_lt_add_one : ∀ {a b : ℤ}, a < b + 1 → a ≤ b := by sorry

This theorem, `Int.le_of_lt_add_one`, states that for all integer values `a` and `b`, if `a` is less than `b + 1`, then `a` is also less than or equal to `b`. It establishes a relationship between the "less than" and "less than or equal to" comparisons in the context of integer arithmetic.

For all integers `a` and `b`, if `a` is less than `b + 1`, then `a` is less than or equal to `b`.


theorem map_iSup :
    ∀ {F : Type u_1} {α : Type u_2} {β : Type u_3} {ι : Sort u_6} [inst : FunLike F α β] [inst_1 : SupSet α]
      [inst_2 : SupSet β] [inst_3 : sSupHomClass F α β] (f : F) (g : ι → α), f (⨆ i, g i) = ⨆ i, f (g i) :=
  by sorry

The theorem `map_iSup` states that for any types `F`, `α`, `β`, and `ι`, if `F` is a function-like mapping from `α` to `β`, both `α` and `β` are SupSet (i.e., they are equipped with a supremum operation), and `F` respects the supremum operation (i.e., `F` is a sup-semilattice homomorphism), then the function `f` of type `F` distributes over the supremum of a family `(g i)` of elements in `α` indexed by `ι`. In mathematical terms, this means that for any function `f` and family `g`, we have `f (sup_i g i) = sup_i f (g i)`.

If `F` is a sup-semilattice homomorphism from a SupSet `α` to a SupSet `β`, then `F (sup_i g i) = sup_i F (g i)`.


theorem Ioo_mem_nhdsWithin_Iio :
    ∀ {α : Type u} [inst : TopologicalSpace α] [inst_1 : LinearOrder α] [inst_2 : ClosedIicTopology α] {a b c : α},
      b ∈ Set.Ioc a c → Set.Ioo a c ∈ nhdsWithin b (Set.Iio b) :=
  by sorry

This theorem states that for any type `α` equipped with a topology and a linear order, and any three elements `a`, `b`, and `c` of `α`, if `b` is in the left-open right-closed interval from `a` to `c`, then the left-open right-open interval from `a` to `c` is in the neighborhood within the left-infinite right-open interval at `b`, under the condition that `α` has the closed lower semi-infinite topology.

In simpler terms, it asserts that if `b` is strictly greater than `a` and less than or equal to `c`, then any "small enough" neighborhood of `b` that does not include `b` itself but only values less than `b`, will contain some values that are strictly greater than `a` and strictly less than `c`. The "small enough" is determined by the topology on `α` which is assumed to be a closed lower semi-infinite topology.

Given a type `α` with a topology and linear order, if `b` is in the left-open right-closed interval between `a` and `c` in `α`, then there exists a neighborhood of `b` containing elements strictly between `a` and `c` under the assumption of the closed lower semi-infinite topology.


/-- The empty set is not an equivalence class.  -/
theorem Setoid.empty_not_mem_classes : ∀ {α : Type u_1} {r : Setoid α}, ∅ ∉ Setoid.classes r := by sorry

This theorem states that the empty set is not an equivalence class. In other words, for any type `α` and any equivalence relation `r` on `α`, the set of equivalence classes of `r` does not contain the empty set. This means that there does not exist an element in `α` such that its equivalence class under `r` is empty.

For any type `α` and equivalence relation `r` on `α`, the empty set is not an equivalence class under `r`.


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

This theorem states that for any category `C`, Grothendieck topology `J` on `C`, functor `F` from `Cᵒᵖ` to a type `w`, and a sub-presheaf `G` of the functor `F`, if `F` is a sheaf for the topology `J`, then the presheaf obtained by applying the `sheafify` operation to `G` and then converting the resulting sub-presheaf back into a presheaf is also a sheaf for the topology `J`. In other words, sheafifying a sub-presheaf and then converting it to a presheaf preserves the sheaf property when the original functor is a sheaf.

If a functor sheafifies a sub-presheaf in a Grothendieck topology and is itself a sheaf, then the resulting presheaf is also a sheaf.


DifferentiableAt.sub

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

The theorem `DifferentiableAt.sub` states that for any nontrivially normed field `𝕜`, as well as any normed additive commutative groups `E` and `F` that are also normed spaces over `𝕜`, if a function `f` from `E` to `F` is differentiable at a point `x` in `E` and another function `g` from `E` to `F` is also differentiable at the same point `x`, then the function that maps any point `y` in `E` to the difference of `f(y)` and `g(y)` is also differentiable at `x`. In other words, the difference of two differentiable functions is itself differentiable at the same point.

If two differentiable functions from a nontrivially normed additive commutative group into another normed space over the same field are given, then their difference is also differentiable at any common point.


/-- If the angle between three points is nonzero, the last two points are not equal.  -/
theorem EuclideanGeometry.right_ne_of_oangle_ne_zero :
    ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V]
      [inst_2 : MetricSpace P] [inst_3 : NormedAddTorsor V P] [hd2 : Fact (FiniteDimensional.finrank ℝ V = 2)]
      [inst_4 : Module.Oriented ℝ V (Fin 2)] {p₁ p₂ p₃ : P}, EuclideanGeometry.oangle p₁ p₂ p₃ ≠ 0 → p₃ ≠ p₂ :=
  by sorry

This theorem, from the field of Euclidean Geometry, states that if the angle formed by three points, `p₁`, `p₂`, and `p₃`, is not zero, then the last two points, `p₂` and `p₃`, cannot be the same point. The theorem is formulated in the context of vector spaces and requires that the underlying space `V` be a 2-dimensional, real inner product space. It also requires that `V` is given an orientation.

In a 2-dimensional, real inner product space with orientation, distinct points `p₁`, `p₂`, and `p₃` form a non-collinear triangle if and only if the angle between the vectors `p₁-p₂` and `p₂-p₃` is non-zero.


theorem Subtype.coe_lt_coe : ∀ {α : Type u} [inst : LT α] {p : α → Prop} {x y : Subtype p}, ↑x < ↑y ↔ x < y := by sorry

This theorem states that for any type `α` that has a less-than (`<`) operation, and for any property `p` that applies to `α`, then for any two subtypes `x` and `y` of `α` satisfying property `p`, `x` is less than `y` if and only if the underlying value of `x` (obtained using the coercion function `↑x`) is less than the underlying value of `y` (`↑y`). In simpler terms, it means that the order relation `<` is preserved when transitioning from subtype to its underlying value.

For any type `α` with a `<` operation and any subtypes `x` and `y` of `α` satisfying a property `p`, if `x < y` then `↑x < ↑y`.


theorem sum_add_tsum_nat_add :
    ∀ {G : Type u_2} [inst : AddCommGroup G] [inst_1 : TopologicalSpace G] [inst_2 : TopologicalAddGroup G]
      [inst_3 : T2Space G] {f : ℕ → G} (k : ℕ),
      Summable f → (Finset.sum (Finset.range k) fun i => f i) + ∑' (i : ℕ), f (i + k) = ∑' (i : ℕ), f i :=
  by sorry

The theorem `sum_add_tsum_nat_add` states that for any type `G` that has the structure of an additive commutative group, a topological space, a topological additive group, and a T2 space (also known as a Hausdorff space), and for any function `f` from the natural numbers to `G`, if `f` is summable, then the sum of `f` over the set of natural numbers less than a given number `k`, plus the infinite sum of `f` applied to each natural number `i` increased by `k`, is equal to the infinite sum of `f` over all the natural numbers. This theorem essentially states a shifting property of the infinite sum of a summable sequence.

For any summable function `f` from natural numbers to an additive commutative group `G` in a T2 topological space with the structure of a topological additive group, the sum of `f` over the first `k` natural numbers and the infinite sum of `f` shifted by `k` are equal.


theorem Mathlib.Data.Set.Prod._auxLemma.7 : ∀ {a b c : Prop}, (a ∧ b ∧ c) = (b ∧ a ∧ c) := by sorry

This theorem states that for any three propositions `a`, `b`, and `c`, the conjunction of `a`, `b`, and `c` in the order `a ∧ b ∧ c` is logically equivalent to the conjunction of these propositions in the order `b ∧ a ∧ c`. In other words, the order in which the propositions are joined with "and" does not change the truth of the overall statement.

The theorem asserts that for any propositions `a`, `b`, and `c`, the conjunctions `a ∧ b ∧ c` and `b ∧ a ∧ c` are logically equivalent.


theorem CstarRing.nnnorm_star_mul_self :
    ∀ {E : Type u_2} [inst : NonUnitalNormedRing E] [inst_1 : StarRing E] [inst_2 : CstarRing E] {x : E},
      ‖star x * x‖₊ = ‖x‖₊ * ‖x‖₊ :=
  by sorry

This theorem states that for any element `x` of a type `E` that forms a non-unital normed ring, a star ring, and a C* ring, the non-negative norm of the product of the star of `x` and `x` itself is equal to the product of the non-negative norm of `x` with itself. In mathematical notation, this can be expressed as ‖star(x) * x‖₊ = ‖x‖₊ * ‖x‖₊.

For any element `x` in a normed ring that is also a star ring and a C* ring, the norm of the product of `x`'s adjoint and `x` equals the square of `x`'s norm.


theorem MeasureTheory.Measure.sub_eq_zero_of_le :
    ∀ {α : Type u_1} {m : MeasurableSpace α} {μ ν : MeasureTheory.Measure α}, μ ≤ ν → μ - ν = 0 := by sorry

This is a theorem in measure theory. It states that for any type `α`, any measurable space `m` of that type, and any two measures `μ` and `ν` on that measurable space, if `μ` is less than or equal to `ν`, then the difference between `μ` and `ν` is zero. In other words, in the context of measures, you can't subtract a larger measure from a smaller one; doing so will always result in zero.

For any measurable spaces `(α, m)` and measures `μ` and `ν` on `m` with `μ ≤ ν`, we have `μ - ν = 0`.


theorem Valued.extension_extends :
    ∀ {K : Type u_1} [inst : Field K] {Γ₀ : Type u_2} [inst_1 : LinearOrderedCommGroupWithZero Γ₀] [hv : Valued K Γ₀]
      (x : K), Valued.extension (↑K x) = Valued.v x :=
  by sorry

The theorem "Valued.extension_extends" states that for any given valued field 'K' (a field with a valuation) with valuation range of 'Γ₀' which is a linearly ordered commutative group with zero, and any element 'x' of 'K', the extension of the valuation of 'K' to its completion at 'x' is equal to the original valuation of 'x'. In simpler terms, this theorem says that extending the valuation from the field to its completion preserves the valuation of all elements in the field.

For any valued field 'K' with linearly ordered, commutative valuation range 'Γ₀', the extension of the valuation of 'K' to its completion at any element 'x' equals the original valuation of 'x'.


/-- If a point `x` belongs to `s`, then its edist to `s` vanishes  -/
theorem EMetric.infEdist_zero_of_mem :
    ∀ {α : Type u} [inst : PseudoEMetricSpace α] {x : α} {s : Set α}, x ∈ s → EMetric.infEdist x s = 0 := by sorry

The theorem `EMetric.infEdist_zero_of_mem` states that for any type `α` that forms a pseudo extended metric space, and for any point `x` of type `α` belonging to a set `s` of type `α`, the extended minimum ('infimum') distance from `x` to `s` is zero. In other words, if a point is a member of a given set within a pseudo extended metric space, its minimum distance to the set is always zero.

For any pseudo extended metric space `(α, d)` and set `s ⊆ α`, the infimum of distances from any point `x ∈ s` to `s` is 0.


theorem Polynomial.natDegree_le_of_dvd :
    ∀ {R : Type u} [inst : Semiring R] [inst_1 : NoZeroDivisors R] {p q : Polynomial R},
      p ∣ q → q ≠ 0 → Polynomial.natDegree p ≤ Polynomial.natDegree q :=
  by sorry

The theorem `Polynomial.natDegree_le_of_dvd` states that for all types `R` that form a semiring and have no zero divisors, and for all polynomials `p` and `q` defined over `R`, if `p` divides `q` and `q` is not zero, then the natural degree of `p` (obtained by the function `Polynomial.natDegree`) is less than or equal to the natural degree of `q`. In other words, the degree of a divisor polynomial is always less than or equal to the degree of the dividend polynomial, given that the dividend is not zero.

For all semirings R without zero divisors and polynomials p, q over R with p dividing non-zero q, the natural degree of p is less than or equal to the natural degree of q.


theorem Mathlib.Topology.Order.Basic._auxLemma.6 :
    ∀ {α : Type u} {β : Type v} {ι : Sort x} {f : α → β} {x : Filter α} {y : ι → Filter β},
      Filter.Tendsto f x (⨅ i, y i) = ∀ (i : ι), Filter.Tendsto f x (y i) :=
  by sorry

This theorem states that for any types `α`, `β` and `ι`, a function `f` from `α` to `β`, a filter `x` on type `α`, and a function `y` from `ι` to filters on `β`, the function `f` tends to the infimum of the filters `y i` (denoted by `(⨅ i, y i)`) if and only if the function `f` tends to each filter `y i` for all `i` in `ι`. In other words, the function `f` has a limit at the infimum of the filters if and only if it has a limit at each of the filters.

A function from types `α` to `β` tends to the infimum of a family of filters on `β` indexed by `ι` if and only if it tends to each filter in the family for all indices `i` in `ι`.


theorem SymAlg.unsym_add :
    ∀ {α : Type u_1} [inst : Add α] (a b : αˢʸᵐ), SymAlg.unsym (a + b) = SymAlg.unsym a + SymAlg.unsym b := by sorry

The theorem `SymAlg.unsym_add` states that for any type `α` that has an addition operation, and for any two symbolic elements `a` and `b` of this type, the unsymbolization of the sum of `a` and `b` is the same as the sum of the unsymbolized `a` and the unsymbolized `b`. In other words, the `unsym` operation commutes with the `+` operation.

For any type `α` with addition and for all `a, b : α`, the unsymbolic representation of `a + b` is equal to the unsymbolic representation of `a + b`.


theorem dist_left_midpoint :
    ∀ {V : Type u_2} {P : Type u_3} [inst : SeminormedAddCommGroup V] [inst_1 : PseudoMetricSpace P]
      [inst_2 : NormedAddTorsor V P] {𝕜 : Type u_6} [inst_3 : NormedField 𝕜] [inst_4 : NormedSpace 𝕜 V]
      [inst_5 : Invertible 2] (p₁ p₂ : P), dist p₁ (midpoint 𝕜 p₁ p₂) = ‖2‖⁻¹ * dist p₁ p₂ :=
  by sorry

The theorem `dist_left_midpoint` states that for any points `p₁` and `p₂` in a pseudo-metric space `P`, which is also a normed add-torsor over a seminormed add-commutative group `V` (meaning that we can measure the distance between points and add displacements in `P`), and `V` is a normed space over a normed field `𝕜`, the distance between `p₁` and the midpoint between `p₁` and `p₂` is equal to the inverse of the norm of 2 multiplied by the distance between `p₁` and `p₂`. This essentially tells us that the midpoint is exactly half the distance away from either endpoint in a normed space.

In a pseudometric space that is a normed add-torsor over a normed semigroup in a normed field, the distance from a point to the midpoint of two points is equal to the constant 1/2 multiplied by the distance between the two points.


/-- **Gram-Schmidt Orthogonalisation**:
`gramSchmidt` produces an orthogonal system of vectors.  -/
theorem gramSchmidt_orthogonal :
    ∀ (𝕜 : Type u_1) {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
      {ι : Type u_3} [inst_3 : LinearOrder ι] [inst_4 : LocallyFiniteOrderBot ι]
      [inst_5 : IsWellOrder ι fun x x_1 => x < x_1] (f : ι → E) {a b : ι},
      a ≠ b → ⟪gramSchmidt 𝕜 f a, gramSchmidt 𝕜 f b⟫_𝕜 = 0 :=
  by sorry

The **Gram-Schmidt Orthogonalisation** theorem states that for any type 𝕜, a given type E that is a NormedAddCommGroup and an InnerProductSpace over 𝕜, and any type ι that is a linearly ordered and locally finite ordered set with a well-defined ordering function, the `gramSchmidt` function produces an orthogonal system of vectors for any function f from ι to E. In other words, for any two different elements a and b in ι, the inner product of the vectors produced by applying `gramSchmidt` to a and b is equal to zero, indicating that these vectors are orthogonal.

For any normed vector space E over a normed field 𝕜 and any linearly ordered and locally finite index set ι, the Gram-Schmidt process constructs an orthogonal system of vectors in E from the given set.


theorem sum_le_hasSum :
    ∀ {ι : Type u_1} {α : Type u_3} [inst : OrderedAddCommMonoid α] [inst_1 : TopologicalSpace α]
      [inst_2 : OrderClosedTopology α] {f : ι → α} {a : α} (s : Finset ι),
      (∀ i ∉ s, 0 ≤ f i) → HasSum f a → (Finset.sum s fun i => f i) ≤ a :=
  by sorry

The theorem `sum_le_hasSum` states that for any types `ι` and `α`, where `α` forms an ordered additive commutative monoid and has a topology such that its order topology is closed, and for any function `f` mapping `ι` to `α` and any element `a` of `α`, given a finite set `s` of `ι`, if for every element `i` not in `s`, `f(i)` is non-negative, and the series formed by `f` has a sum `a`, then the sum of `f(i)` for `i` in `s` is less than or equal to `a`. In mathematical terms, this states that if $\sum_{i \in \mathbb{N}} f(i)$ converges to a limit `a`, then the partial sum over any finite subset is always less than or equal to `a`, assuming non-negativity for terms outside the subset.

For any function from a countable set to an ordered additive commutative monoid with a closed order topology, if the function's series has a sum and all terms outside a finite subset are non-negative, then the sum of terms in the finite subset is less than or equal to the series' sum.


OneOneReducible.trans

theorem OneOneReducible.trans :
    ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : Primcodable α] [inst_1 : Primcodable β]
      [inst_2 : Primcodable γ] {p : α → Prop} {q : β → Prop} {r : γ → Prop}, p ≤₁ q → q ≤₁ r → p ≤₁ r :=
  by sorry

The theorem `OneOneReducible.trans` states that for any three types `α`, `β`, and `γ` that are Primcodable, and any three properties `p` of `α`, `q` of `β`, and `r` of `γ`, if `p` is one-one reducible to `q`, and `q` is one-one reducible to `r`, then `p` is one-one reducible to `r`. Here, "one-one reducible" means there exists some function that maps every instance of the first property to a unique instance of the second, preserving the structure in the process. This theorem is essentially a transitivity property for one-one reducibility between properties on different types.

If `p` is one-one reducible to `q` and `q` is one-one reducible to `r`, then `p` is one-one reducible to `r`. (One-one reducibility is a transitive relation between properties on different types.)


List.Chain'.cons'

theorem List.Chain'.cons' :
    ∀ {α : Type u} {R : α → α → Prop} {x : α} {l : List α},
      List.Chain' R l → (∀ y ∈ List.head? l, R x y) → List.Chain' R (x :: l) :=
  by sorry

The theorem `List.Chain'.cons'` states that for any type `α`, any binary relation `R` on `α`, any element `x` of type `α`, and any list `l` of elements of type `α`, if `R` holds between the adjacent elements of `l` (that is, `l` is a chain with respect to `R`) and `R` holds between `x` and the first element of `l` (if such an element exists), then the list obtained by prepending `x` to `l` is also a chain with respect to `R`. In other words, we can extend a chain by adding an element to the beginning, provided the new element is related to the first element of the original chain by `R`.

If `R` is a binary relation on `α`, `l` is a chain of `α` with respect to `R`, and `x ∈ α` is related to the first element of `l` (if it exists) by `R`, then `x :: l` is also a chain of `α` with respect to `R`.


IsCompact.isSeparable

/-- A compact set is separable.  -/
theorem IsCompact.isSeparable :
    ∀ {α : Type u} [inst : PseudoMetricSpace α] {s : Set α}, IsCompact s → TopologicalSpace.IsSeparable s := by sorry

This theorem states that any compact set in a pseudo-metric space is separable. In detail, given a type `α` equipped with a pseudo-metric space structure, and a set `s` of this type, if `s` is compact (i.e., for every nontrivial filter `f` that contains `s`, there exists an element `a` in `s` such that every set of `f` meets every neighborhood of `a`), then `s` is also separable. That is, there exists a countable set `c` such that `s` is contained in the closure of `c`.

In a pseudo-metric space, every compact set is separable, meaning there exists a countable subset whose closure contains the compact set.


theorem Int.sub_zero : ∀ (a : ℤ), a - 0 = a := by sorry

This theorem states that for any integer `a`, subtracting zero from `a` will result in `a`. In mathematical terms, it can be expressed as ∀a ∈ ℤ, a - 0 = a. It's a simple property of integers relating to the operation of subtraction.


theorem MeasureTheory.MeasurePreserving.set_integral_image_emb :
    ∀ {X : Type u_1} {E : Type u_3} [inst : MeasurableSpace X] [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace ℝ E] {μ : MeasureTheory.Measure X} {Y : Type u_5} {x : MeasurableSpace Y} {f : X → Y}
      {ν : MeasureTheory.Measure Y},
      MeasureTheory.MeasurePreserving f μ ν →
        MeasurableEmbedding f → ∀ (g : Y → E) (s : Set X), ∫ (y : Y) in f '' s, g y ∂ν = ∫ (x : X) in s, g (f x) ∂μ :=
  by sorry

This theorem, `MeasureTheory.MeasurePreserving.set_integral_image_emb`, establishes a result in measure theory and integration theory. It states that given two types X and Y with measurable spaces and a function `f` from X to Y, if `f` preserves the measure μ on X under the measure ν on Y and `f` is a measurable embedding, then for any function `g` from Y to a normed additively commutative group E and any set `s` of X, the integral of `g` over the image of `s` under `f` with respect to the measure ν equals the integral of `g ∘ f` over `s` with respect to the measure μ. That is, the measures and the integrals are preserved under the function `f`.

Given measurable spaces (X, μ) and (Y, ν), a measurable embedding and measure-preserving function f : X → Y, and a function g : Y → an additively commutative group E, the integral of g over the image of a set s ⊆ X under f with respect to ν equals the integral of g ∘ f over s with respect to μ.


theorem SetTheory.PGame.lf_of_moveRight_le :
    ∀ {x y : SetTheory.PGame} {j : SetTheory.PGame.RightMoves x},
      SetTheory.PGame.moveRight x j ≤ y → SetTheory.PGame.LF x y :=
  by sorry

The theorem `SetTheory.PGame.lf_of_moveRight_le` states that for any games `x` and `y`, and for any allowable move `j` by the Right player in the game `x`, if the new game resulting from the Right player making the move `j` in game `x` is less or equal to game `y` (i.e., `SetTheory.PGame.moveRight x j ≤ y`), then the Left player can win game `x` as the first player when playing against game `y` (i.e., `SetTheory.PGame.LF x y`). In other words, this theorem provides a condition under which the Left player has a winning strategy in the game `x` against `y`.

If for any game `x`, allowable move `j` by the Right player, and game `y`, `SetTheory.PGame.moveRight x j ≤ y` implies `SetTheory.PGame.LF x y`.


theorem Ordinal.opow_le_opow_right : ∀ {a b c : Ordinal.{u_1}}, 0 < a → b ≤ c → a ^ b ≤ a ^ c := by sorry

The theorem `Ordinal.opow_le_opow_right` states that for all ordinals `a`, `b`, and `c` in a given type, if `a` is greater than 0 and `b` is less than or equal to `c`, then `a` raised to the power `b` is less than or equal to `a` raised to the power `c`. This property can be seen as an extension of the monotonicity of the exponentiation function to the context of ordinals.

For all ordinals `a`, `b`, and `c` with `a > 0` and `b <= c`, we have `a^b <= a^c`.


theorem add_pow_char_of_commute :
    ∀ (R : Type u_1) [inst : Semiring R] {p : ℕ} [hp : Fact (Nat.Prime p)] [inst_1 : CharP R p] (x y : R),
      Commute x y → (x + y) ^ p = x ^ p + y ^ p :=
  by sorry

The theorem `add_pow_char_of_commute` states that, for any type `R` which is a semiring, and for any natural number `p` which is prime (characteristic of `R` is `p`), given any two elements `x` and `y` of `R` that commute, that is `x * y = y * x`, the power of the sum `(x + y)` to the `p` equals the sum of the power `x` to the `p` and `y` to the `p`. In mathematical terms, it can be stated as: if `x` and `y` commute in a semiring `R` and `p` is a prime number that is also the characteristic of `R`, then `(x + y)^p = x^p + y^p`.

If `x` and `y` commute in a semiring `R` of prime characteristic `p`, then `(x + y)^p = x^p + y^p`.


theorem Sum.swap_swap : ∀ {α : Type u_1} {β : Type u_2} (x : α ⊕ β), Sum.swap (Sum.swap x) = x := by sorry

This theorem, named `Sum.swap_swap`, states that for all types `α` and `β` and for any value `x` of type `α ⊕ β` (a sum type which can be either a value of type `α` or a value of type `β`), applying the `Sum.swap` function twice to `x` yields `x` itself. In other words, it is stating that swapping the components of the sum type twice reverts back to the original sum type.

For all types `α` and `β`, and for any `x` of type `α ⊕ β`, the application of `Sum.swap` twice to `x` equals `x`.


theorem norm_eq_of_mem_sphere :
    ∀ {E : Type u_6} [inst : SeminormedAddGroup E] {r : ℝ} (x : ↑(Metric.sphere 0 r)), ‖↑x‖ = r := by sorry

This theorem, `norm_eq_of_mem_sphere`, states that for every type `E` which is a semi-normed addition group, and for every real number `r`, if `x` is a point in the metric sphere centered at the origin (0) with radius `r`, then the norm of `x` is equal to `r`. In mathematical terms, if a point `x` belongs to the sphere of radius `r` centered at the origin in a semi-normed addition group, then the norm of `x` (denoted as `‖x‖`) is equal to `r`.

In a semi-normed additive group, the norm of a point in the metric sphere centered at the origin equals the sphere's radius.


theorem MeasureTheory.condexp_undef :
    ∀ {α : Type u_1} {F' : Type u_3} [inst : NormedAddCommGroup F'] [inst_1 : NormedSpace ℝ F']
      [inst_2 : CompleteSpace F'] {m m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} {f : α → F'},
      ¬MeasureTheory.Integrable f μ → MeasureTheory.condexp m μ f = 0 :=
  by sorry

The theorem `MeasureTheory.condexp_undef` states that for any types `α` and `F'`, with `F'` being a normed additive commutative group, a normed space over the real numbers, and a complete space, and given measurable spaces `m` and `m0`, a measure `μ`, and a function `f` from `α` to `F'`, if `f` is not integrable with respect to the measure `μ`, then the conditional expectation of `f` (as defined by `MeasureTheory.condexp`) is zero. In other words, if the integral of the norm of `f` (with respect to `μ`) is not finite, then the conditional expectation of `f` is zero.

If `μ` is a measure on the measurable spaces `(α, Σ)` and `(F', Σ')`, `F'` is a normed additive commutative group and a complete normed space over the real numbers, `f: α → F'` is measurable and not integrable with respect to `μ`, then `MeasureTheory.condexp f μ μ0 = 0`.


theorem ExistsUnique.elim₂ :
    ∀ {α : Sort u_2} {p : α → Sort u_3} [inst : ∀ (x : α), Subsingleton (p x)] {q : (x : α) → p x → Prop} {b : Prop},
      (∃! x h, q x h) → (∀ (x : α) (h : p x), q x h → (∀ (y : α) (hy : p y), q y hy → y = x) → b) → b :=
  by sorry

This theorem states that for any type `α`, any predicate `p` on `α`, and any property `q` depending on `α` and `p α`, if there exists a unique element `x` and `h` such that `q x h` holds, then for all `x` and `h` where `q x h` holds, if for all `y` and `hy` where `q y hy` holds, `y` is equal to `x`, then some property `b` holds. The predicate `p` is assumed to be a subsingleton, which means that there is at most one proof of `p x` for any `x`.

If for any type `α`, predicate `p` on `α`, and property `q` such that `p` is a subsingleton, there exists a unique `x` and `h` such that `q x h` holds, and for all `x` and `h` where `q x h` holds, if `x = y` implies `h = hy`, then some property `b` holds for all such `x` and `h`.


theorem Subgroup.comap_map_eq :
    ∀ {G : Type u_1} [inst : Group G] {N : Type u_5} [inst_1 : Group N] (f : G →* N) (H : Subgroup G),
      Subgroup.comap f (Subgroup.map f H) = H ⊔ MonoidHom.ker f :=
  by sorry

The theorem `Subgroup.comap_map_eq` states that for any group homomorphism `f` from a group `G` to a group `N`, and for any subgroup `H` of `G`, the subgroup obtained by first mapping `H` under `f` and then taking the preimage under `f` is equal to the join of `H` and the kernel of `f`. In other words, when you map a subgroup to another group and then pull it back, you not only get the original subgroup, but also the elements of the original group that are mapped to the identity in the target group.

For any group homomorphism `f` and subgroup `H` of a group `G`, `f''(H) = H.join (f.ker)`, where `f''` denotes the image of `H` under `f` and `join` denotes the subgroup generated by the union of two subgroups.


theorem Mathlib.Order.Monotone.Monovary._auxLemma.3 :
    ∀ {ι : Type u_1} {α : Type u_3} {β : Type u_4} [inst : Preorder α] [inst_1 : Preorder β] {f : ι → α} {g : ι → β},
      MonovaryOn f g Set.univ = Monovary f g :=
  by sorry

This theorem states that for any types `ι`, `α`, and `β`, and given preordered types `α` and `β`, the function `f` from `ι` to `α` and function `g` from `ι` to `β`, the property of `f` monovarying with `g` on the universal set (i.e., for all elements in `ι`) is equivalent to `f` monovarying with `g` in general. In other words, `f` monovaries with `g` if and only if `f` monovaries with `g` for all values in the type `ι`. Here, a function `f` is said to monovary with a function `g` if whenever `g i` is less than `g j`, `f i` is less than or equal to `f j`.

For functions `f:` ι -> α and `g:` ι -> β between preordered types, `f` monovaries with `g` if and only if `f` monovaries with `g` on the universal set.


theorem Mathlib.Order.Monotone.Monovary._auxLemma.4 :
    ∀ {ι : Type u_1} {α : Type u_3} {β : Type u_4} [inst : Preorder α] [inst_1 : Preorder β] {f : ι → α} {g : ι → β},
      AntivaryOn f g Set.univ = Antivary f g :=
  by sorry

This theorem states that for any given types `ι`, `α`, and `β`, with `α` and `β` being preordered, and any functions `f : ι → α` and `g : ι → β`, the property of `f` antivarying with `g` on the universal set (i.e., for all elements of `ι`) is equivalent to `f` antivarying with `g` without restriction to a specific set. In other words, if for every pair of elements `i` and `j` from `ι`, whenever `g(i)` is less than `g(j)`, `f(j)` is less than or equal to `f(i)`, this will hold true regardless of whether we consider all elements of `ι` (the case of `Antivary`) or restrict ourselves to a subset (the case of `AntivaryOn` with the universal set).

For any preordered types `ι`, `α`, and `β`, and functions `f : ι → α` and `g : ι → β`, the condition that `f(i) ≤ f(j)` whenever `g(i) < g(j)` for all `i, j ∈ ι` is equivalent to `f` antivarying with `g` over `ι`, i.e., `Antivary f g ι`, and thus holds without restriction to any subset of `ι`.


/-- **Chebyshev's Sum Inequality**: When `f` and `g` monovary together (eg they are both
monotone/antitone), the scalar product of their sum is less than the size of the set times their
scalar product.  -/
theorem MonovaryOn.sum_smul_sum_le_card_smul_sum :
    ∀ {ι : Type u_1} {α : Type u_2} {β : Type u_3} [inst : LinearOrderedRing α] [inst_1 : LinearOrderedAddCommGroup β]
      [inst_2 : Module α β] [inst_3 : OrderedSMul α β] {s : Finset ι} {f : ι → α} {g : ι → β},
      MonovaryOn f g ↑s →
        ((Finset.sum s fun i => f i) • Finset.sum s fun i => g i) ≤ s.card • Finset.sum s fun i => f i • g i :=
  by sorry

**Chebyshev's Sum Inequality**: This theorem states that for any set `s` and functions `f` and `g` that monovary together (that is, both are either monotone or antitone), the scalar multiplication of the sum of `f` values by the sum of `g` values is less than or equal to the size of the set `s` times the sum of scalar multiplications of `f` and `g` for each element in the set. In mathematical notation, if `f` and `g` monovary on `s`, then the inequality $(\sum_{i \in s} f(i)) \cdot (\sum_{i \in s} g(i)) \leq |s| \cdot (\sum_{i \in s} f(i) \cdot g(i))$ holds.

For sets \(s\), monovarying functions \(f\) and \(g\): \(\sum\_{i \in s} f(i) \cdot g(i) \geq \dfrac{1}{|s|} (\sum\_{i \in s} f(i)) (\sum\_{i \in s} g(i))\). (Note that this is the opposite inequality to the one stated in the given Lean theorem, but it is a common way to state Chebyshev's Sum Inequality in mathematics literature.)


/-- If a vector space has a finite basis, then its dimension (seen as a cardinal) is equal to the
cardinality of the basis.  -/
theorem rank_eq_card_basis :
    ∀ {R : Type u} {M : Type v} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M]
      [inst_3 : StrongRankCondition R] {ι : Type w} [inst_4 : Fintype ι],
      Basis ι R M → Module.rank R M = ↑(Fintype.card ι) :=
  by sorry

This theorem states that for any Ring `R`, Additive Commutative Group `M`, and a Module structure over `R` and `M` satisfying the Strong Rank Condition, and for any index type `ι` which is finite (that is, it has a `Fintype` instance), if there exists a Basis indexed by `ι` for the Module, then the rank of the Module (which is a cardinal number) is equal to the number of elements in `ι` (the cardinality of the basis).

For any ring `R`, additive commutative group `M` with a Module structure over `R`, satisfying the Strong Rank Condition, with a finite index type `ι` having a Basis for the Module, the rank of the Module equals the cardinality of `ι`.


/-- **Alias** of the reverse direction of `antitone_comp_ofDual_iff`. -/
theorem Monotone.dual_left :
    ∀ {α : Type u} {β : Type v} [inst : Preorder α] [inst_1 : Preorder β] {f : α → β},
      Monotone f → Antitone (f ∘ ⇑OrderDual.ofDual) :=
  by sorry

**Monotone.dual_left Theorem**: For any types `α` and `β` that are preordered, and for any function `f` from `α` to `β`, if `f` is monotone, then the composition of `f` with the identity function on the dual order of `α` is antitone. This means that if `f` preserves the order of `α` (i.e., `f` is monotone), then when applied to the dual order of `α`, `f` reverses the order (i.e., becomes antitone). The dual order of `α` is simply `α` with the order reversed.

If `f` is a monotone function from preordered types `α` to `β`, then `f` composed with the reverse order function on `α` is an antitone function.


theorem PiNat.dist_triangle : ∀ {E : ℕ → Type u_1} (x y z : (n : ℕ) → E n), dist x z ≤ dist x y + dist y z := by sorry

This theorem is a formalization of the triangle inequality in the context of Pi types over natural numbers in Lean 4. Given three functions `x`, `y`, and `z` from natural numbers to some type `E`, the theorem states that the distance between `x` and `z` is less than or equal to the sum of the distance between `x` and `y` and the distance between `y` and `z`. Here, the `dist` function measures some notion of distance between two functions of the same type. This is a generalization of the triangle inequality from metric spaces to this specific context.

Given functions `x`, `y`, and `z` from natural numbers to some type `E` with a defined distance `dist`, the triangle inequality holds: `dist (x x) (z x) ≤ dist (x x) (y x) + dist (y x) (z x)`.


theorem Finset.sup'_apply :
    ∀ {α : Type u_2} {β : Type u_3} {C : β → Type u_7} [inst : (b : β) → SemilatticeSup (C b)] {s : Finset α}
      (H : s.Nonempty) (f : α → (b : β) → C b) (b : β), Finset.sup' s H f b = Finset.sup' s H fun a => f a b :=
  by sorry

The theorem `Finset.sup'_apply` states that for any types `α`, `β`, `C`, and a function `f` from `α` to `C b` for each `b` in `β`, along with a non-empty finset `s` of `α`, and any `b` in `β`, the supremum of the image of `s` under `f` evaluated at `b` is equal to the supremum of the image of `s` under the function that maps each element `a` of `s` to `f a b`. This holds in a possibly unbounded join-semilattice `C b` for each `b` in `β`.

For any type `α`, types `β` and `C`, function `f` from `α` to `C(β)`, non-empty finset `s` of `α`, and `b` in `β`, the supremum of `f` applied element-wise to `s` equals the supremum of `f` applied to each element of `s` and then evaluated at `b`.


theorem Rat.cast_le : ∀ {K : Type u_5} [inst : LinearOrderedField K] {m n : ℚ}, ↑m ≤ ↑n ↔ m ≤ n := by sorry

This theorem, `Rat.cast_le`, states that for any type `K` that has an instance of `LinearOrderedField`, and for any rational numbers `m` and `n`, the cast of `m` to `K` is less than or equal to the cast of `n` to `K` if and only if `m` is less than or equal to `n`. In simpler terms, it ensures that the order of two rational numbers is maintained when they are cast to any type that is a linear ordered field.

For any linear ordered field K and rational numbers m and n, m ≤ n if and only if K.cast m ≤ K.cast n.


theorem tendsto_nhdsWithin_of_tendsto_nhds :
    ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] {f : α → β} {a : α} {s : Set α} {l : Filter β},
      Filter.Tendsto f (nhds a) l → Filter.Tendsto f (nhdsWithin a s) l :=
  by sorry

The theorem `tendsto_nhdsWithin_of_tendsto_nhds` states that for any types `α` and `β` with `α` being a topological space, any function `f` from `α` to `β`, any point `a` in `α`, any set `s` of `α`, and any filter `l` on `β`, if the function `f` tends to the filter `l` at the neighborhood of `a` (`nhds a`), then it also tends to `l` at the intersection of `s` and a neighborhood of `a` (`nhdsWithin a s`). In other words, if `f` converges to `l` as we approach `a`, it still converges to `l` even if we only approach `a` within the subset `s` of `α`.

If a function from a topological space to another tends to a filter at a point's neighborhood, then it also tends to that filter at the intersection of any subset and a neighborhood of the point.


theorem Multiset.map_toEnumFinset_fst :
    ∀ {α : Type u_1} [inst : DecidableEq α] (m : Multiset α), Multiset.map Prod.fst (Multiset.toEnumFinset m).val = m :=
  by sorry

This theorem states that for any multiset `m` of a type `α` with decidable equality, if you convert `m` to a finset whose elements enumerate the elements of the multiset (with `ℕ` component differentiating between equal elements), and then map the `fst` function (which extracts the first element of a pair) over this finset, you will get back the original multiset `m`. In other words, the process of transforming the multiset to an enumerated finset and then projecting out the first components of the finset is a lossless operation; it does not change the underlying multiset.

For any decidably equated multiset `m` of type `α`, the mapping `fst ∘ toFinset (map finset.single m)` equals `m`.


/-- A variant of `Finset.mul_prod_erase` with the multiplication swapped.  -/
theorem Finset.prod_erase_mul :
    ∀ {α : Type u_3} {β : Type u_4} [inst : CommMonoid β] [inst_1 : DecidableEq α] (s : Finset α) (f : α → β) {a : α},
      a ∈ s → (Finset.prod (Finset.erase s a) fun x => f x) * f a = Finset.prod s fun x => f x :=
  by sorry

This theorem, `Finset.prod_erase_mul`, states that for any finite set `s` of elements of type `α`, a function `f` from `α` to a type `β` that forms a commutative monoid, and an element `a` of type `α` that belongs to `s`, the product of `f` over all elements in `s` excluding `a`, then multiplied by `f(a)`, is equal to the product of `f` over all elements in `s`. In other words, the order of multiplication does not affect the total product in the context of a finite set, which is a reflection of the commutative property of the monoid. This theorem also requires that equality between elements of type `α` is decidable.

For any commutative monoid homomorphism `f` from a finite set `s` of type `α` to type `β`, and any element `a` in `s`, the product of `f` over all elements in `s` excluding `a`, multiplied by `f(a)`, equals the product of `f` over all elements in `s`.


theorem MeasurableEquiv.coe_toEquiv :
    ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] [inst_1 : MeasurableSpace β] (e : α ≃ᵐ β),
      ⇑e.toEquiv = ⇑e :=
  by sorry

This theorem states that for any two types `α` and `β` that have associated measurable spaces, given a measurable equivalence `e` between `α` and `β`, the function representation of `e` as an equivalence (via `e.toEquiv`) is the same as the function representation of `e` itself. In other words, converting a measurable equivalence to a regular equivalence doesn't change how it behaves as a function.

For any measurable equivalences `e : α ≃ β`, the functions `e` and `e.toEquiv` represent the same relation between `α` and `β`.


theorem Fin.mk_zero : ∀ {n : ℕ}, { val := 0, isLt := ⋯ } = 0 := by sorry

This theorem states that for all natural numbers `n`, the finite type `Fin n` when created with `val` as `0` and some proof `isLt` is equal to `0`. In other words, the zero element of any finite type of size `n` is effectively the same as the natural number zero. This is a feature of the way finite types are defined in Lean.

For all natural numbers `n`, the zero element of the finite type `Fin n` is equal to the natural number zero.


theorem compl_eq_bot : ∀ {α : Type u} {x : α} [inst : BooleanAlgebra α], xᶜ = ⊥ ↔ x = ⊤ := by sorry

This theorem states that for any type `α` which forms a Boolean algebra, the complement (`xᶜ`) of an element `x` of type `α` is equal to the bottom element (`⊥`) if and only if `x` is the top element (`⊤`). In terms of set theory, this would mean that the complement of a set is the empty set if and only if the set is universal, i.e., contains all elements.

For any Boolean algebra type `α`, the complement of an element `x` equals the bottom element `⊥` if and only if `x` is the top element `⊤`. Equivalently, in set theory, the complement of a set is the empty set if and only if the set is universal.


theorem Finset.lcm_dvd_iff :
    ∀ {α : Type u_1} {β : Type u_2} [inst : CancelCommMonoidWithZero α] [inst_1 : NormalizedGCDMonoid α] {s : Finset β}
      {f : β → α} {a : α}, Finset.lcm s f ∣ a ↔ ∀ b ∈ s, f b ∣ a :=
  by sorry

This theorem states that for any two types `α` and `β`, where `α` is a Cancel Commutative Monoid with zero and a Normalized GCD Monoid, a function `f` from `β` to `α`, a set `s` of type `β`, and an element `a` of type `α`, the least common multiple (lcm) of the set `s` under the function `f` divides `a` if and only if for each element `b` in the set `s`, `f(b)` divides `a`. In simpler terms, this theorem relates the divisibility of a number by the least common multiple of a set to the divisibility of that number by each element of the set.

For any Cancel Commutative Monoid with zero and Normalized GCD Monoid `α`, set `s` of elements in a type `β`, function `f` from `β` to `α`, and element `a` of type `α`, `lcm(map f s)` divides `a` if and only if each `b` in `s` has `f(b)` dividing `a`.


theorem mul_kstar_le_kstar : ∀ {α : Type u_1} [inst : KleeneAlgebra α] {a : α}, a * KStar.kstar a ≤ KStar.kstar a := by
  sorry

The theorem `mul_kstar_le_kstar` states that for any type `α` that forms a Kleene algebra, and for any element `a` of type `α`, the product of `a` and the Kleene star of `a` (denoted as `a * KStar.kstar a`) is less than or equal to the Kleene star of `a` (denoted as `KStar.kstar a`). In the context of Kleene algebras, the "less than or equal to" relation typically represents an ordering based on possible reachability or effect in a system modeled by the algebra.

For any element `a` in a Kleene algebra `α`, `a * KStar.kstar a ≤ KStar.kstar a`.


theorem Polynomial.nonempty_support_iff :
    ∀ {R : Type u} [inst : Semiring R] {p : Polynomial R}, (Polynomial.support p).Nonempty ↔ p ≠ 0 := by sorry

This theorem states that for any semiring `R` and any polynomial `p` over `R`, the support set of `p` (i.e., the set of all `n` such that the `n`-th power of `X` has a non-zero coefficient in `p`) is nonempty if and only if the polynomial `p` is not the zero polynomial. In other words, a polynomial has a non-empty support iff it isn't the zero polynomial.

A polynomial over a semiring is non-zero if and only if its support set is non-empty.


theorem sdiff_eq_self_iff_disjoint :
    ∀ {α : Type u} {x y : α} [inst : GeneralizedBooleanAlgebra α], x \ y = x ↔ Disjoint y x := by sorry

This theorem states that for any generalized Boolean algebra, denoted by `α`, and any two elements `x` and `y` of `α`, the statement "`x` set-minus `y` equals `x`" is equivalent to "`y` and `x` are disjoint". Here, two elements are considered disjoint if their infimum (greatest lower bound) is the bottom element of the algebra. This notion of disjointness generalizes the concept of disjoint sets in set theory.

For any generalized Boolean algebra `α`, elements `x` and `y` are disjoint if and only if `x \ y` equals the bottom element of `α`.


IsChain.total

theorem IsChain.total :
    ∀ {α : Type u_1} {r : α → α → Prop} {s : Set α} {x y : α} [inst : IsRefl α r],
      IsChain r s → x ∈ s → y ∈ s → r x y ∨ r y x :=
  by sorry

This theorem states that for any type `α` and any binary relation `r` on `α`, if a set `s` of type `α` is a chain (i.e., for all elements `x` and `y` in `s`, `r x y`, `r y x`, or `x = y` holds), then for all elements `x` and `y` in `s`, `r x y` or `r y x` holds. Furthermore, the relation `r` is reflexive, meaning for all `x` in `α`, `r x x` holds. This theorem is very significant in the study of order relations, particularly in proving the properties of chains in partially ordered sets.

In a reflexive binary relation on a type, any chain is a total order.


theorem Submonoid.closure_union :
    ∀ {M : Type u_1} [inst : MulOneClass M] (s t : Set M),
      Submonoid.closure (s ∪ t) = Submonoid.closure s ⊔ Submonoid.closure t :=
  by sorry

This theorem states that for any type `M` that has a multiplication and a multiplicative identity (captured by the `MulOneClass M` typeclass in Lean), and for any two sets `s` and `t` of this type `M`, the submonoid generated by the union of `s` and `t` is equal to the join (supremum) of the submonoids generated by `s` and `t` respectively. In other words, the submonoid generated by the union of two sets is the smallest submonoid that contains both the submonoid generated by each individual set.

For any type `M` with multiplication and multiplicative identity, the submonoid generated by the union of two sets `s` and `t` in `M` equals the join (supremum) of the submonoids generated by `s` and `t`.


theorem Finset.filter_map :
    ∀ {α : Type u_1} {β : Type u_2} {f : α ↪ β} {s : Finset α} {p : β → Prop} [inst : DecidablePred p],
      Finset.filter p (Finset.map f s) = Finset.map f (Finset.filter (p ∘ ⇑f) s) :=
  by sorry

The theorem `Finset.filter_map` states that for any given types `α` and `β`, embedding function `f` from `α` to `β`, finset `s` of type `α`, and a decidable property `p` for type `β`, the filter of `p` applied to the map of `f` over `s` is equivalent to the map of `f` over the filter of `p` composed with `f` applied to `s`. In simpler terms, it means you can either first map a function over a finset and then filter the results, or first filter the finset and then map the function, and both processes will yield the same result.

For any type `α`, type `β`, decidable property `p` on `β`, embedding function `f` from `α` to `β`, and finset `s` of type `α`, the filter of `p` applied to the image of `s` under `f` is equal to the image of the filter of `p` composed with `f` applied to `s`.


theorem AddLECancellable.eq_tsub_of_add_eq :
    ∀ {α : Type u_1} [inst : PartialOrder α] [inst_1 : AddCommSemigroup α] [inst_2 : Sub α] [inst_3 : OrderedSub α]
      {a b c : α}, AddLECancellable c → a + c = b → a = b - c :=
  by sorry

The theorem `AddLECancellable.eq_tsub_of_add_eq` states that for any partially ordered commutative semigroup with subtraction that is also an ordered subtraction, given elements `a`, `b`, and `c` such that `c` is left-cancellable with respect to addition, if the sum of `a` and `c` equals `b`, then `a` is equal to the result of subtracting `c` from `b`. In mathematical terms, for all `a`, `b`, `c` in a certain algebraic structure, if `c` has the property that for all `x`, `y`, `c + x ≤ c + y` implies `x ≤ y` and `a + c = b`, then `a = b - c`.

If `a`, `b`, and `c` are in a commutative semigroup with subtraction and `c` is left-cancellable for addition, then `a = b - c` whenever `a + c = b`.


theorem Metric.thickening_singleton :
    ∀ {X : Type u} [inst : PseudoMetricSpace X] (δ : ℝ) (x : X), Metric.thickening δ {x} = Metric.ball x δ := by sorry

The theorem `Metric.thickening_singleton` states that for any pseudometric space `X`, any real number `δ`, and any point `x` in `X`, the `δ`-thickening of the singleton set containing only `x` is the same as the metric ball with center `x` and radius `δ`. In simpler terms, it tells us that all the points that are less than `δ` distance away from `x` can be described either as a `δ`-thickening of the set `{x}` or equivalently as a ball of radius `δ` centered at `x`.

For any pseudometric space X, point x, and real number δ, the δ-thickening of the singleton set {x} equals the metric ball with center x and radius δ.


theorem Nat.mul_mod_left : ∀ (m n : ℕ), m * n % n = 0 := by sorry

This theorem states that for all natural numbers `m` and `n`, the remainder of the product of `m` and `n` divided by `n` is always `0`. In mathematical terms, this says `m*n mod n = 0` for all `m`,`n` in the set of natural numbers. This is consistent with the property of modulus operation, the remainder of any number `x` divided by `y` is zero if `x` is a multiple of `y`, and `m*n` is clearly a multiple of `n`.

For all natural numbers m and n, m * n is a multiple of n.


theorem Pi.prod_fst_snd : ∀ {α : Type u_1} {β : Type u_2}, Pi.prod Prod.fst Prod.snd = id := by sorry

This theorem, `Pi.prod_fst_snd`, states that for all types `α` and `β`, the product mapping of the first and second projections (`Prod.fst` and `Prod.snd`) is the identity function. In simpler terms, when you create a pair by collecting the results of applying the first and second projection functions (which essentially deconstruct a pair into its two components) and then apply this operation to any pair, you would get the original pair back. It shows the compatibility of the product mapping with the projection operations in the context of pair-type data.

For all types `α` and `β`, the function that maps a pair `(a, b)` to `(Prod.fst (a, b), Prod.snd (a, b))` is the identity function on pairs of type `(α × β)`.


theorem normalize_idem :
    ∀ {α : Type u_1} [inst : CancelCommMonoidWithZero α] [inst_1 : NormalizationMonoid α] (x : α),
      normalize (normalize x) = normalize x :=
  by sorry

The theorem `normalize_idem` states that for any type `α` that forms a Cancel Commutative Monoid with zero and has a Normalization Monoid structure, the operation `normalize` is idempotent on any element `x` of `α`. That is, applying the `normalize` operation twice on `x` is the same as applying it once. This means the `normalize` operation doesn't change the value of `x` after its first application, irrespective of how many more times it's applied afterwards.

For any cancel commutative monoid `α` with zero and a normalization monoid structure, the normalization operation is idempotent.


Bimod.Hom.ext

theorem Bimod.Hom.ext :
    ∀ {C : Type u₁} {inst : CategoryTheory.Category.{v₁, u₁} C} {inst_1 : CategoryTheory.MonoidalCategory C}
      {A B : Mon_ C} {M N : Bimod A B} (x y : Bimod.Hom M N), x.hom = y.hom → x = y :=
  by sorry

This theorem states that for any given category `C` (with `C` being a Monoidal Category), and any given monoidal objects `A` and `B` in `C`, and any two given Bimodules `M` and `N` over `A` and `B`, if we have two Bimodule homomorphisms `x` and `y` from `M` to `N`, then if the underlying morphisms of `x` and `y` are equal, it implies that `x` and `y` themselves are equal. In other words, it asserts the principle of equality of Bimodule morphisms in the context of Category Theory.

In a monoidal category, if two bimodule homomorphisms between bimodules over the same monoidal objects have equal underlying morphisms, then they are equal as bimodule homomorphisms.


MeasureTheory.SigmaFinite.out

theorem MeasureTheory.SigmaFinite.out :
    ∀ {α : Type u_1} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α},
      MeasureTheory.SigmaFinite μ → Nonempty (MeasureTheory.Measure.FiniteSpanningSetsIn μ Set.univ) :=
  by sorry

The theorem `MeasureTheory.SigmaFinite.out` states that for any type `α`, given a measurable space `m0` on `α` and a measure `μ` on this measurable space, if the measure `μ` is sigma-finite, then there exists a nonempty set of finite spanning sets in the universal set of `α` with respect to this measure `μ`. In simpler words, if a measure is sigma-finite (i.e., it can be partitioned into a countable union of sets with finite measure), then we can find a nonempty collection of finite spanning sets that cover the entire space.

Given a sigma-finite measure `μ` on a measurable space `(α, m0)`, there exists a countable collection `{S_i}` of finite sets in `α` such that `α = ⋃i (S_i)`.


theorem IsCompactOperator.image_subset_compact_of_isVonNBounded :
    ∀ {𝕜₁ : Type u_1} {𝕜₂ : Type u_2} [inst : NontriviallyNormedField 𝕜₁] [inst_1 : SeminormedRing 𝕜₂] {σ₁₂ : 𝕜₁ →+* 𝕜₂}
      {M₁ : Type u_3} {M₂ : Type u_4} [inst_2 : TopologicalSpace M₁] [inst_3 : AddCommMonoid M₁]
      [inst_4 : TopologicalSpace M₂] [inst_5 : AddCommMonoid M₂] [inst_6 : Module 𝕜₁ M₁] [inst_7 : Module 𝕜₂ M₂]
      [inst_8 : ContinuousConstSMul 𝕜₂ M₂] {f : M₁ →ₛₗ[σ₁₂] M₂},
      IsCompactOperator ⇑f → ∀ {S : Set M₁}, Bornology.IsVonNBounded 𝕜₁ S → ∃ K, IsCompact K ∧ ⇑f '' S ⊆ K :=
  by sorry

This theorem states that for a compact operator `f` from one topological vector space `M₁` over a normed field `𝕜₁` to another vector space `M₂` over a seminormed ring `𝕜₂`, if a set `S` in `M₁` is von Neumann bounded (meaning it is absorbed by every neighborhood of the zero vector in `M₁`), then there exists a compact set `K` in `M₂` such that the image of `S` under the operator `f` is contained within `K`. This essentially asserts that compact operators map von Neumann bounded sets to compact sets.

For a compact operator between topological vector spaces over normed fields, the image of any von Neumann bounded set is contained in a compact set.


theorem PartialHomeomorph.extend_source_mem_nhds :
    ∀ {𝕜 : Type u_1} {E : Type u_2} {M : Type u_3} {H : Type u_4} [inst : NontriviallyNormedField 𝕜]
      [inst_1 : NormedAddCommGroup E] [inst_2 : NormedSpace 𝕜 E] [inst_3 : TopologicalSpace H]
      [inst_4 : TopologicalSpace M] (f : PartialHomeomorph M H) (I : ModelWithCorners 𝕜 E H) {x : M},
      x ∈ f.source → (PartialHomeomorph.extend f I).source ∈ nhds x :=
  by sorry

The theorem `PartialHomeomorph.extend_source_mem_nhds` states that for any type `𝕜` which is a nontrivially normed field, any type `E` which is a normed add commutative group, any type `M`, any type `H` which are both topological spaces, a partial homeomorphism `f` from `M` to `H`, a ModelWithCorners `I` with base type `𝕜`, shape type `E` and model type `H`, and an element `x` of type `M` that is in the source of `f`, the source of the extension of `f` using `I` is a neighborhood of `x`. In other words, the source set of the extended partial homeomorphism contains an open set around `x`.

For any nontrivially normed field 𝕜, normed add commutative group E, topological spaces M and H, a partial homeomorphism f from M to H, and an element x in the domain of f, the source of the extension of f using some ModelWithCorners I containing x is a neighborhood of x.


theorem Complex.exp_periodic : Function.Periodic Complex.exp (2 * ↑Real.pi * Complex.I) := by sorry

The theorem `Complex.exp_periodic` states that the complex exponential function is periodic with a period of `2 * π * i`, where `i` is the imaginary unit. In other words, for any complex number `z`, the value of the complex exponential function at `z + 2πi` is the same as its value at `z`. This is a formal version of the well-known fact from complex analysis that `e^(z + 2πi) = e^z` for all complex `z`.

The complex exponential function is periodic with a period of `2 * π * i`. That is, `Complex.exp (z + 2 * π * i) = Complex.exp z` for all complex `z`.


theorem csInf_le_csInf :
    ∀ {α : Type u_1} [inst : ConditionallyCompleteLattice α] {s t : Set α},
      BddBelow t → Set.Nonempty s → s ⊆ t → sInf t ≤ sInf s :=
  by sorry

The theorem `csInf_le_csInf` states that for any type `α` which has a conditionally complete lattice structure and for any two sets `s` and `t` of `α`, if `t` is bounded below and `s` is nonempty, and every element of `s` is also an element of `t` (i.e., `s` is a subset of `t`), then the infimum of `t` is less than or equal to the infimum of `s`. This theorem is a property related to order theory and lattice theory, specifically it is about infimums in the context of conditionally complete lattices.

In a conditionally complete lattice, the infimum of a nonempty subset that is also a subset of a bounded-below set is less than or equal to the infimum of the larger set.


theorem map_zpow' :
    ∀ {G : Type u_7} {H : Type u_8} {F : Type u_9} [inst : FunLike F G H] [inst_1 : DivInvMonoid G]
      [inst_2 : DivInvMonoid H] [inst_3 : MonoidHomClass F G H] (f : F),
      (∀ (x : G), f x⁻¹ = (f x)⁻¹) → ∀ (a : G) (n : ℤ), f (a ^ n) = f a ^ n :=
  by sorry

The theorem `map_zpow'` states that for given types `G`, `H`, and `F`, if `F` is a function-like from `G` to `H` (`F` has an injective coercion to functions from `G` to `H`), `G` and `H` both have an instance of `DivInvMonoid` (a mathematical structure that combines a monoid with an operation of inversion), and `F` has an instance of `MonoidHomClass` (which means `F` is a homomorphism over the monoids `G` and `H`), then for any function `f` from `F`, if `f` preserves the inversion operation (i.e., the inversion of `f(x)` equals `f` of the inverse of `x`), then `f` also preserves the integer power operation. In other words, for any `a` in `G` and any integer `n`, applying `f` to `a` raised to the power `n` is the same as first applying `f` to `a` and then raising the result to the power `n`. This property is important in the theory of group homomorphisms.

If `F` is a function-like from a group `G` to a group `H` that preserves the group operation and inversion, then `F` preserves the integer power operation.


theorem Multiset.powersetCardAux_eq_map_coe :
    ∀ {α : Type u_1} {n : ℕ} {l : List α},
      Multiset.powersetCardAux n l = List.map Multiset.ofList (List.sublistsLen n l) :=
  by sorry

The theorem `Multiset.powersetCardAux_eq_map_coe` states that for any given type `α`, natural number `n`, and list `l` of type `α`, the function `Multiset.powersetCardAux n l` which returns a list of all sublists of `l` of length `n` as multisets, is equal to applying the function `Multiset.ofList` to each element of the list returned by `List.sublistsLen n l`, which is the list of all sublists of `l` of length `n`. In other words, it shows the equivalence between generating multisets from sublists of a certain length and converting such sublists into multisets.

For any type `α` and natural number `n`, the multiset of all sublists of length `n` from a list `l` of type `α` is equal to the multiset obtained by applying `Multiset.ofList` to each sublist in `List.sublistsLen n l`.


theorem IsGLB.exists_between :
    ∀ {α : Type u} [inst : LinearOrder α] {s : Set α} {a b : α}, IsGLB s a → a < b → ∃ c ∈ s, a ≤ c ∧ c < b := by sorry

This theorem states that for any type `α` equipped with a `LinearOrder`, given a set `s` of type `α` and two elements `a` and `b` of type `α`, if `a` is a greatest lower bound (GLB) of the set `s` and `a` is less than `b`, then there exists an element `c` in set `s` such that `a` is less than or equal to `c` and `c` is less than `b`. In other words, whenever `a` is a GLB of a set and `a` is strictly less than `b`, we can always find an element in the set that lies between `a` and `b`.

If `α` is a type with a `LinearOrder`, `s` is a non-empty subset of `α`, `a` is the greatest lower bound of `s`, and `a` is strictly less than `b` in `α`, then there exists `c` in `s` such that `a ≤ c` and `c < b`.


theorem Dioph.abs_poly_dioph : ∀ {α : Type u} (p : Poly α), Dioph.DiophFn fun v => Int.natAbs (p v) := by sorry

The theorem `Dioph.abs_poly_dioph` states that for any multivariate integer polynomial `p` of any type `α`, the function that maps a vector `v` to the absolute value of `p` at `v` is a Diophantine function. In other words, the graph of this function is a Diophantine set. Here, the absolute value of an integer is computed as defined by `Int.natAbs`, which returns its non-negative counterpart.

The theorem `Dioph.abs_poly_dioph` asserts that the absolute value of a multivariate integer polynomial evaluated at a vector is a Diophantine function.


theorem Pell.strictMono_y : ∀ {a : ℕ} (a1 : 1 < a), StrictMono (Pell.yn a1) := by sorry

The theorem `Pell.strictMono_y` states that for all natural numbers `a` such that `a > 1`, the function `Pell.yn` is strictly monotone. In other words, for any two natural numbers `m` and `n` where `m < n`, the value of `Pell.yn` at `m` is strictly less than the value of `Pell.yn` at `n`. Here, `Pell.yn` is the Pell `y` sequence defined for natural numbers `a` greater than 1.

For all natural numbers `a > 1` and any `m, n` with `m < n`, `Pell.yn` (a, m) < `Pell.yn` (a, n).


theorem eq_of_fin_equiv :
    ∀ (R : Type u) [inst : Semiring R] [inst_1 : InvariantBasisNumber R] {n m : ℕ},
      ((Fin n → R) ≃ₗ[R] Fin m → R) → n = m :=
  by sorry

This theorem, `eq_of_fin_equiv`, states that for any type `R` equipped with a semiring structure and an invariant basis number property, if there is a linear equivalence between the functions from `Fin n` to `R` and `Fin m` to `R`, then `n` must be equal to `m`. Here, `Fin n` is the type of finite ordinals less than `n`, so this theorem essentially relates to the linear structure of finite-dimensional vector spaces over the ring `R`.

If there exists a linear equivalence between `Fin n` and `Fin m` as `R`-modules, then `n = m`.


/-- Alias for `Equiv.image_eq_preimage`  -/
theorem Set.image_equiv_eq_preimage_symm :
    ∀ {α : Type u_1} {β : Type u_2} (S : Set α) (f : α ≃ β), ⇑f '' S = ⇑f.symm ⁻¹' S := by sorry

This theorem states that for any set `S` of type `α` and any bijective function `f` from `α` to another type `β`, the image of the set `S` under the function `f` (denoted as `⇑f '' S`) is equal to the preimage of the set `S` under the inverse of the function `f` (denoted as `⇑f.symm ⁻¹' S`). In other words, applying `f` to every element in `S` gives the same result as finding all the elements in `β` that get mapped back to `S` by the inverse of `f`.

For any set `S` of type `α` and bijective function `f` from `α` to `β`, `f '' S = (f.symm)^-1 '' S`.


theorem Mathlib.Algebra.Order.Monoid.Lemmas._auxLemma.29 :
    ∀ {α : Type u_1} [inst : AddZeroClass α] [inst_1 : LT α]
      [inst_2 : CovariantClass α α (Function.swap fun x x_1 => x + x_1) fun x x_1 => x < x_1]
      [inst_3 : ContravariantClass α α (Function.swap fun x x_1 => x + x_1) fun x x_1 => x < x_1] {a : α} (b : α),
      (a + b < b) = (a < 0) :=
  by sorry

The theorem `Mathlib.Algebra.Order.Monoid.Lemmas._auxLemma.29` states that for all types `α`, given the type `α` is equipped with an additive zero class, less than relation, and the appropriate covariance and contravariance structures with respect to addition, then for all elements `a` and `b` of type `α`, `a + b` is less than `b` if and only if `a` is less than zero. In other words, in this specific algebraic structure, adding `b` to `a` only decreases the value of `b` if `a` is a negative value.

For an additively commutative type equipped with an additive zero and a total order such that subtraction is the inverse operation to addition, if `a` and `b` are elements of this type and `a + b < b`, then `a < 0`.


theorem uniformity_eq_symm : ∀ {α : Type ua} [inst : UniformSpace α], uniformity α = Prod.swap <$> uniformity α := by
  sorry

This theorem states that for any type `α` which has a `UniformSpace` structure, the uniformity of `α` is equal to the uniformity of `α` after swapping the factors of the product. In other words, the uniform distribution on the product space `α × α` is symmetric; the distribution remains the same when the factors are swapped. This is crucial when considering properties such as convergence and continuity in a uniform space, as they should be insensitive to the order of the factors.

For any type `α` with a `UniformSpace` structure, the uniformity of `α × α` is equal to the swapped product uniformity.


theorem Matrix.transpose_neg :
    ∀ {m : Type u_2} {n : Type u_3} {α : Type v} [inst : Neg α] (M : Matrix m n α),
      Matrix.transpose (-M) = -Matrix.transpose M :=
  by sorry

The theorem `Matrix.transpose_neg` states that for any type `m` and `n` and a type `α` which has a negation operation, given a matrix `M` with entries in `α` indexed by `m` and `n`, the transpose of the negation of `M` equals the negation of the transpose of `M`. In mathematical terms, for all matrices `M`, we have that `(-M)^T = -M^T`. Here, `T` denotes the transpose of a matrix, and `-` denotes the negation of each entry of the matrix.

For any matrix `M` with entries in a type `α` having negation operation, the transpose of the negated matrix `-M` equals the negation of the transpose `-M^T`.


theorem IsLocalization.lift_comp :
    ∀ {R : Type u_1} [inst : CommSemiring R] {M : Submonoid R} {S : Type u_2} [inst_1 : CommSemiring S]
      [inst_2 : Algebra R S] {P : Type u_3} [inst_3 : CommSemiring P] [inst_4 : IsLocalization M S] {g : R →+* P}
      (hg : ∀ (y : ↥M), IsUnit (g ↑y)), RingHom.comp (IsLocalization.lift hg) (algebraMap R S) = g :=
  by sorry

The theorem `IsLocalization.lift_comp` states that, given a commutative semiring `R`, a submonoid `M` of `R`, another commutative semiring `S` with an algebra structure over `R`, and yet another commutative semiring `P`, along with an indication that `S` is a localization of `R` at `M`, and a ring homomorphism `g` from `R` to `P` that maps each element of `M` to a unit in `P`, then the composition of the ring homomorphism `IsLocalization.lift hg` (constructed from `g` and `hg`) and the ring homomorphism generated by the algebra structure of `S` over `R` (`algebraMap R S`) is the same as the original ring homomorphism `g`. In simpler terms, this theorem expresses a fundamental property of the localization process in commutative algebra, ensuring the existence of a certain homomorphisms compatibility when working with localizations.

Given a commutative semiring `R`, a submonoid `M` of `R`, a localization of `R` at `M` `S`, a ring homomorphism `g : R → P` mapping `M` to units in `P`, the homomorphism `IsLocalization.lift hg` constructed from `g` and `hg` equals the composition of `g` with the algebra homomorphism `algebraMap R S`.


theorem Quaternion.normSq_eq_zero :
    ∀ {R : Type u_1} [inst : LinearOrderedCommRing R] {a : Quaternion R}, Quaternion.normSq a = 0 ↔ a = 0 := by sorry

This theorem states that for any quaternion `a` over a type `R`, where `R` is a linearly ordered commutative ring, the square of the norm of `a` is equal to zero if and only if `a` is the zero quaternion. In other words, a quaternion `a` has zero norm squared if and only if it is the zero quaternion, and conversely, if a quaternion `a` is the zero quaternion, then its norm squared is zero. This is a two-way implication theorem that links the zero quaternion with a zero norm square in the space of quaternions over a linearly ordered commutative ring.

For any quaternion `a` over a linearly ordered commutative ring `R`, the square of its norm is equal to zero if and only if `a` is the zero quaternion.


theorem NonUnitalAlgebra.mem_top :
    ∀ {R : Type u} {A : Type v} [inst : CommSemiring R] [inst_1 : NonUnitalNonAssocSemiring A] [inst_2 : Module R A]
      [inst_3 : IsScalarTower R A A] [inst_4 : SMulCommClass R A A] {x : A}, x ∈ ⊤ :=
  by sorry

This theorem states that for any type `R` which is a commutative semiring and any type `A` which is a non-unital non-associative semiring, if `A` is a module over `R`, and if there is a scalar tower of `R` over `A`, and if the scalar multiplication `R * A -> A` commutes, then any element of `A` is an element of the top (or greatest) submodule `⊤` of `A`. This can be seen as an abstract algebra version of the observation that every element of a set is an element of its power set.

In Lean 4, given a commutative semiring `R`, a non-unital non-associative semiring `A` with an `R`-module structure and a scalar tower, if scalar multiplication commutes, then every element of `A` is contained in the top submodule `⊤` of `A`.


EqvGen.mono

theorem EqvGen.mono :
    ∀ {α : Type u_1} {a b : α} {r p : α → α → Prop}, (∀ (a b : α), r a b → p a b) → EqvGen r a b → EqvGen p a b := by
  sorry

This theorem states that for any type `α` and any elements `a` and `b` of this type, given two relations `r` and `p` on `α`, if it is the case that whenever `r` holds between any two elements of `α`, `p` also holds between them, then `EqvGen r a b` implies `EqvGen p a b`. In simpler terms, `EqvGen` is a type that describes equivalence relations generated by a given relation, so the theorem is stating that if `r` is a sub-relation of `p`, then any equivalence generated by `r` is also an equivalence generated by `p`.

If relation `r` implies relation `p` and `EqvGen` generates the equivalence relation of `r` for elements `a` and `b`, then `EqvGen` also generates the equivalence relation of `p` for `a` and `b`.


theorem upperBounds_empty : ∀ {α : Type u} [inst : Preorder α], upperBounds ∅ = Set.univ := by sorry

The theorem `upperBounds_empty` states that for any type `α` that has a preorder relation, the set of upper bounds of the empty set is the universal set. In other words, for any preordered type, every element is considered an upper bound of the empty set, hence the set of all upper bounds for the empty set is the universal set. This makes sense because an upper bound of a set is any element that is greater than or equal to all elements of the set, and since there are no elements in the empty set, all elements of the preordered type trivially satisfy this condition.

For any preordered type `α`, the set of upper bounds of the empty set is the universal set.


TopologicalSpace.IsSeparable.closure

/-- **Alias** of the reverse direction of `TopologicalSpace.isSeparable_closure`. -/
theorem TopologicalSpace.IsSeparable.closure :
    ∀ {α : Type u} [t : TopologicalSpace α] {s : Set α},
      TopologicalSpace.IsSeparable s → TopologicalSpace.IsSeparable (closure s) :=
  by sorry

This theorem states that for any set `s` in a topological space `α`, if `s` is a separable set, then the closure of `s` is also a separable set. Here, a set is called separable if it can be contained within the closure of some countable set. The closure of a set `s` is the smallest closed set that contains `s`.

If a set `s` in a topological space is separable, then the closure of `s` is also a separable set.


theorem MeasureTheory.snorm_indicator_const :
    ∀ {α : Type u_1} {G : Type u_4} {m0 : MeasurableSpace α} {p : ENNReal} {μ : MeasureTheory.Measure α}
      [inst : NormedAddCommGroup G] {s : Set α} {c : G},
      MeasurableSet s →
        p ≠ 0 → p ≠ ⊤ → MeasureTheory.snorm (Set.indicator s fun x => c) p μ = ↑‖c‖₊ * ↑↑μ s ^ (1 / p.toReal) :=
  by sorry

This theorem states that for any type `α`, any normed additive commutative group `G`, any measurable space `m0` on `α`, any extended non-negative real number `p`, any measure `μ` on `α`, any set `s` of `α`, and any element `c` of `G`, given that the set `s` is measurable, and `p` is neither 0 nor infinity, the seminorm of the indicator function of the set `s` (which maps each element in `s` to `c` and all other elements to zero) according to measure `μ` and `p` equals to the non-negative real number norm of `c` times the power of the measure of the set `s` to the reciprocal of `p`. In mathematical terms, if `s` is measurable and `p` is any real number except 0 and infinity, then we have `∥indicator s (λx, c)∥_p = ∥c∥ * μ(s)^(1/p)`.

For any measurable set `s` in a measurable space `(α, m0)`, the $L^p$ norm of the indicator function of `s` with value `c` for all elements in `s` and 0 for all other elements is equal to `|c| * (measure of `s`) ^(1/p)`, where `p` is any real number excluding 0 and infinity.


theorem Finset.image_inter_subset :
    ∀ {α : Type u_1} {β : Type u_2} [inst : DecidableEq β] [inst_1 : DecidableEq α] (f : α → β) (s t : Finset α),
      Finset.image f (s ∩ t) ⊆ Finset.image f s ∩ Finset.image f t :=
  by sorry

This theorem states that for any two finite sets `s` and `t` of elements of some type `α`, and a function `f` from `α` to another type `β` (both `α` and `β` equipped with a decidable equality relation), the image of the intersection of `s` and `t` under `f` is a subset of the intersection of the images of `s` and `t` under `f`. In other words, if you apply the function `f` to each element in the intersection of `s` and `t`, every resulting value will also be in the intersection of the set obtained by applying `f` to `s` and the set obtained by applying `f` to `t`.

For finite sets `s` and `t` of elements from a type `α` with decidable equality, and a function `f` from `α` to another type `β`, the image of `s ∩ t` under `f` is a subset of `f(s) ∩ f(t)`.


ContractingWith.toLipschitzWith

theorem ContractingWith.toLipschitzWith :
    ∀ {α : Type u_1} [inst : EMetricSpace α] {K : NNReal} {f : α → α}, ContractingWith K f → LipschitzWith K f := by
  sorry

The theorem "ContractingWith.toLipschitzWith" establishes that for a given function `f` mapping from a type `α` to itself, where `α` is an extended metric space, and for a given nonnegative real number `K`, if `f` is contracting with a contraction constant `K` (i.e., `K` is less than 1 and `f` is Lipschitz continuous with Lipschitz constant `K`), then `f` is also Lipschitz continuous with Lipschitz constant `K`. In other words, any function that contracts distances between points by a constant factor is also Lipschitz continuous.

If a function `f` mapping from an extended metric space `α` to itself is contracting with constant `K` (`0 < K <= 1`) and Lipschitz continuous with constant `K`, then `f` is Lipschitz continuous with constant `K`.


theorem List.mem_dlookup_kunion :
    ∀ {α : Type u} {β : α → Type v} [inst : DecidableEq α] {a : α} {b : β a} {l₁ l₂ : List (Sigma β)},
      b ∈ List.dlookup a (List.kunion l₁ l₂) ↔ b ∈ List.dlookup a l₁ ∨ a ∉ List.keys l₁ ∧ b ∈ List.dlookup a l₂ :=
  by sorry

The theorem `List.mem_dlookup_kunion` states that for all types `α` and `β`, given the decidable equality on `α`, and for any `a` of type `α`, `b` of type `β a`, and `l₁` and `l₂` being lists of key-value pairs (Sigma types), the value `b` is in the list obtained by looking up the key `a` in the list formed by the key-union of `l₁` and `l₂` if and only if `b` is in the list obtained by looking up `a` in `l₁`, or `a` is not a key in `l₁` and `b` is in the list obtained by looking up `a` in `l₂`. In other words, this theorem describes the behavior of the `dlookup` operation with respect to the `kunion` operation on lists of key-value pairs.

For all types `α` and `β`, given decidable equality on `α`, the key `a` is in the list obtained by key-union of `l₁` and `l₂` if and only if it is in `l₁` or is not in `l₁` but is in the value associated with `a` in `l₂`.


theorem sup_iInf_eq :
    ∀ {α : Type u} {ι : Sort w} [inst : Order.Coframe α] (a : α) (f : ι → α), a ⊔ ⨅ i, f i = ⨅ i, a ⊔ f i := by sorry

This theorem states that, for any type `α` equipped with a coframe order structure, any value `a` of type `α`, and any function `f` mapping from a type `ι` to `α`, the supremum (or least upper bound, denoted by `⊔`) of `a` and the infimum (or greatest lower bound, denoted by `⨅ i, f i`) of the values produced by `f` over all `i` in `ι` is equal to the infimum of the supremum of `a` and each value produced by `f`. In mathematical terms, the theorem is asserting that `a ⊔ (⨅ i, f i) = ⨅ i, (a ⊔ f i)`.

For any type `α` with a coframe order structure, the supremum of an element `a` in `α` and the infimum of the supremums of `a` and `f(i)` over all `i` in an index type `ι` are equal: `a ⊔ (⨅ i, f i) = ⨅ i, (a ⊔ f i)`.


theorem ENNReal.tsum_coe_eq : ∀ {α : Type u_1} {r : NNReal} {f : α → NNReal}, HasSum f r → ∑' (a : α), ↑(f a) = ↑r := by
  sorry

The theorem `ENNReal.tsum_coe_eq` states that for any type `α`, any nonnegative real number `r`, and any function `f` from `α` to nonnegative real numbers, if the series of `f` has a sum equal to `r`, then the infinite sum (denoted by `∑'`) of the co-domain values of `f` (obtained by applying the function to each element of the original domain `α`), when each is coerced (or casted) into an extended nonnegative real number (`↑(f a)`), is equal to `r` casted into an extended nonnegative real number (`↑r`). In other words, the summation of the function values remains the same even when the values are interpreted as extended nonnegative real numbers.

For any type α, nonnegative real number r, and function f from α to nonnegative real numbers with the sum of f equal to r, the sum of the coerced values of f (denoted by ∑↑(fa)) equals the coerced sum of r (denoted by ↑r).


theorem Order.le_succ_iff_eq_or_le :
    ∀ {α : Type u_1} [inst : PartialOrder α] [inst_1 : SuccOrder α] {a b : α},
      a ≤ Order.succ b ↔ a = Order.succ b ∨ a ≤ b :=
  by sorry

The theorem `Order.le_succ_iff_eq_or_le` states that for any partially ordered type `α` that also has a successor function and any two elements `a` and `b` of type `α`, `a` is less than or equal to the successor of `b` if and only if `a` is equal to the successor of `b` or `a` is less than or equal to `b`. This theorem bridges the relation between the successor function and the order relation.

For any partially ordered type with a successor function, the order relation holds between elements `a` and the successor of `b` if and only if `a` is equal to the successor of `b` or `a` is less than or equal to `b`.


theorem Computation.thinkN_mem :
    ∀ {α : Type u} {s : Computation α} {a : α} (n : ℕ), a ∈ Computation.thinkN s n ↔ a ∈ s := by sorry

The theorem `Computation.thinkN_mem` states that for any type `α`, any computation `s` of type `Computation α`, any element `a` of type `α`, and any natural number `n`, the element `a` is an element of the computation obtained by delaying `s` for `n` ticks using `Computation.thinkN` if and only if `a` is an element of `s`. In other words, delaying a computation does not change the set of elements that the computation can return.

For any computation `s` of type `Computation α`, any element `a` of type `α`, and any natural number `n`, `Computation.thinkN a n s` returns `a` if and only if `s` returns `a`.


theorem Real.Gamma_add_one : ∀ {s : ℝ}, s ≠ 0 → Real.Gamma (s + 1) = s * Real.Gamma s := by sorry

This theorem states that for any real number `s` not equal to zero, the Gamma function of `s` plus 1 equals `s` multiplied by the Gamma function of `s`. In mathematical terms, it's saying that for all `s ∈ ℝ, s ≠ 0`, we have `Γ(s + 1) = s * Γ(s)`. This is a property of the Gamma function often stated in mathematics as `Γ(n) = (n-1)!` for any positive integer `n`.

For any non-zero real number `s`, the Gamma function satisfies `Γ(s + 1) = s * Γ(s)`.


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

This theorem states that for any type `α` that is a Generalized Coheyting Algebra, and for any two elements `a` and `b` from this type, the result of subtracting the infimum of `a` and `b` from `b` is the same as subtracting `a` from `b`. This is denoted in Lean 4 as `b \ (a ⊓ b) = b \ a`. The `\` operator denotes set difference (also known as "set subtract"), and `⊓` denotes the infimum (greatest lower bound) in the context of a Coheyting Algebra.

In a Generalized Coheting Algebra, the set difference of an element with the infimum of that element and another element is commutative, that is, `b \ (a ⊓ b) = b \ a`.


theorem CategoryTheory.isCoseparator_def :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] (G : C),
      CategoryTheory.IsCoseparator G ↔
        ∀ ⦃X Y : C⦄ (f g : X ⟶ Y),
          (∀ (h : Y ⟶ G), CategoryTheory.CategoryStruct.comp f h = CategoryTheory.CategoryStruct.comp g h) → f = g :=
  by sorry

The theorem `CategoryTheory.isCoseparator_def` states that, for any category `C` and object `G` in `C`, `G` is a coseparator if and only if for all objects `X` and `Y` in `C` and morphisms `f` and `g` from `X` to `Y`, if for every morphism `h` from `Y` to `G`, the composition of `f` with `h` equals the composition of `g` with `h`, then `f` must be equal to `g`. In simple terms, a coseparator `G` is able to distinguish between any two different morphisms `f` and `g` from `X` to `Y`, by testing them against all morphisms `h` from `Y` to `G`.

A object `G` in a category `C` is a coseparator if and only if for all objects `X` and `Y` and morphisms `f` and `g` from `X` to `Y`, if for all morphisms `h` from `Y` to `G`, `hf = hg` implies `f = g`.


theorem Mathlib.Analysis.Normed.Group.Basic._auxLemma.34 :
    ∀ {E : Type u_6} [inst : NormedAddGroup E] {a : E}, (‖a‖ ≤ 0) = (a = 0) := by sorry

This theorem states that for any type `E` that forms a normed add group, the norm of an element `a` from `E` is less than or equal to zero if and only if `a` is zero. In mathematical terms, for a given element `a` in a normed add group `E`, the statement `‖a‖ ≤ 0` is equivalent to `a = 0`. A normed add group is a type of mathematical structure that combines a group and a vector space with a norm operation.

In a normed add group, the element with zero norm is precisely the additive identity.


theorem Mathlib.Analysis.Normed.Group.Basic._auxLemma.25 : ∀ {r₁ r₂ : NNReal}, (r₁ ≤ r₂) = (↑r₁ ≤ ↑r₂) := by sorry

This theorem states that for any two nonnegative real numbers `r₁` and `r₂`, the condition that `r₁` is less than or equal to `r₂` is equivalent to the condition that the real number associated with `r₁` is less than or equal to the real number associated with `r₂`. Here, the `↑` symbol indicates the coercion of a nonnegative real number to a real number.

For any nonnegative real numbers `r₁` and `r₂`, `r₁ ≤ r₂` if and only if `↑r₁ ≤ ↑r₂`.


/-- If `C` is thin and skeletal, then any naturally isomorphic functors to `C` are equal.  -/
theorem CategoryTheory.Functor.eq_of_iso :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂}
      [inst_1 : CategoryTheory.Category.{v₂, u₂} D] {F₁ F₂ : CategoryTheory.Functor D C} [inst_2 : Quiver.IsThin C],
      CategoryTheory.Skeletal C → (F₁ ≅ F₂) → F₁ = F₂ :=
  by sorry

The theorem `CategoryTheory.Functor.eq_of_iso` states that for any given categories `C` and `D`, if `C` is both thin and skeletal, then any two functors `F₁` and `F₂` from `D` to `C` that are naturally isomorphic are in fact equal.

To elaborate, "thin" refers to a quiver (a directed graph that may have multiple arrows between nodes) that has no parallel arrows. In the context of categories, this means there is at most one morphism between any two objects. "Skeletal" refers to a category in which any two isomorphic objects are equal, meaning there are no two distinct objects that have the same structure. The theorem states that under these conditions, naturally isomorphic functors, which are functors with a specific type of correspondence between the structures they map, must be equal.

In categories `C` that are both thin and skeletal, any two naturally isomorphic functors from another category to `C` are equal.


theorem abs_norm_sub_norm_le : ∀ {E : Type u_6} [inst : SeminormedAddGroup E] (a b : E), |‖a‖ - ‖b‖| ≤ ‖a - b‖ := by
  sorry

This theorem states that for any two elements `a` and `b` from a type `E` taking the guise of a seminormed add group, the absolute difference between their norms is less than or equal to the norm of their difference. In mathematical terms, it asserts that |‖a‖ - ‖b‖| ≤ ‖a - b‖ for any `a` and `b` in the seminormed add group `E`.

For any elements `a` and `b` in a seminormed add group `E`, the triangle inequality holds: $|||a|| - ||b||| \leq ||a - b||$.


theorem IsClosed.smul_left_of_isCompact :
    ∀ {α : Type u} {β : Type v} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] [inst_2 : Group α]
      [inst_3 : MulAction α β] [inst_4 : ContinuousInv α] [inst_5 : ContinuousSMul α β] {s : Set α} {t : Set β},
      IsClosed t → IsCompact s → IsClosed (s • t) :=
  by sorry

The theorem `IsClosed.smul_left_of_isCompact` states that if you have a set `s` of elements of some type `α` in a topological group (where α is equipped with a topological space structure and a group structure, and the group operation is continuous) and a set `t` of another type `β` in a topological space (where β is equipped with a topological space structure and a multiplication action of α on β that is continuous), and if `t` is a closed set and `s` is a compact set, then the scalar multiplication of `s` and `t` (represented by `s • t`) is also a closed set. In other words, the left scalar multiplication of a compact set by a closed set in a topological group under a continuous action is a closed set.

If `s` is a compact set in a topological group with continuous group action on a closed set `t`, then the scalar multiplication `s • t` is a closed set.


/-- For `n ≤ m`, `(n, m)` is in the reflexive-transitive closure of `~` if `i ~ succ i`
for all `i` between `n` and `m`.  -/
theorem reflTransGen_of_succ_of_le :
    ∀ {α : Type u_1} [inst : PartialOrder α] [inst_1 : SuccOrder α] [inst_2 : IsSuccArchimedean α] (r : α → α → Prop)
      {n m : α}, (∀ i ∈ Set.Ico n m, r i (Order.succ i)) → n ≤ m → Relation.ReflTransGen r n m :=
  by sorry

This theorem states that for any partially ordered type `α` with a successor order that is Archimedean (i.e., there are no infinite increasing sequences), given a relation `r` and two elements `n` and `m` of type `α` such that `n ≤ m`, if for every element `i` in the left-closed right-open interval between `n` and `m`, `i` is related to its successor, then `(n, m)` is in the reflexive-transitive closure of the relation `r`. The reflexive-transitive closure of a relation is the smallest relation that contains the original relation and is both reflexive (each element is related to itself) and transitive (if `a` is related to `b` and `b` is related to `c`, then `a` is related to `c`).

If `α` is a partially ordered type with no infinite increasing sequences, and `r` is a relation on `α` such that `n ≤ m` implies that for all `i` in the interval `(n, m)`, `i r (i' := succ i)`, then `(n, m)` is in the reflexive-transitive closure of `r`.


theorem Mathlib.Topology.Category.TopCat.Limits.Products._auxLemma.1 :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z : C} (α : X ≅ Y) {f : X ⟶ Z} {g : Y ⟶ Z},
      (CategoryTheory.CategoryStruct.comp α.hom g = f) = (g = CategoryTheory.CategoryStruct.comp α.inv f) :=
  by sorry

The theorem states that, for any category `C` and objects `X`, `Y`, and `Z` in `C`, given an isomorphism `α` from `X` to `Y` and morphisms `f` from `X` to `Z` and `g` from `Y` to `Z`, the composition of the isomorphism's forward map `α.hom` with `g` being equal to `f` is equivalent to `g` being equal to the composition of the isomorphism's inverse map `α.inv` with `f`.

For any category C, objects X, Y, Z, isomorphism α from X to Y, and morphisms f from X to Z and g from Y to Z, the equality of α.hom ∘ g with f is equivalent to the equality of g with α.inv ∘ f.


theorem Equiv.Perm.mem_alternatingGroup :
    ∀ {α : Type u_1} [inst : Fintype α] [inst_1 : DecidableEq α] {f : Equiv.Perm α},
      f ∈ alternatingGroup α ↔ Equiv.Perm.sign f = 1 :=
  by sorry

This theorem states that for any finite type `α` with decidable equality and any permutation `f` of the set `α`, `f` belongs to the alternating group of `α` if and only if the signature or parity of the permutation `f` is `1`. The alternating group of a set `α` consists of permutations that can be represented as an even number of transpositions (i.e., pairwise swaps), and these permutations are considered "even" and have a signature of `1`. Therefore, this theorem connects the concept of a permutation being in the alternating group with its signature being `1`.

A finite type `α` with decidable equality's permutations belong to its alternating group if and only if they have signature 1.