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

This theorem states that for any type `α` that forms a Generalized Coheyting Algebra (a certain type of algebraic structure), for any three elements `a`, `b`, `c` of that type, the difference of `a` and `b`, and then the difference of the result with `c`, is equal to the difference of `a` and the join (or union) of `b` and `c`. In mathematical terms, `(a \ b) \ c = a \ (b ⊔ c)`. Note that `\` represents the operation of taking the 'residual' or 'difference' in the context of Generalized Coheyting Algebras, and `⊔` represents the join operation.

In a Generalized Coheting Algebra, the difference of an element with the join of two other elements is equal to the sequential difference of that element with each of the other two.


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

This theorem, `SimplexCategory.δ_comp_σ_succ`, describes the second part of the third simplicial identity, a fundamental property in the context of the Simplex Category. Concretely, it states that for any natural number `n` and for any `i` which is a number from `0` to `n` (represented as a `Fin (n + 1)`), the composition of the `i+1`-th face map from `[n]` to `[n+1]` (denoted `SimplexCategory.δ (Fin.succ i)`) and the `i`-th degeneracy map from `[n+1]` to `[n]` (denoted `SimplexCategory.σ i`) is the identity morphism on the object `[n]` in the Simplex Category. In other words, composing these two operations results in the original object, reflecting the identity `δ_{i+1} ∘ σ_i = id`.

The composition of the `(i+1)`-th face map and the `i`-th degeneracy map in the Simplex Category is the identity map on `[n]` for any `n` and `0 ≤ i ≤ n`.


CategoryTheory.EffectiveEpiFamily.uniq

theorem CategoryTheory.EffectiveEpiFamily.uniq :
    ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_3, u_1} C] {B W : C} {α : Type u_2} (X : α → C)
      (π : (a : α) → X a ⟶ B) [inst_1 : CategoryTheory.EffectiveEpiFamily X π] (e : (a : α) → X a ⟶ W)
      (h :
        ∀ {Z : C} (a₁ a₂ : α) (g₁ : Z ⟶ X a₁) (g₂ : Z ⟶ X a₂),
          CategoryTheory.CategoryStruct.comp g₁ (π a₁) = CategoryTheory.CategoryStruct.comp g₂ (π a₂) →
            CategoryTheory.CategoryStruct.comp g₁ (e a₁) = CategoryTheory.CategoryStruct.comp g₂ (e a₂))
      (m : B ⟶ W),
      (∀ (a : α), CategoryTheory.CategoryStruct.comp (π a) m = e a) →
        m = CategoryTheory.EffectiveEpiFamily.desc X π e ⋯ :=
  by sorry

This theorem, `CategoryTheory.EffectiveEpiFamily.uniq`, states that in a category `C`, for any objects `B` and `W`, and a family of objects `X` indexed by `α`, with morphisms `π` from each `X a` to `B`, if this family forms an effective epimorphism, and there exist morphisms `e` from each `X a` to `W` such that for any object `Z` in `C` and any morphisms `g₁` and `g₂` from `Z` to `X a₁` and `X a₂` respectively, if the compositions `g₁ ≫ π a₁` and `g₂ ≫ π a₂` are equal then the compositions `g₁ ≫ e a₁` and `g₂ ≫ e a₂` are also equal, then for any morphism `m` from `B` to `W` that makes `π a ≫ m` equal to `e a` for all `a` in `α`, `m` must be equal to the unique morphism described by `CategoryTheory.EffectiveEpiFamily.desc X π e`.

In simpler terms, it says that in a category, if we have a family of objects and morphisms that behave like a collective "epimorphism", and there exists a certain commutative diagram, then any morphism that composes with the family to recreate this diagram must be the unique morphism described by a specific construction in category theory.

Given a category `C`, an effective epimorphism `π : ⨅α, Xα → B` of objects in `C`, and morphisms `e : ⨅α, Xα → W` such that for any `g₁, g₂ : C → Xα₁, α₂` with `g₁ ≫ πα₁ = g₂ ≫ πα₂` implying `g₁ ≫ eα₁ = g₂ ≫ eα₂`, there exists a unique morphism `m : B → W` satisfying `π a ≫ m = e a` for all `a ∈ α`, such that for all `h : C → W`, if `h ≫ π = m`, then `h = CategoryTheory.EffectiveEpiFamily.desc X π e`.


theorem Real.tendsto_log_nhdsWithin_zero : Filter.Tendsto Real.log (nhdsWithin 0 {0}ᶜ) Filter.atBot := by sorry

This theorem states that the real logarithm function tends to negative infinity as its argument approaches zero from the positive side. Specifically, for any open interval of negative numbers, there exists an open interval of positive numbers centered around zero such that the logarithm of any number in this positive interval falls within the given negative interval. This captures the intuitive idea that as we take the logarithm of smaller and smaller positive numbers, we get larger and larger (in magnitude) negative numbers.

For any open negative interval, there exists an open positive interval around 0 such that the logarithm of every number in the positive interval has logarithmic value in the given negative interval.


theorem AlgebraicTopology.DoldKan.Q_f_idem :
    ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
      {X : CategoryTheory.SimplicialObject C} (q n : ℕ),
      CategoryTheory.CategoryStruct.comp ((AlgebraicTopology.DoldKan.Q q).f n) ((AlgebraicTopology.DoldKan.Q q).f n) =
        (AlgebraicTopology.DoldKan.Q q).f n :=
  by sorry

This theorem states that for any category `C` that is preadditive, and any simplicial object `X` in `C`, the morphism `Q q` in the Dold-Kan correspondence is idempotent for any natural numbers `q` and `n`, i.e., the composition of `Q q` with itself equals to `Q q`. In other words, applying the function `Q q` twice to the same input has the same effect as applying it once. This property is known as idempotence in category theory and algebraic topology.

For any preadditive category `C` and simplicial object `X` in `C`, the morphism `Q q` in the Dold-Kan correspondence is idempotent, i.e., `Q q ∘ Q q = Q q`.


theorem mem_rightCoset_iff :
    ∀ {α : Type u_1} [inst : Group α] {s : Set α} {x : α} (a : α), x ∈ MulOpposite.op a • s ↔ x * a⁻¹ ∈ s := by sorry

This theorem states that for any given type `α` that forms a Group, for any set `s` of elements of type `α`, and for any elements `x` and `a` of type `α`, `x` is in the right coset of `s` formed by multiplying `s` by the multiplicative opposite of `a` if and only if the result of multiplying `x` by the inverse of `a` is in `s`. In other words, it provides a condition to check if an element belongs to a particular right coset in a Group.

For any group `α`, set `s ⊆ α`, element `a ∈ α`, and `x ∈ α`, `x ∈ s * (−a)` if and only if `x * a^−1 ∈ s`, where `*` denotes group multiplication and `^−1` denotes the multiplicative inverse.


theorem WithTop.coe_zero : ∀ {α : Type u} [inst : Zero α], ↑0 = 0 := by sorry

This theorem states that for all types `α` that have a zero (`0`) element, the coerced value of `0` (`↑0`) in the `WithTop` wrapper is equal to `0`. In simpler terms, it shows that zero wrapped with `WithTop` is still zero. This fact is true regardless of what type `α` is, as long as `α` has a defined zero.

For all types `α` with a zero element, the `WithTop` wrapper of `0` equals `0`. (Or, in mathematical notation, `↑0 = 0` where `α` has `0`.)


theorem List.singleton_sublist : ∀ {α : Type u_1} {a : α} {l : List α}, List.Sublist [a] l ↔ a ∈ l := by sorry

This theorem, `List.singleton_sublist`, states that for any type `α`, any instance `a` of that type, and any list `l` of that type, a list containing only `a` is a sublist of `l` if and only if `a` is an element of `l`. In other words, it asserts that a singleton list is a sublist of a larger list precisely when the single element of the singleton list is also a member of the larger list.

For any type `α` and any list `l` of length 1 or more over `α`, the singleton list `[a]` is a sublist of `l` if and only if `a` is an element of `l`.


theorem Finpartition.sum_card_parts :
    ∀ {α : Type u_1} [inst : DecidableEq α] {s : Finset α} (P : Finpartition s),
      (Finset.sum P.parts fun i => i.card) = s.card :=
  by sorry

This theorem states that for any given type `α` with a decidable equality, and a finite set `s` of type `α`, if `P` is a partition of `s`, then the sum of the cardinalities (or sizes) of all the parts in `P` is equal to the size of `s`. In other words, if you break up a set into several non-overlapping parts, the total number of elements in all the parts combined is the same as the number of elements in the original set.

For any finite type `α` with decidable equality, the sum of the sizes of the parts in any partition of a finite set `s` of type `α` equals the size of `s`.


theorem TopCat.prodIsoProd_hom_snd :
    ∀ (X Y : TopCat),
      CategoryTheory.CategoryStruct.comp (TopCat.prodIsoProd X Y).hom TopCat.prodSnd = CategoryTheory.Limits.prod.snd :=
  by sorry

The theorem `TopCat.prodIsoProd_hom_snd` states that for any two topological spaces `X` and `Y`, the composition of the homeomorphism from the categorical product `X ⨯ Y` to the set-theoretic product equipped with the product topology and the second projection from the set-theoretic product equals the second projection from the categorical product. In other words, if we first map the categorical product to the set-theoretic product (using the homeomorphism) and then project to the second component, this is the same as projecting to the second component in the category of topological spaces.

The homeomorphism from the categorical product of topological spaces X and Y to their set-theoretic product with product topology preserves the second projection, that is, the second projection of the categorical product equals the composition of the homeomorphism with the second projection of the set-theoretic product.


theorem isGreatest_Iic : ∀ {α : Type u} [inst : Preorder α] {a : α}, IsGreatest (Set.Iic a) a := by sorry

This theorem states that for any type `α` that has a `Preorder` instance, and for any element `a` of type `α`, `a` is the greatest element of the set of all elements less than or equal to `a`. In other words, in any partially ordered set, an element `a` is considered the greatest in the set of all elements that are less than or equal to `a`.

For any type `α` with a `Preorder` instance and any `a` in `α`, `a` is the greatest element in the subset of `α` consisting of elements less than or equal to `a`.


theorem mul_div_mul_right_eq_div : ∀ {G : Type u_3} [inst : Group G] (a b c : G), a * c / (b * c) = a / b := by sorry

This theorem is stating that for any group `G`, and any elements `a`, `b`, and `c` of that group, the result of taking `a` times `c`, and then dividing it by the result of `b` times `c`, is equivalent to simply dividing `a` by `b`. In mathematical notation, this can be written as: \( \frac{a \cdot c}{b \cdot c} = \frac{a}{b} \). This equality holds true because of the properties of groups and their operation.

For any group operation `*` and elements `a`, `b`, and `c` in the group, `(a * c) / (b * c) = a / b`.


theorem FormalMultilinearSeries.radius_eq_top_of_forall_image_add_eq_zero :
    ∀ {𝕜 : Type u_1} {E : Type u_2} {F : Type u_3} [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F]
      (p : FormalMultilinearSeries 𝕜 E F) (n : ℕ), (∀ (m : ℕ), p (m + n) = 0) → FormalMultilinearSeries.radius p = ⊤ :=
  by sorry

This theorem states that for any normed fields 𝕜, normed additive commutative group E, normed space 𝕜 E, normed additive commutative group F, normed space 𝕜 F, and a given formal multilinear series 'p', if all the mth terms of the series 'p' after addition with a natural number 'n' results in zero, then the radius of convergence of the formal multilinear series 'p' is the mathematical entity 'top' (which usually represents infinity).

If the sum of all terms of degree greater than or equal to a certain natural number in a formal multilinear series over a normed field is zero for all normed spaces involved, then the radius of convergence is infinite.


theorem Monoid.exponent_min' :
    ∀ {G : Type u} [inst : Monoid G] (n : ℕ), 0 < n → (∀ (g : G), g ^ n = 1) → Monoid.exponent G ≤ n := by sorry

The theorem `Monoid.exponent_min'` states that for any monoid `G` and any positive natural number `n`, if every element `g` of the monoid `G` satisfies the property that `g` raised to power `n` equals the identity element (`g ^ n = 1`), then the exponent of the monoid `G` is less than or equal to `n`. This is essentially saying that the exponent of a monoid, defined as the smallest positive integer `n` such that `g ^ n = 1` for all `g` in `G` (or zero if such an `n` doesn't exist), must be the smallest such `n` that satisfies this property for all `g` in `G`.

If every element in a monoid raises any positive power to the power of its exponent equal to the identity element, then the monoid's exponent is less than or equal to that power.


Filter.Tendsto.inv

/-- If a function converges to a value in a multiplicative topological group, then its inverse
converges to the inverse of this value. For the version in normed fields assuming additionally
that the limit is nonzero, use `Tendsto.inv'`.  -/
theorem Filter.Tendsto.inv :
    ∀ {G : Type w} {α : Type u} [inst : TopologicalSpace G] [inst_1 : Inv G] [inst_2 : ContinuousInv G] {f : α → G}
      {l : Filter α} {y : G}, Filter.Tendsto f l (nhds y) → Filter.Tendsto (fun x => (f x)⁻¹) l (nhds y⁻¹) :=
  by sorry

This theorem states that if a function, within the context of a multiplicative topological group, converges to a certain value, then the inverse of this function converges to the inverse of that value. More formally, given a function `f` from an arbitrary type `α` to a topological space `G`, if `f` tends to a limit `y` (i.e., for every neighborhood of `y`, the pre-image under `f` of this neighborhood is a neighborhood in the domain of `f`) as described by `Filter.Tendsto f l (nhds y)`, then the function that maps `x` to the inverse of `f(x)` also tends to the inverse of `y`. The conditions that `G` is a topological space, has a defined operation of inversion (`Inv G`), and this inversion operation is continuous (`ContinuousInv G`), are also required. Note that this theorem is stated in general for any multiplicative topological group, and there is a specific version applicable for normed fields where the limit is non-zero.

If a multiplicative topological group homomorphism `f : α → G` with `G` being a topological space, having a continuous inversion operation, tends to a limit `y` in `G`, then the function that maps each `x` to the inverse of `f(x)` tends to the inverse of `y`.


theorem Polynomial.degree_le_zero_iff :
    ∀ {R : Type u} [inst : Semiring R] {p : Polynomial R},
      Polynomial.degree p ≤ 0 ↔ p = Polynomial.C (Polynomial.coeff p 0) :=
  by sorry

The theorem `Polynomial.degree_le_zero_iff` establishes an equivalence condition for a polynomial in a given semiring. It states that for any polynomial `p` over a semiring `R`, the degree of the polynomial `p` is less than or equal to zero if and only if `p` is equal to the constant polynomial whose coefficient is the coefficient of `p` at degree 0. In other words, a polynomial has degree at most zero if and only if it is a constant polynomial, where the constant term is the coefficient of the zeroth degree term of the polynomial.

A polynomial over a semiring has degree at most zero if and only if it is equal to the constant polynomial with coefficient equal to its zeroth degree term.


theorem Filter.Tendsto.limUnder_eq :
    ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : T2Space X] {x : X} {f : Filter Y}
      [inst_2 : Filter.NeBot f] {g : Y → X}, Filter.Tendsto g f (nhds x) → limUnder f g = x :=
  by sorry

This theorem establishes an equivalence between the notion of a limit and the concept of a function tending towards a limit in a topological space. Specifically, for any topological space `X` that is also a `T2Space` (a space in which any two distinct points have disjoint open neighborhoods), given any point `x` in `X` and a filter `f` on an arbitrary type `Y` (where the filter is not the smallest filter, i.e., not the bottom element), and a function `g` from `Y` to `X`. If the function `g` tends towards the neighborhood filter of `x` under the filter `f` (i.e., for every neighborhood of `x`, there is a set in filter `f` such that the image of that set under `g` falls inside the neighborhood), then the limit of the function `g` under the filter `f` is `x`. This theorem essentially asserts that under these conditions, the limit is unique and is equal to the point towards which the function tends.

In a T2 topological space, if a function tends towards a point under a non-bottom filter, then the limit of the function under that filter equals the point.


/-- If `F` preserves pullbacks, then it preserves monomorphisms.  -/
theorem CategoryTheory.preserves_mono_of_preservesLimit :
    ∀ {C : Type u₁} {D : Type u₂} [inst : CategoryTheory.Category.{v₁, u₁} C]
      [inst_1 : CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor C D) {X Y : C} (f : X ⟶ Y)
      [inst_2 : CategoryTheory.Limits.PreservesLimit (CategoryTheory.Limits.cospan f f) F]
      [inst_3 : CategoryTheory.Mono f], CategoryTheory.Mono (F.map f) :=
  by sorry

The theorem `CategoryTheory.preserves_mono_of_preservesLimit` states that for any categories `C` and `D`, given a functor `F` from `C` to `D`, if `F` preserves the limit of the cospan of a morphism `f` from `X` to `Y` in `C` (i.e., `F` preserves pullbacks), and if `f` is a monomorphism in `C`, then the image of `f` under `F` is a monomorphism in `D`. In other words, if a functor preserves pullbacks, it also preserves monomorphisms.

If functor $F : C \to D$ preserves limits and $f : X \to Y$ is a monomorphism in $C$, then $F(f) : F(X) \to F(Y)$ is a monomorphism in $D$.


theorem map_sub_rev :
    ∀ {F : Type u_2} {α : Type u_3} {β : Type u_4} [inst : FunLike F α β] [inst_1 : AddGroup α]
      [inst_2 : OrderedAddCommMonoid β] [inst_3 : AddGroupSeminormClass F α β] (f : F) (x y : α),
      f (x - y) = f (y - x) :=
  by sorry

The theorem `map_sub_rev` states that for all types `F`, `α`, `β`, given an instance of `FunLike F α β` (which means `F` has an injective coercion to functions from `α` to `β`), an `AddGroup` over `α`, an `OrderedAddCommMonoid` over `β`, and an `AddGroupSeminormClass` over `F`, `α`, and `β`, for any function `f` of type `F` and any elements `x` and `y` of type `α`, applying `f` to the result of subtracting `y` from `x` yields the same result as applying `f` to the result of subtracting `x` from `y`. In other words, `f` preserves the property of negation over the subtraction operation in `α`.

For any function `f` in a FunLike structure between AddGroups `α` and `β` with an AddGroupSeminormClass, applying `f` to the difference of two elements is commutative with respect to the subtraction operation.


theorem lt_or_lt_of_div_lt_div :
    ∀ {α : Type u} [inst : CommGroup α] [inst_1 : LinearOrder α]
      [inst_2 : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1] {a b c d : α},
      a / d < b / c → a < b ∨ c < d :=
  by sorry

This theorem states that for any type `α` that forms a commutative group with a linear order and satisfies the covariant property, if the quotient of `a` and `d` is less than the quotient of `b` and `c`, then `a` is less than `b` or `c` is less than `d`. In mathematical terms, this means that if `a/d < b/c`, then either `a < b` or `c < d`.

If `α` is a commutative group with a linear order satisfying the covariant property, then `a < b` or `c < d` holds if and only if `a/d < b/c`.


/-- Any element semiconjugates `1` to `1`.  -/
theorem SemiconjBy.one_right : ∀ {M : Type u_2} [inst : MulOneClass M] (a : M), SemiconjBy a 1 1 := by sorry

The theorem `SemiconjBy.one_right` states that for any type `M` which possesses a multiplication operation and a multiplicative identity element (`1`), every element `a` of `M` semiconjugates `1` to `1`. In other words, for any element `a` in `M`, the product `a * 1` is equal to `1 * a`, which is essentially the definition of a multiplicative identity.

For any type `M` with multiplication and multiplicative identity `1`, every element `a` in `M` satisfies `a * 1 = 1 * a`.


theorem CategoryTheory.Discrete.monoidalFunctor.proof_1 :
    ∀ {M : Type u_2} [inst : Monoid M] {N : Type u_1} [inst_1 : Monoid N] (F : M →* N)
      {X Y : CategoryTheory.Discrete M}, (X ⟶ Y) → F X.as = F Y.as :=
  by sorry

This theorem states that for any two objects `X` and `Y` in the discrete category of a monoid `M`, and a monoid homomorphism `F` from `M` to another monoid `N`, the image of the `as` (the underlying element of the monoid) of `X` under `F` is equal to the image of the `as` of `Y` under `F`, provided that there exists a morphism from `X` to `Y` in the discrete category. In simpler terms, this theorem says that any morphism in the discrete category essentially maps elements in `M` to their corresponding images in `N` under the homomorphism `F`.

Given any monoid homomorphism `F` from monoid `M` to monoid `N`, objects `X` and `Y` in the discrete category of `M`, and a morphism from `X` to `Y`, the image of the underlying element of `X` under `F` is equal to the image of the underlying element of `Y` under `F`.


theorem Set.OrdConnected.upperClosure_inter_lowerClosure :
    ∀ {α : Type u_1} [inst : Preorder α] {s : Set α}, Set.OrdConnected s → ↑(upperClosure s) ∩ ↑(lowerClosure s) = s :=
  by sorry

This theorem states that for any set `s` of elements of a certain type `α`, under the condition that `α` has a Preorder relation and the set `s` is order-connected, the intersection of the upper closure and lower closure of `s` is equivalent to `s` itself. In other words, for an order-connected set, the overlap of all elements that are at least as great as some element in the set and all elements that are at most as great as some element in the set, is nothing but the set itself.

For any order-connected subset `s` of a preordered type `α`, the upper and lower closures of `s` coincide, i.e., `s` = `cl_upper s` = `cl_lower s`.


theorem LinearEquiv.toEquiv_injective :
    ∀ {R : Type u_1} {S : Type u_6} {M : Type u_7} {M₂ : Type u_9} [inst : Semiring R] [inst_1 : Semiring S]
      [inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid M₂] [inst_4 : Module R M] [inst_5 : Module S M₂] {σ : R →+* S}
      {σ' : S →+* R} [inst_6 : RingHomInvPair σ σ'] [inst_7 : RingHomInvPair σ' σ],
      Function.Injective LinearEquiv.toEquiv :=
  by sorry

The theorem `LinearEquiv.toEquiv_injective` states that for any types `R`, `S`, `M`, and `M₂`, where `R` and `S` are semirings, `M` and `M₂` are additive commutative monoids, `M` is a module over `R`, `M₂` is a module over `S`, and there are two ring homomorphisms `σ: R →+* S` and `σ': S →+* R` that form a pair of inverse ring homomorphisms, the function `LinearEquiv.toEquiv` is injective. In other words, if two linear equivalences have the same underlying function equivalence, then they must be the same linear equivalence.

If `σ: R →+* S` and `σ': S →+* R` are a pair of inverse ring homomorphisms between semirings `R` and `S`, and `LinearEquiv.toEquiv` maps two linear equivalences between modules `M` over `R` and `M₂` over `S` with the same underlying function equivalence, then these linear equivalences are equal.


/-- The function `expNegInvGlue` vanishes on `(-∞, 0]`.  -/
theorem expNegInvGlue.zero_of_nonpos : ∀ {x : ℝ}, x ≤ 0 → expNegInvGlue x = 0 := by sorry

The theorem `expNegInvGlue.zero_of_nonpos` states that the function `expNegInvGlue` evaluates to zero for all real numbers `x` that are less than or equal to zero. In other words, the function `expNegInvGlue` vanishes on the interval from negative infinity to zero, inclusive.

For all real numbers `x ≤ 0`, the function `expNegInvGlue(x) = 0`.


theorem Ring.not_isField_iff_exists_ideal_bot_lt_and_lt_top :
    ∀ {R : Type u_1} [inst : CommSemiring R] [inst_1 : Nontrivial R], ¬IsField R ↔ ∃ I, ⊥ < I ∧ I < ⊤ := by sorry

This theorem states that for any commutative semiring `R` that is nontrivial (i.e., it has at least two distinct elements), `R` is not a field if and only if there exists an ideal `I` in `R` such that `I` is greater than the trivial (or zero) ideal and less than the unit ideal (or the whole ring). In mathematical terms, the theorem establishes a bi-directional relationship between the property of a ring not being a field and the existence of an ideal within the ring that is strictly between the zero and unit ideals.

A commutative semiring `R` is not a field if and only if it contains a proper, non-zero ideal.


theorem Mathlib.Order.CompactlyGenerated.Basic._auxLemma.13 :
    ∀ {α : Type u_1} [inst : SemilatticeInf α] [inst_1 : OrderBot α] {a b : α}, Disjoint a b = (a ⊓ b = ⊥) := by sorry

This theorem states that for any type `α` which is a semilattice with respect to the infimum operation and has a bottom element, and for any two elements `a` and `b` of that type, `a` and `b` are disjoint (defined as every element `x` that is less than or equal to both `a` and `b` must also be less than or equal to the bottom element) if and only if the infimum of `a` and `b` is the bottom element. This theorem is generalizing the property of disjoint sets, where the intersection of two disjoint sets is empty, to an arbitrary semilattice with a bottom element.

For any semilattice with a bottom element α, elements a and b are disjoint if and only if their infimum is the bottom element.


theorem Mathlib.Order.CompactlyGenerated.Basic._auxLemma.14 :
    ∀ {α : Type u_1} {ι : Sort u_5} [inst : CompleteLattice α] {s : ι → α}, (iSup s = ⊥) = ∀ (i : ι), s i = ⊥ := by
  sorry

This theorem states that for any type `α` and index type `ι`, where `α` is a complete lattice, and `s` is a function from `ι` to `α`, the indexed supremum (`iSup`) of `s` is equal to the bottom element (`⊥`) if and only if all elements of `s` are equal to the bottom element. In other words, the supremum of a set of elements in a complete lattice is the bottom element if and only if each element in the set is the bottom element.

For any complete lattice `α` and index type `ι`, the indexed supremum `iSup` of a function `s : ι → α` is the bottom element `⊥` if and only if all elements in the image of `s` are equal to `⊥`.


theorem Int.negOnePow_add : ∀ (n₁ n₂ : ℤ), (n₁ + n₂).negOnePow = n₁.negOnePow * n₂.negOnePow := by sorry

This theorem states that for any two given integers `n₁` and `n₂`, the power of negative one to the sum of these integers is equal to the product of the power of negative one to `n₁` and the power of negative one to `n₂`. In mathematical terms, this theorem establishes that $(-1)^{n₁ + n₂} = (-1)^{n₁} * (-1)^{n₂}$.

The theorem asserts that for any integers `n₁` and `n₂`, $(-1)^{n₁ + n₂} = (-1)^{n₁} \times (-1)^{n₂}$.


theorem List.perm_singleton : ∀ {α : Type u_1} {a : α} {l : List α}, List.Perm l [a] ↔ l = [a] := by sorry

This theorem states that for all types `α`, elements `a` of type `α`, and lists `l` of type `α`, the list `l` is a permutation of the single-element list `[a]` if and only if `l` is identical to the single-element list `[a]`. In other words, a list is a permutation of a singleton list if and only if it is equal to that singleton list.

For all types `α` and elements `a` of type `α`, the list `[a]` is a permutation of list `l` of type `α` if and only if `l = [a]`.


/-- **Fermat's Theorem**: the derivative of a function at a local minimum equals zero.  -/
theorem IsLocalMin.hasFDerivAt_eq_zero :
    ∀ {E : Type u} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {f : E → ℝ} {a : E} {f' : E →L[ℝ] ℝ},
      IsLocalMin f a → HasFDerivAt f f' a → f' = 0 :=
  by sorry

**Fermat's Theorem** states that for a function `f` that maps from a normed additive commutative group `E` (with a normed real number space) to the real numbers, if `f` has a local minimum at a point `a`, and if `f` has a derivative `f'` at this point `a`, then the derivative `f'` at this point `a` is zero. In mathematical terms, if `f` is locally minimized at `a` and `f'(a)` exists, then `f'(a) = 0`. This is a fundamental result of calculus that characterizes critical points of functions.

If a real-valued function `f` on a normed additive commutative group `E` has a local minimum at `a` and a derivate `f'` at `a`, then `f'(a) = 0`.


theorem HomologicalComplex.p_descOpcycles :
    ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_3, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
      {ι : Type u_2} {c : ComplexShape ι} (K : HomologicalComplex C c) {i : ι}
      [inst_2 : HomologicalComplex.HasHomology K i] {A : C} (k : K.X i ⟶ A) (j : ι) (hj : ComplexShape.prev c i = j)
      (hk : CategoryTheory.CategoryStruct.comp (K.d j i) k = 0),
      CategoryTheory.CategoryStruct.comp (HomologicalComplex.pOpcycles K i)
          (HomologicalComplex.descOpcycles K k j hj hk) =
        k :=
  by sorry

Theorem `HomologicalComplex.p_descOpcycles` states that for any category `C` with zero morphisms, any complex shape `c`, and any homological complex `K` in `C` which has homology at index `i`, if `A` is an object in `C`, `k` is a morphism from `K.X i` to `A`, `j` is an index such that `j` is the previous index of `i` in the complex shape `c`, and the composition of the differentials `K.d j i` and `k` is the zero morphism, then the composition of the projection to the opcycles of `K` at `i` and the descendent opcycles of `K` with `k`, `j`, `hj`, and `hk` is equal to `k`. In essence, this theorem describes how differentials and morphisms behave in relation to the opcycles of a homological complex.

Given a homological complex `K` in a category `C` with zero morphisms, if the composition of the differential `K.d j i` and morphism `k` from `K.X i` to an object `A` is zero, then the composition of `K.Z i`.`proj`, `K.Z j`.`desc`, `hj`, `hk`, and `k` equals `k`.


theorem Equiv.Perm.IsCycle.cycleOf_eq :
    ∀ {α : Type u_2} [inst : DecidableEq α] [inst_1 : Fintype α] {f : Equiv.Perm α} {x : α},
      Equiv.Perm.IsCycle f → f x ≠ x → Equiv.Perm.cycleOf f x = f :=
  by sorry

The theorem `Equiv.Perm.IsCycle.cycleOf_eq` asserts that for all types `α`, given that `α` has a decidable equality and is a finite type, for any permutation `f` of `α` and any element `x` of `α`, if `f` is a cycle (a non-identity permutation in which any two non-fixed points are related by repeated application of the permutation) and `f` of `x` is not equal to `x`, then the cycle of the permutation `f` to which `x` belongs is equal to `f` itself.

For any finite type `α` with decidable equality and any permutation `f` on `α` that is a cycle, if `x` is a non-fixed point of `f`, then the cycle containing `x` is equal to `f`.


theorem SetTheory.PGame.moveLeft_lf :
    ∀ {x : SetTheory.PGame} (i : SetTheory.PGame.LeftMoves x), SetTheory.PGame.LF (SetTheory.PGame.moveLeft x i) x := by
  sorry

This theorem from set theory's game theory, `SetTheory.PGame.moveLeft_lf`, states that for any pre-game `x` and any allowable move `i` by the Left player in `x`, the post-move game (obtained by applying `SetTheory.PGame.moveLeft` to `x` and `i`) is less fuzzy than the original game `x`. In other words, after Left makes an allowable move `i` in a pre-game `x`, Left can win the resulting game as the first player.

For any pre-game `x` and allowable move `i` by the Left player, the post-move game obtained by applying `moveLeft` is a Left-winning game.


theorem CategoryTheory.ShortComplex.RightHomologyData.p_g'_assoc :
    ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
      {S : CategoryTheory.ShortComplex C} (h : CategoryTheory.ShortComplex.RightHomologyData S) {Z : C}
      (h_1 : S.X₃ ⟶ Z),
      CategoryTheory.CategoryStruct.comp h.p
          (CategoryTheory.CategoryStruct.comp (CategoryTheory.ShortComplex.RightHomologyData.g' h) h_1) =
        CategoryTheory.CategoryStruct.comp S.g h_1 :=
  by sorry

The theorem `CategoryTheory.ShortComplex.RightHomologyData.p_g'_assoc` states that for any Category `C` with zero morphisms, any `ShortComplex` `S` of `C`, any `RightHomologyData` `h` of `S`, and any morphism `h_1` from `S.X₃` to some object `Z` in `C`, the composition of `h.p` with the composition of `h.g'` and `h_1` is equal to the composition of `S.g` and `h_1`. This theorem is expressing a certain associativity property in the context of Category Theory and Homological Algebra.

For any Category `C` with zero morphisms, any ShortComplex `S` in `C`, any RightHomologyData `h` of `S`, and any morphism `h_1` from `S.X₃` to an object `Z` in `C`, we have `h.p ∘ (h.g' ∘ h_1) = (S.g ∘ h_1)`.


theorem eq_compl_iff_isCompl : ∀ {α : Type u} {x y : α} [inst : BooleanAlgebra α], x = yᶜ ↔ IsCompl x y := by sorry

This theorem states that for any type `α` with a Boolean algebra structure, and any two elements `x` and `y` of type `α`, `x` equals the complement of `y` if and only if `x` and `y` are complements of each other. In mathematical terms, given a Boolean algebra (often represented in terms of set operations), two elements `x` and `y` are complements (i.e., their union is the whole set and their intersection is empty) if and only if `x` is equivalent to the set-theoretic complement of `y`.

For any Boolean algebra type `α` and elements `x` and `y` of type `α`, `x` and `y` are complements if and only if `x` is the complement of `y` and vice versa.


Dioph.inter

theorem Dioph.inter : ∀ {α : Type u} {S S' : Set (α → ℕ)}, Dioph S → Dioph S' → Dioph (S ∩ S') := by sorry

The theorem `Dioph.inter` states that for any two sets `S` and `S'` of functions from a type `α` to natural numbers (`ℕ`), if both `S` and `S'` are Diophantine, then their intersection (`S ∩ S'`) is also Diophantine. Here, a set is said to be Diophantine if there exists a polynomial on `α ⊕ β` such that a function `v` belongs to the set if and only if there exists a function `t : ℕ^β` such that the polynomial evaluated at `(v, t)` equals zero.

If `S` and `S'` are Diophantine sets of functions from type `α` to natural numbers, then their intersection `S ∩ S'` is also a Diophantine set.


IsLocallyConstant.comp

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

The theorem `IsLocallyConstant.comp` states that for any three types `X`, `Y`, and `Z`, given a topological space over `X` and a function `f` from `X` to `Y` that is locally constant — meaning the preimage of any subset of `Y` under `f` is an open set in `X` — then for any function `g` from `Y` to `Z`, the composition of `g` and `f` (denoted as `g ∘ f`) is also locally constant. Essentially, this means the property of being locally constant is preserved under function composition.

If `f : X -> Y` is locally constant and `g : Y -> Z`, then `g ∘ f` is locally constant.


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

This theorem states that for any given group homomorphism `f` from a group `G` to another group `N`, and any subgroup `H` of `N`, the multiplicative kernel of `f` is a subset of (or equal to) the preimage of `H` under `f`. The multiplicative kernel of `f` here refers to the set of all elements `x` in `G` such that `f(x)` equals the identity element in `N`. The preimage of `H` under `f` is the set of all elements in `G` that map to any element in `H` under `f`.

The multiplicative kernel of a group homomorphism is contained in the preimage of its subgroup under the homomorphism.


theorem Equiv.refl_trans : ∀ {α : Sort u} {β : Sort v} (e : α ≃ β), (Equiv.refl α).trans e = e := by sorry

This theorem, named `Equiv.refl_trans`, states that for all types `α` and `β`, if there exists an equivalence `e` between `α` and `β`, then the composition of the reflexive equivalence on `α` and `e` is just `e`. In other words, precomposing any equivalence `e : α ≃ β` with the identity equivalence on `α` doesn't change `e`. This mirrors the mathematical concept that composing a function with the identity function leaves the original function unchanged.

For all types `α` and `β` and equivalences `e : α ≈ β`, the composition of reflexivity on `α` and `e` equals `e`. In symbols, `rfl α ∘ e = e`.


/-- **Alias** of `div_lt_div_of_pos_right`. -/
theorem div_lt_div_of_lt :
    ∀ {α : Type u_2} [inst : LinearOrderedSemifield α] {a b c : α}, a < b → 0 < c → a / c < b / c := by sorry

This theorem, `div_lt_div_of_lt`, states that for any linear ordered semifield `α` and any three elements `a`, `b`, and `c` of `α`, if `a` is less than `b` and `c` is greater than `0`, then `a` divided by `c` is less than `b` divided by `c`. This is essentially an alias for the theorem `div_lt_div_of_pos_right`.

If `α` is a linear ordered semifield, `a`, `b` are elements of `α`, and `0 < c`, then `a / c < b / c`.


theorem OmegaCompletePartialOrder.Chain.map_comp :
    ∀ {α : Type u} {β : Type v} {γ : Type u_1} [inst : Preorder α] [inst_1 : Preorder β] [inst_2 : Preorder γ]
      (c : OmegaCompletePartialOrder.Chain α) {f : α →o β} (g : β →o γ),
      OmegaCompletePartialOrder.Chain.map (OmegaCompletePartialOrder.Chain.map c f) g =
        OmegaCompletePartialOrder.Chain.map c (OrderHom.comp g f) :=
  by sorry

The theorem `OmegaCompletePartialOrder.Chain.map_comp` states that for all types `α`, `β`, and `γ` that are preordered, and for any chain `c` in `α`, and any order preserving functions `f` from `α` to `β` and `g` from `β` to `γ`, mapping the chain `c` first by `f` and then by `g` (i.e., doing two consecutive mappings) is the same as first composing the functions `g` and `f` and then mapping the chain `c` by the composed function. This theorem therefore asserts the compatibility of the chain mapping operation with the function composition operation in the context of omega complete partial orders.

For any chain in an omega complete preordered type `α`, and order preserving functions `f : α → β` and `g : β → γ`, the composition `g ∘ f` preserves the ordering between elements of the chain if and only if the chain application of `g` followed by the chain application of `f` also preserves the ordering.


theorem SimpleGraph.mem_incidence_iff_neighbor :
    ∀ {V : Type u} (G : SimpleGraph V) {v w : V},
      s(v, w) ∈ SimpleGraph.incidenceSet G v ↔ w ∈ SimpleGraph.neighborSet G v :=
  by sorry

This theorem states that for any simple graph `G` of vertices of type `V` and any two vertices `v` and `w` in the graph, the pair `s(v, w)` (representing an edge) belongs to the incidence set of `v` in `G` if and only if the vertex `w` is in the neighbor set of `v` in `G`. In other words, an edge is incident to a vertex if and only if the other end of the edge is a neighbor of the vertex.

For any simple graph G and vertices v, w in G, the edge s(v, w) is in the incidence set of v if and only if w is in the neighbor set of v.


theorem specializes_iff_mem_closure : ∀ {X : Type u_1} [inst : TopologicalSpace X] {x y : X}, x ⤳ y ↔ y ∈ closure {x} :=
  by sorry

The theorem `specializes_iff_mem_closure` states that for any topological space `X` and any two points `x` and `y` in `X`, the point `x` specializes to `y` (i.e., every open neighborhood of `x` also contains `y`) if and only if `y` is a member of the closure of the set containing only `x`. In other words, the specialization relation between two points corresponds to membership in the closure of the singleton set.

A point specializes to another point in a topological space if and only if the second point belongs to the closure of the set containing the first point.


theorem iSup_iUnion :
    ∀ {α : Type u_1} {β : Type u_2} {ι : Sort u_4} [inst : CompleteLattice β] (s : ι → Set α) (f : α → β),
      ⨆ a ∈ ⋃ i, s i, f a = ⨆ i, ⨆ a ∈ s i, f a :=
  by sorry

This theorem, `iSup_iUnion`, states that for all types `α`, `β`, and `ι`, given a complete lattice structure on `β`, a function `s` from `ι` to a set of `α`, and a function `f` from `α` to `β`, the supremum (denoted by `⨆`) of `f a` for any `a` in the union (denoted by `⋃`) of all sets `s i` is equal to the supremum of the suprema of `f a` for `a` in each `s i`. In other words, it asserts the equality between the supreme value obtained through the function `f` applied over a union of sets, and the supreme value obtained through the function `f` applied individually to each set, considering all sets provided by the function `s`.

For any complete lattice `β`, function `s` from index set `ι` to sets of type `α`, and function `f` from `α` to `β`, the supremum of `f` applied to the union of `s i` is equal to the supremum of the suprema of `f a` over each `s i`.


theorem CategoryTheory.finitaryExtensive_of_preserves_and_reflects :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {D : Type u''}
      [inst_1 : CategoryTheory.Category.{v'', u''} D] (F : CategoryTheory.Functor C D)
      [inst_2 : CategoryTheory.FinitaryExtensive D] [inst_3 : CategoryTheory.Limits.HasFiniteCoproducts C]
      [inst_4 : CategoryTheory.HasPullbacksOfInclusions C] [inst_5 : CategoryTheory.PreservesPullbacksOfInclusions F]
      [inst_6 : CategoryTheory.Limits.ReflectsLimitsOfShape CategoryTheory.Limits.WalkingCospan F]
      [inst_7 :
        CategoryTheory.Limits.PreservesColimitsOfShape (CategoryTheory.Discrete CategoryTheory.Limits.WalkingPair) F]
      [inst_8 :
        CategoryTheory.Limits.ReflectsColimitsOfShape (CategoryTheory.Discrete CategoryTheory.Limits.WalkingPair) F],
      CategoryTheory.FinitaryExtensive C :=
  by sorry

This theorem states that for any two categories `C` and `D` and a functor `F` from `C` to `D`, if `D` is finitary extensive, `C` has finite coproducts, `C` has pullbacks of inclusions, `F` preserves pullbacks of inclusions, `F` reflects limits of the shape `WalkingCospan`, `F` preserves colimits of the shape `WalkingPair`, and `F` reflects colimits of the shape `WalkingPair`, then `C` is also finitary extensive.

In more detail, finitary extensiveness is a property of a category that relates to the ability to 'break apart' objects into a finite coproduct of smaller objects. The theorem is essentially saying that if these conditions are met, then this property is preserved under the functor `F`: if you can 'break apart' objects in `D`, then you can also 'break apart' their pre-images in `C`. The conditions on `F` mean that `F` behaves well with respect to certain limits and colimits, essentially that it 'respects' the ways in which objects can be 'broken apart' or 'put together'.

If categories `C` and `D` have given properties, and functor `F` from `C` to `D` preserves certain limits and colimits, then `C` is finitarily extensive if `D` is.


theorem Ordinal.derivFamily_isNormal :
    ∀ {ι : Type u} (f : ι → Ordinal.{max u u_1} → Ordinal.{max u u_1}), Ordinal.IsNormal (Ordinal.derivFamily f) := by
  sorry

The theorem `Ordinal.derivFamily_isNormal` states that for all types `ι` and for any function `f` from `ι` to a family of ordinals, the derivative family of `f`, which is represented as `Ordinal.derivFamily f`, is a normal ordinal function. A normal ordinal function, in this context, means that the function is strictly increasing and order-continuous. This implies that the image of a limit ordinal under this function is the supremum of the images of the ordinals less than the original limit ordinal.

The derivative family of a function from an type `ι` to ordinals is a normal ordinal function, i.e., it is strictly increasing and order-continuous, ensuring the image of a limit ordinal is the supremum of the images of smaller ordinals.


HasFPowerSeriesAt.congr

theorem HasFPowerSeriesAt.congr :
    ∀ {𝕜 : Type u_1} {E : Type u_2} {F : Type u_3} [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {f g : E → F}
      {p : FormalMultilinearSeries 𝕜 E F} {x : E}, HasFPowerSeriesAt f p x → f =ᶠ[nhds x] g → HasFPowerSeriesAt g p x :=
  by sorry

The theorem `HasFPowerSeriesAt.congr` states that for any nontrivially normed field `𝕜`, normed additive commutative groups `E` and `F`, normed spaces over `𝕜` for `E` and `F`, and functions `f` and `g` from `E` to `F`, together with a formal multilinear series `p` and an element `x` of `E`, if `f` has a power series representation `p` at `x`, and `f` equals `g` in a neighborhood of `x`, then `g` also has the power series representation `p` at `x`. This theorem essentially says that local equality of functions in a neighborhood implies the same power series representation.

If `nontrivially normed fields 𝕜`, normed additive commutative groups `E` and `F`, normed spaces over `𝕜` for `E` and `F`, functions `f: E → F` and `g: E → F`, formal multilinear series `p`, and element `x` in `E` satisfy `f = g` in a neighborhood of `x` and `f` has power series representation `p` at `x`, then `g` also has power series representation `p` at `x`.


RingEquiv.bijective

theorem RingEquiv.bijective :
    ∀ {R : Type u_4} {S : Type u_5} [inst : Mul R] [inst_1 : Mul S] [inst_2 : Add R] [inst_3 : Add S] (e : R ≃+* S),
      Function.Bijective ⇑e :=
  by sorry

The theorem `RingEquiv.bijective` asserts that for any types `R` and `S` which both have multiplication (`Mul`) and addition (`Add`) operations defined on them, any ring isomorphism `e` (denoted as `R ≃+* S` in Lean) between `R` and `S` is a bijective function. In other words, the application of `e` (denoted as `⇑e`) is both injective (one-to-one) and surjective (onto).

Given types `R` and `S` with multiplication and addition operations, and a ring isomorphism `e : R ≃+* S`, then `e` is a bijective function.


theorem Nat.pred_le_pred : ∀ {n m : ℕ}, n ≤ m → Nat.pred n ≤ Nat.pred m := by sorry

The theorem `Nat.pred_le_pred` states that for any two natural numbers `n` and `m`, if `n` is less than or equal to `m` (expressed as `n ≤ m`), then the predecessor of `n` is also less than or equal to the predecessor of `m` (expressed as `Nat.pred n ≤ Nat.pred m`). Here, the predecessor of a natural number `x` is defined as `x - 1` if `x` is not zero, and it remains zero if `x` is zero.

For all natural numbers `n` and `m`, if `n ≤ m` then `Nat.pred n ≤ Nat.pred m`.


theorem ProbabilityTheory.kernel.Indep.indepSets :
    ∀ {α : Type u_1} {Ω : Type u_2} {_mα : MeasurableSpace α} {_mΩ : MeasurableSpace Ω}
      {κ : ↥(ProbabilityTheory.kernel α Ω)} {μ : MeasureTheory.Measure α} {s1 s2 : Set (Set Ω)},
      ProbabilityTheory.kernel.Indep (MeasurableSpace.generateFrom s1) (MeasurableSpace.generateFrom s2) κ μ →
        ProbabilityTheory.kernel.IndepSets s1 s2 κ μ :=
  by sorry

This theorem states that for any types `α` and `Ω`, given a measurable space on `α` and `Ω`, a kernel `κ` from `α` to `Ω`, a measure `μ` on `α`, and two sets of sets `s1` and `s2` in `Ω`, if the two measurable spaces generated from `s1` and `s2` are independent with respect to the kernel `κ` and the measure `μ`, then the sets of sets `s1` and `s2` are also independent with respect to the same kernel and measure. In other words, it shows that the independence of the generated measurable spaces implies the independence of the original sets of sets under the same conditions.

If measurable spaces $(s_1, \mathcal{A}_1, \mu, \kappa)$ and $(s_2, \mathcal{A}_2, \mu, \kappa)$ generated from sets $s_1, s_2 \subseteq \Omega$ are independent with respect to kernel $\kappa$ and measure $\mu$, then $s_1$ and $s_2$ are independent sets in $\Omega$ with respect to kernel $\kappa$ and measure $\mu$.


theorem Nat.minFac_has_prop : ∀ {n : ℕ}, n ≠ 1 → Nat.minFacProp n (Nat.minFac n) := by sorry

This theorem states that for every natural number `n` that is not equal to 1, the function `Nat.minFac` returns a number that has the property described by `Nat.minFacProp`. Specifically, this property is that the returned number is a prime factor of `n`, and is the smallest such factor.

For every natural number `n` not equal to 1, there exists a prime factor `p` of `n` such that `p` = `Nat.minFac n`.


theorem AddLECancellable.add_tsub_assoc_of_le :
    ∀ {α : Type u_1} [inst : AddCommSemigroup α] [inst_1 : PartialOrder α] [inst_2 : ExistsAddOfLE α]
      [inst_3 : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] [inst_4 : Sub α] [inst_5 : OrderedSub α]
      {b c : α}, AddLECancellable c → c ≤ b → ∀ (a : α), a + b - c = a + (b - c) :=
  by sorry

The theorem `AddLECancellable.add_tsub_assoc_of_le` states that for any type `α` which is an additive commutative semigroup, has a partial order, has an existing additive counterpart of less than or equal to, exhibits covariance with respect to addition and less than or equal to relation, and has subtraction and an ordered subtraction operation, if an element `c` in `α` is less than or equal to `b` and `c` is left-cancellable with respect to addition and order (meaning that addition of `c` on the left side preserves the order of elements), then for any element `a` in `α`, the expression `a + b - c` is equal to `a + (b - c)`. In other words, adding `b` to `a`, subtracting `c`, is the same as adding `a` to the result of `b - c`.

If `α` is an additive commutative semigroup with partial order, has an additive `≤`, exhibits covariance, and has subtraction and ordered subtraction, and `c ≤ b` and `c` is left-cancellative with respect to addition and `≤`, then `a + b - c = a + (b - c)` for all `a` in `α`.


theorem Function.minimalPeriod_prod_map :
    ∀ {α : Type u_1} {β : Type u_2} (f : α → α) (g : β → β) (x : α × β),
      Function.minimalPeriod (Prod.map f g) x = Nat.lcm (Function.minimalPeriod f x.1) (Function.minimalPeriod g x.2) :=
  by sorry

The theorem `Function.minimalPeriod_prod_map` states that for any two types `α` and `β`, an endomorphism `f` on `α`, an endomorphism `g` on `β`, and a point `x` which is a pair from `α` and `β`, the minimal period of the point `x` under the combined map `Prod.map f g` (which applies `f` to the first component of `x` and `g` to the second component) equals the least common multiple of the minimal period of the first component of `x` under `f` and the minimal period of the second component of `x` under `g`. In other words, the recurrence period of `x` under the composite action is the least common multiple of the individual recurrence periods under the actions of `f` and `g`.

The minimal period of a point under the product map of two endomorphisms is the least common multiple of their minimal periods applied to the respective components.


/-- See `zero_lt_four'` for a version with the type explicit.  -/
theorem zero_lt_four :
    ∀ {α : Type u_1} [inst : AddMonoidWithOne α] [inst_1 : PartialOrder α] [inst_2 : ZeroLEOneClass α]
      [inst_3 : NeZero 1] [inst_4 : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1], 0 < 4 :=
  by sorry

This theorem, named `zero_lt_four`, states that for any type `α` with the properties of an additive monoid with unity, a partial order, a class where zero is less than or equal to one, a non-zero unity, and a covariant class under addition and order, the number zero is less than four. The proof for this theorem is not provided here. The comment suggests to look at a version of this theorem where the type is made explicit, named `zero_lt_four'`.

For any additive monoid with unity, partial order, zero <= 1, non-zero unity, and covariant additive and order structure, zero is less than four.


theorem Mathlib.Data.Set.Pointwise.SMul._auxLemma.36 :
    ∀ {α : Type u_2} [inst : InvolutiveNeg α] {s : Set α}, -s = Neg.neg '' s := by sorry

This theorem states that for any type `α` that is equipped with an `InvolutiveNeg` structure (which is a structure that has a negation operation `neg` such that negating twice yields the original element), and for any set `s` of type `α`, the negation of the set `s` (denoted by `-s`) is equal to the image of the set `s` under the negation operation `Neg.neg` (denoted by `Neg.neg '' s`).

In mathematical terms, this theorem asserts that every element in the set `-s` is the negative of some element in the set `s`, and vice versa. Hence, the set `-s` is precisely the set of negatives of elements of `s`.

For any set `s` of a type `α` equipped with an `InvolutiveNeg` structure, `-s` = `Neg.neg '' s`, where `-s` denotes the negation of the set `s` and `Neg.neg '' s` is the image of `s` under the negation operation.


theorem Mathlib.Data.ENNReal.Basic._auxLemma.45 :
    ∀ {β : Type u_2} {ι : Sort u_4} (s : Set β) (t : ι → Set β), ⋃ i, s ∩ t i = s ∩ ⋃ i, t i := by sorry

This theorem states that for any type `β`, and for any type `ι`, if `s` is a set of `β` and `t` is a function from `ι` to a set of `β`, then the union over all `i` of the intersection of `s` and `t i` is equal to the intersection of `s` and the union over all `i` of `t i`. In mathematical terms, this theorem asserts that $\bigcup_{i} (s \cap t_i) = s \cap \bigcup_{i} t_i$. This is a property of the interactions between union and intersection operations in set theory.

For any types `β` and `ι`, and sets `s` of `β` and function `t` from `ι` to sets of `β`, the union of intersections of `s` with each `t(i)` equals the intersection of `s` with the union of all `t(i)`. Mathematically: $\bigcup\_{i} (s \cap t\_i) = s \cap \bigcup\_{i} t\_i$.


SimpleGraph.Dart.ext

theorem SimpleGraph.Dart.ext :
    ∀ {V : Type u_1} {G : SimpleGraph V} (d₁ d₂ : SimpleGraph.Dart G), d₁.toProd = d₂.toProd → d₁ = d₂ := by sorry

This theorem states that for any simple graph `G` with vertices of type `V`, if we have two 'darts' (directed edges) `d₁` and `d₂` such that their pair of vertices (obtained using `toProd`) are equal, then the two darts themselves are equal. In essence, two darts are considered identical if they are directed from the same vertex to another same vertex, regardless of their internal representation.

In a simple graph, two darts with equal source-target vertex pairs are equal.


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

This theorem is about the composition of morphisms in the context of a category theory. Specifically, it states that for any category `C` that has zero morphisms, and for any three short complexes `S₁`, `S₂`, and `S₃` in this category, if `φ₁` is a morphism from `S₁` to `S₂`, `φ₂` is a morphism from `S₂` to `S₃`, and `h₁`, `h₂`, `h₃` are left homology data for `S₁`, `S₂`, `S₃` respectively, then the cycle map of the composition of `φ₁` and `φ₂` from `h₁` to `h₃` is equal to the composition of the cycle map of `φ₁` from `h₁` to `h₂` and the cycle map of `φ₂` from `h₂` to `h₃`. This theorem is a fundamental property of morphisms in category theory which ensures the associative property of composition of morphisms.

In any category with zero morphisms, the cycle map of the composition of two morphisms is equal to the composition of their cycle maps.


theorem Function.Surjective.Prod_map :
    ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {δ : Type u_4} {f : α → γ} {g : β → δ},
      Function.Surjective f → Function.Surjective g → Function.Surjective (Prod.map f g) :=
  by sorry

The theorem `Function.Surjective.Prod_map` states that for any four types `α`, `β`, `γ` and `δ` and any two functions `f` from `α` to `γ` and `g` from `β` to `δ`, if `f` and `g` are both surjective functions, then the function `Prod.map f g`, which applies `f` to the first component and `g` to the second component of a pair (from type `α × β` to type `γ × δ`), is also surjective. In other words, for every pair in the codomain `γ × δ`, there exists a pair in the domain `α × β` such that applying the function `Prod.map f g` to the pair from the domain produces the pair from the codomain.

If `f` from `α` to `γ` and `g` from `β` to `δ` are surjective functions, then the function `Prod.map f g` from `α × β` to `γ × δ` is also surjective.


theorem Set.piecewise_eq_indicator :
    ∀ {α : Type u_1} {M : Type u_4} [inst : Zero M] {s : Set α} {f : α → M} [inst_1 : DecidablePred fun x => x ∈ s],
      Set.piecewise s f 0 = Set.indicator s f :=
  by sorry

This theorem states that for any type `α`, any type `M` equipped with a zero element, any set `s` of `α`, and any function `f` from `α` to `M`, the piecewise function on `s` that is equal to `f` on `s` and zero elsewhere is the same as the indicator function of `s` with respect to `f`. This holds if the predicate "an element belongs to `s`" is decidable. In mathematical terms, if `f : α → M` and `s` is a subset of `α`, then the function `s.piecewise f 0` equals the function `Set.indicator s f`, where `Set.indicator s f a` equals `f(a)` if `a` is in `s` and `0` otherwise.

For any type `α`, set `s` of `α` with decidable membership, and function `f : α → M`, the piecewise function `s.piecewise f 0` equals the indicator function `Set.indicator s f`.


theorem Turing.ListBlank.tail_map :
    ∀ {Γ : Type u_1} {Γ' : Type u_2} [inst : Inhabited Γ] [inst_1 : Inhabited Γ'] (f : Turing.PointedMap Γ Γ')
      (l : Turing.ListBlank Γ),
      Turing.ListBlank.tail (Turing.ListBlank.map f l) = Turing.ListBlank.map f (Turing.ListBlank.tail l) :=
  by sorry

The theorem `Turing.ListBlank.tail_map` states that for any types `Γ` and `Γ'` such that `Γ` and `Γ'` are inhabited, and for any pointed map `f` from `Γ` to `Γ'` and any list blank `l` of type `Γ`, the tail of the map of `f` on `l` is the same as the map of `f` on the tail of `l`. In other words, mapping a function over a list blank and then taking the tail is the same as taking the tail first and then mapping the function. This is a kind of commutativity property between the tail operation and the map operation on list blanks in the context of Turing machines.

For any type `Γ`, any inhabited types `Γ'`, any pointed map `f` from `Γ` to `Γ'`, and any list blank `l` of type `Γ`, the map of `f` on the tail of `l` is equal to the tail of the map of `f` on `l`.


theorem Polynomial.Monic.natDegree_mul' :
    ∀ {R : Type u} [inst : Semiring R] {p q : Polynomial R},
      Polynomial.Monic p → q ≠ 0 → Polynomial.natDegree (p * q) = Polynomial.natDegree p + Polynomial.natDegree q :=
  by sorry

The theorem `Polynomial.Monic.natDegree_mul'` states that for any type `R` that is a semiring, and for any two polynomials `p` and `q` over that semiring, if the polynomial `p` is monic (i.e., its leading coefficient is 1) and the polynomial `q` is not zero, then the natural degree (the degree forced to ℕ with the degree of 0 defined as 0) of the product of `p` and `q` is equal to the sum of the natural degrees of `p` and `q`. In mathematical terms, for monic `p` and non-zero `q`, we have $\deg(p*q) = \deg(p) + \deg(q)$.

For any monic polynomial `p` and non-zero polynomial `q` over a semiring, the natural degree of their product is equal to the sum of their natural degrees.


theorem Cardinal.beth_limit : ∀ {o : Ordinal.{u_1}}, Ordinal.IsLimit o → Cardinal.beth o = ⨆ a, Cardinal.beth ↑a := by
  sorry

The theorem `Cardinal.beth_limit` states that for any limit ordinal `o`, the beth number of `o` is the supremum of the beth numbers of all ordinals less than `o`. In other words, if `o` is a limit ordinal (an ordinal which is not zero and not a successor), then the beth number of `o` (denoted as `beth o`) is equal to the supremum (denoted as `⨆ a`) of the beth number of `a` for all `a` less than `o`. This is a characterization of beth numbers at limit ordinals in the context of the generalized continuum hypothesis.

For any limit ordinal `o`, the beth number `beth o` is the supremum of the beth numbers of all ordinals less than `o`.


theorem Module.free_iff_set :
    ∀ (R : Type u) (M : Type v) [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M],
      Module.Free R M ↔ ∃ S, Nonempty (Basis (↑S) R M) :=
  by sorry

This theorem states that for any type `R` which has a semiring structure, and any type `M` which has an additive commutative monoid structure and a module structure over `R`, the module `M` is free over `R` if and only if there exists a set `S` such that there is a nonempty basis for `M` over `R` indexed by the elements of `S`. In other words, a module `M` over a semiring `R` is free exactly when it has a basis indexed by a set.

A module M over a semiring R is free if and only if there exists a basis for M over R indexed by a set.


theorem Nat.one_le_two_pow : ∀ {n : ℕ}, 1 ≤ 2 ^ n := by sorry

This theorem states that for any non-negative integer `n`, the value of `1` is less than or equal to `2` raised to the power of `n`. This is because any power of `2` is always at least `1`, since `2` to the power of `0` is `1` and for `n > 0`, `2` to the power of `n` is always more than `1`.

For all non-negative integers n, 1 ≤ 2^n.


theorem Polynomial.hasseDeriv_apply :
    ∀ {R : Type u_1} [inst : Semiring R] (k : ℕ) (f : Polynomial R),
      (Polynomial.hasseDeriv k) f = Polynomial.sum f fun i r => (Polynomial.monomial (i - k)) (↑(Nat.choose i k) * r) :=
  by sorry

The theorem `Polynomial.hasseDeriv_apply` states that for any semiring `R`, any natural number `k`, and any polynomial `f` with coefficients in `R`, the `k`th Hasse derivative of `f` is equal to the sum of the terms `(Polynomial.monomial (i - k)) (↑(Nat.choose i k) * r)`, where `i` ranges over the degrees of the monomials in `f`, `r` is the coefficient of the `i`th monomial in `f`, and `Nat.choose i k` is the binomial coefficient "i choose k". In other words, the `k`th Hasse derivative of a polynomial is obtained by multiplying each coefficient of the polynomial by the binomial coefficient "i choose k", and subtracting `k` from the degree of the corresponding term.

The `k`th Hasse derivative of a polynomial `f` with coefficients in a semiring `R` is the sum of the terms `(i - k)! * r * x^(i)`, where `i` ranges over the degrees of the monomials in `f`, `r` is the coefficient of the `i`th monomial in `f`, and `x` is an indeterminate.


theorem Finset.prod_fiberwise_of_maps_to :
    ∀ {ι : Type u_6} {κ : Type u_7} {α : Type u_8} [inst : CommMonoid α] {s : Finset ι} {t : Finset κ}
      [inst_1 : DecidableEq κ] {g : ι → κ},
      (∀ i ∈ s, g i ∈ t) →
        ∀ (f : ι → α),
          (Finset.prod t fun j => Finset.prod (Finset.filter (fun i => g i = j) s) fun i => f i) =
            Finset.prod s fun i => f i :=
  by sorry

This theorem states that for any types `ι`, `κ` and `α`, where `α` is a commutative monoid, given two finite sets `s` of type `ι` and `t` of type `κ`, a decidable equality on `κ`, and a function `g` mapping from `ι` to `κ` which maps every element of `s` into `t`, then for any function `f` from `ι` to `α`, the product over `t` of the function `j` mapped to the product over the filtered set of `s` where `g i = j` of the function `i` mapped to `f i` is equal to the product over `s` of the function `i` mapped to `f i`. In other words, it says that the product of each `f i` over the `i` in `s` is equal to the product of the products of each `f i` for `i` in the fiber of `j` over all `j` in `t`. This is a form of the principle of distributivity of multiplication over addition.

Given finite sets `s` and `t`, a decidable equality on `t`, a commutative monoid `α`, a function `g` mapping `s` to `t`, and a function `f` mapping a type to `α`, the product of `f i` over `i` in `s` is equal to the product of the products of `f i` over `i` in the fibers of `g`.


theorem AlternatingMap.coeFn_smul :
    ∀ {R : Type u_1} [inst : Semiring R] {M : Type u_2} [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {N : Type u_3}
      [inst_3 : AddCommMonoid N] [inst_4 : Module R N] {ι : Type u_7} {S : Type u_10} [inst_5 : Monoid S]
      [inst_6 : DistribMulAction S N] [inst_7 : SMulCommClass R S N] (c : S) (f : M [⋀^ι]→ₗ[R] N), ⇑(c • f) = c • ⇑f :=
  by sorry

The theorem `AlternatingMap.coeFn_smul` states that for any semiring `R`, any type `M` with an additive commutative monoid structure and a module structure over `R`, any type `N` with an additive commutative monoid structure, a module structure over `R`, and a distributive multiplication action by a monoid `S`, and for any types `ι` and `S`, the result of applying a scalar multiplication by a scalar `c` from `S` to an alternating multilinear map `f` from `M` to `N` over `R` (denoted `c • f`) is the same as the result of applying `f` first and then multiplying the result by `c` (denoted `c • ⇑f`). This is, in essence, a statement about the compatibility of scalar multiplication with the action of an alternating multilinear map.

For any semirings R, types M with additive commutative monoid and R-module structures, and N with additive commutative monoid, R-module, and distributive S-module structures, and for any alternating multilinear map f from M to N over R, the scalar multiplication of f by a scalar c from S is equivalent to applying c to each input and then applying f.


theorem Mathlib.Probability.Moments._auxLemma.1 : (¬False) = True := by sorry

This theorem, named `_auxLemma.1` from the `Mathlib.Probability.Moments` module, states that the negation of `False` is `True` in Lean 4. This is a fundamental logical principle, corresponding to the fact that if something is not false (i.e., if it's not the case that something does not hold), then it is indeed true.

The negation of False is True. (In Lean 4 logical terms: �� /******/∃ h : False, ¬h) ≡ True. )


RingCon.add

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

This theorem, `RingCon.add`, states that for any ring `R` (signified by addition `Add` and multiplication `Mul` operations), and for any congruence relation `c` on `R`, if `c` relates `w` to `x` and `y` to `z`, then `c` also relates `(w + y)` to `(x + z)`. In other words, this congruence relation is preserved under the addition operation in the ring.

If `R` is a ring, `c` is a congruence relation on `R`, and `w ~ c x` and `y ~ c z`, then `w + y ~ c (x + z)`.


theorem completeSpace_iff_isComplete_univ :
    ∀ {α : Type u} [uniformSpace : UniformSpace α], CompleteSpace α ↔ IsComplete Set.univ := by sorry

The theorem `completeSpace_iff_isComplete_univ` states that for any type `α` that is equipped with a uniform space structure, `α` is a complete space if and only if the universal set of `α` is complete. In the context of this theorem, a set is complete if any Cauchy filter on the set has a limit within the set, and a space is complete if every Cauchy filter converges to a point within the space. The universal set of `α` is the set containing all elements of `α`. In essence, this theorem links the property of completeness of the whole space with the completeness of the universal set in that space.

A uniform space `α` is complete if and only if its universal set is complete.


theorem CategoryTheory.Adjunction.left_triangle :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂}
      [inst_1 : CategoryTheory.Category.{v₂, u₂} D] {F : CategoryTheory.Functor C D} {G : CategoryTheory.Functor D C}
      (adj : F ⊣ G),
      CategoryTheory.CategoryStruct.comp (CategoryTheory.whiskerRight adj.unit F)
          (CategoryTheory.whiskerLeft F adj.counit) =
        CategoryTheory.CategoryStruct.id (CategoryTheory.Functor.comp (CategoryTheory.Functor.id C) F) :=
  by sorry

This theorem is known as the "left triangle identity" for adjunctions in category theory. It states that for any two categories `C` and `D`, and for any two functors `F : C → D` and `G : D → C` forming an adjunction `F ⊣ G`, the composition of the morphism `adj.unit` whiskered on the right with `F` and the morphism `adj.counit` whiskered on the left with `F`, is equal to the identity morphism on the composition of the identity functor on `C` and the functor `F`. This is a fundamental property satisfied by all adjunctions in category theory.

For any adjunction `F ⊣ G` between categories `C` and `D`, the composition of `F(adj.unit)` and `G` is equal to the identity function on `F`. In Lean syntax: `(F ∘ adj.unit) = id_on_fc : ∀{C : Type u1} {D : Type u2} [Category C] [Category D] (F : C → D) (G : D → C) (adj : F ⊣ G), F (adj.unit X) = X`.


theorem MeasureTheory.Measure.count_apply_lt_top :
    ∀ {α : Type u_1} [inst : MeasurableSpace α] {s : Set α} [inst_1 : MeasurableSingletonClass α],
      ↑↑MeasureTheory.Measure.count s < ⊤ ↔ Set.Finite s :=
  by sorry

This theorem states that for any set `s` of a certain type `α` in a measurable space, the count measure (which assigns the cardinality of the set as its measure) is less than infinity if and only if the set `s` is finite. This is to say, the theorem establishes a connection between the finiteness of a set and its count measure being less than infinity. The `MeasurableSingletonClass α` is an assumption that ensures singletons of `α` are measurable, allowing the use of the counting measure.

For a set `s` of type `α` in a measurable space, the count measure of `s` is less than infinity if and only if `s` is finite. (Assuming `MeasurableSingletonClass α`)


theorem HasDerivAt.mul_const :
    ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {x : 𝕜} {𝔸 : Type u_2} [inst_1 : NormedRing 𝔸]
      [inst_2 : NormedAlgebra 𝕜 𝔸] {c : 𝕜 → 𝔸} {c' : 𝔸},
      HasDerivAt c c' x → ∀ (d : 𝔸), HasDerivAt (fun y => c y * d) (c' * d) x :=
  by sorry

This theorem states that if a function `c` has a derivative `c'` at a point `x` in a nontrivially normed field `𝕜`, then for any element `d` of a normed ring `𝔸`, which is also a normed algebra over `𝕜`, the function that maps `y` to `c y * d` has a derivative of `c' * d` at that point `x`. In other words, it is the rule for differentiation of a function multiplied by a constant, generalised to normed fields and normed algebras.

If `c` is differentiable at `x` in a nontrivially normed field `𝕜`, then the function `y ↦ c(y) * d` is differentiable at `x` in the normed algebra `𝔸` over `𝕜`, with derivative `c'(x) * d`.


theorem round_eq :
    ∀ {α : Type u_2} [inst : LinearOrderedField α] [inst_1 : FloorRing α] (x : α), round x = ⌊x + 1 / 2⌋ := by sorry

This theorem states that for any type `α` that is a linear ordered field and has a floor ring structure (which basically means that we can talk about the "floor" or "greatest integer less than or equal to" operation for elements of type `α`), the rounding operation for any element `x` of type `α` can be expressed as the floor of `x` plus 1/2. In other words, to round a number `x` to the nearest integer, you can instead add 1/2 to `x` and then take the floor of the result.

For any linear ordered field `α` with a floor ring structure, the rounding operation on `α` equals the floor function followed by adding one-half.


/-- In the characteristic zero case, the weights in the centroid sum
to 1 if the number of points is not zero.  -/
theorem Finset.sum_centroidWeights_eq_one_of_card_ne_zero :
    ∀ (k : Type u_1) [inst : DivisionRing k] {ι : Type u_4} (s : Finset ι) [inst_1 : CharZero k],
      s.card ≠ 0 → (Finset.sum s fun i => Finset.centroidWeights k s i) = 1 :=
  by sorry

The theorem `Finset.sum_centroidWeights_eq_one_of_card_ne_zero` states that in the characteristic zero case (this is the scenario where zero cannot be represented as a finite sum of units), the sum of the weights in the centroid equals to 1, if the number of points is non-zero. Here the centroid is calculated for a finite set 's' of elements of some type 'ι' in a division ring 'k'. The weights of the centroid are defined as the reciprocal of the cardinality (number of elements) of the set 's'. The sum is taken over all elements 'i' of the set 's'. This theorem essentially establishes a key property of centroids, that the sum of the weights of all the points contributing to the centroid equals to 1, provided that the set of points is not empty.

In characteristic zero, the sum of the reciprocal cardinalities of a non-empty finite set's elements equals 1 for the centroid weights.


theorem CategoryTheory.Functor.IsCoverDense.Types.appHom_restrict :
    ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_6, u_1} C] {D : Type u_2}
      [inst_1 : CategoryTheory.Category.{u_5, u_2} D] {K : CategoryTheory.GrothendieckTopology D}
      {G : CategoryTheory.Functor C D} [inst_2 : CategoryTheory.Functor.IsCoverDense G K]
      [inst_3 : CategoryTheory.Full G] {ℱ : CategoryTheory.Functor Dᵒᵖ (Type v)} {ℱ' : CategoryTheory.SheafOfTypes K}
      (α : CategoryTheory.Functor.comp G.op ℱ ⟶ CategoryTheory.Functor.comp G.op ℱ'.val) {X : D} {Y : C}
      (f : Opposite.op X ⟶ Opposite.op (G.obj Y)) (x : ℱ.obj (Opposite.op X)),
      ℱ'.val.map f (CategoryTheory.Functor.IsCoverDense.Types.appHom α X x) = α.app (Opposite.op Y) (ℱ.map f x) :=
  by sorry

This theorem states that given a category `C` and another category `D`, with a functor `G` from `C` to `D`, a Grothendieck topology `K` on `D`, and the functor `G` is cover-dense with respect to `K`. Further, if `G` is full and we have two functors `ℱ` and `ℱ'` from `Dᵒᵖ` to `Type v` and `ℱ'` is a sheaf of types with respect to `K`, respectively. Then, for a natural transformation `α` from the composite functor `G.op` and `ℱ` to the composite functor `G.op` and `ℱ'.val`, an object `X` in `D`, an object `Y` in `C`, a morphism `f` from the opposite of `X` to the opposite of `G.obj Y` in `C`, and an object `x` in `ℱ.obj` of the opposite of `X`, the assertion is that mapping `f` under `ℱ'.val` on the result of applying `α` with `X` and `x` using `appHom` of `CategoryTheory.Functor.IsCoverDense.Types` equals applying `α.app` with the opposite of `Y` on the result of mapping `f` under `ℱ` on `x`.

Given a cover-dense functor `G` from category `C` to `D` with respect to a Grothendieck topology `K` on `D`, if `ℱ'` is a sheaf of types over `D` with respect to `K` and `α` is a natural transformation from `G.op ∘ ℱ` to `G.op ∘ ℱ'`, then for any object `X` in `D`, any object `Y` in `C`, any morphism `f` from `X` to `G.obj Y` in `D`, and any `x` in `ℱ.obj` over `X`, `α.val.app (f, x) = ℱ'.val.app (G.map f, ℱ.val.app f x)`.


theorem Finset.fold_cons :
    ∀ {α : Type u_1} {β : Type u_2} {op : β → β → β} [hc : Std.Commutative op] [ha : Std.Associative op] {f : α → β}
      {b : β} {s : Finset α} {a : α} (h : a ∉ s),
      Finset.fold op b f (Finset.cons a s h) = op (f a) (Finset.fold op b f s) :=
  by sorry

The theorem `Finset.fold_cons` states that for any types `α` and `β`, any commutative and associative operation `op` on `β`, any function `f` from `α` to `β`, any base element `b` of type `β`, any finite set `s` of elements of type `α`, and any element `a` of type `α` not in `s`, applying the `Finset.fold` operation to the set obtained by adding `a` to `s` (i.e., `Finset.cons a s h`) is the same as applying the operation `op` to `f(a)` and the result of folding `op` over `s`. In mathematical terms, it means if we have a set `{a} ∪ s` and we fold an operation over this set, it's the same as applying the operation to `f(a)` and the result of folding the operation over the original set `s`.

For any commutative and associative operation `op` on type `β`, function `f` from `α` to `β`, base element `b` of type `β`, finite set `s` of elements of type `α`, and element `a` of type `α` not in `s`, we have `Finset.fold op (Finset.cons a s h) f b = op (f a) (Finset.fold op s f b)`.


theorem CategoryTheory.ShortComplex.Exact.g_desc :
    ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_3, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
      {S : CategoryTheory.ShortComplex C} [inst_2 : CategoryTheory.Balanced C]
      (hS : CategoryTheory.ShortComplex.Exact S) {A : C} (k : S.X₂ ⟶ A)
      (hk : CategoryTheory.CategoryStruct.comp S.f k = 0) [inst_3 : CategoryTheory.Epi S.g],
      CategoryTheory.CategoryStruct.comp S.g (CategoryTheory.ShortComplex.Exact.desc hS k hk) = k :=
  by sorry

The theorem `CategoryTheory.ShortComplex.Exact.g_desc` states that for any category `C` which is preadditive and balanced, and any exact short complex `S` in this category, given an object `A` in `C` and a morphism `k` from `S.X₂` to `A` such that the composition of `S.f` and `k` is the zero morphism, if `S.g` is an epimorphism, then the composition of `S.g` and the description map of `S` with respect to `k` is equal to `k`. This theorem essentially describes a property of exact sequences in the context of category theory, specifically for short complexes.

For any preadditive and balanced category `C`, exact short complex `S`, object `A` in `C`, and morphism `k` from `S.X₂` to `A` with `S.f ∘ k = 0` and `S.g` an epimorphism, `S.g ∘ S.desc(k) = k`.


/-- In a weakly locally compact space,
every compact set is contained in the interior of a compact set.  -/
theorem exists_compact_superset :
    ∀ {X : Type u_1} [inst : TopologicalSpace X] [inst_1 : WeaklyLocallyCompactSpace X] {K : Set X},
      IsCompact K → ∃ K', IsCompact K' ∧ K ⊆ interior K' :=
  by sorry

In the mathematical field of topology, this theorem states that in a weakly locally compact space, any compact set is contained within the interior of another compact set. Specifically, for any compact set `K` in a topological space `X` that also has the property of being a weakly locally compact space, there exists another compact set `K'` such that `K` is a subset of the interior of `K'`. Here, the 'interior' of a set refers to the largest open subset of that set. The 'compactness' of a set is a property indicating that for any nontrivial filter containing the set, there exists a point in the set where all sets of the filter meet all neighborhoods of that point. A 'weakly locally compact space' is a specific type of topological space.

In a weakly locally compact space, every compact set is contained in the interior of another compact set.


theorem ppow_add :
    ∀ {M : Type u_1} [inst : Mul M] [inst_1 : Pow M ℕ+] [inst_2 : PNatPowAssoc M] (k n : ℕ+) (x : M),
      x ^ (k + n) = x ^ k * x ^ n :=
  by sorry

This theorem, `ppow_add`, states that for any type `M` that supports multiplication and exponentiation by positive natural numbers, and for which this exponentiation operation is associative, raising a value `x` of this type to the power of the sum of two positive natural numbers `k` and `n` is the same as raising `x` to the power `k`, multiplying the result by `x` raised to the power `n`. This is analogous to the exponent addition rule in basic algebra, where `x^(a+b) = x^a * x^b`.

For any type `M` with associative exponentiation by natural numbers, `x^(k + n) = x^k * x^n`.


theorem Real.arcsin_of_one_le : ∀ {x : ℝ}, 1 ≤ x → Real.arcsin x = Real.pi / 2 := by sorry

The theorem `Real.arcsin_of_one_le` states that for all real numbers `x`, if `x` is greater than or equal to 1, then the inverse of the sine function of `x`, also known as `arcsin(x)`, is equal to π/2. This means `arcsin(x)` defaults to π/2 for `x` in the interval [1, ∞).

For all real numbers `x` with `x ≥ 1`, `arcsin x = π/2`.


theorem Rat.mkRat_zero : ∀ (n : ℤ), mkRat n 0 = 0 := by sorry

This theorem states that for every integer `n`, when we create a rational number with `n` as the numerator and `0` as the denominator using the `mkRat` function, we will always get `0`. This is consistent with the definition of `mkRat`, which ensures that when the denominator is zero, the function returns zero, regardless of the value of the numerator.

For every integer `n`, the rational number `mkRat n 0` equals `0`.


theorem Finset.subset_insert_iff :
    ∀ {α : Type u_1} [inst : DecidableEq α] {a : α} {s t : Finset α}, s ⊆ insert a t ↔ Finset.erase s a ⊆ t := by sorry

This theorem states that for any type `α` with decidable equality, given an element `a` of type `α`, and two finite sets `s` and `t` of the same type, the set `s` is a subset of the set obtained by inserting `a` into `t` if and only if the set obtained by erasing `a` from `s` is a subset of `t`. This theorem essentially relates the operations of inserting an element into a set and erasing an element from a set with the concept of subset inclusion.

For any type `α` with decidable equality, and sets `s` and `t` of type `α`, `s ⊆ t` if and only if `s \ {a} ⊆ t` for all `a` in `α`.


theorem zsmul_strictMono_right :
    ∀ (α : Type u_1) [inst : OrderedAddCommGroup α] {n : ℤ}, 0 < n → StrictMono fun x => n • x := by sorry

The theorem `zsmul_strictMono_right` states that for any type `α` that is an ordered additive commutative group, and for any integer `n` greater than zero, the function that scales elements of `α` by `n` is strictly monotonic. In other words, if `a` and `b` are elements of `α` and `a < b`, then `n` times `a` is less than `n` times `b`.

For any ordered additive commutative group type `α` and integer `n` > 0, the multiplication by `n` function on `α` is strictly monotonic. That is, if `a < b` in `α`, then `n*a < n*b`.


theorem Zsqrtd.ext_iff : ∀ {d : ℤ} (x y : ℤ√d), x = y ↔ x.re = y.re ∧ x.im = y.im := by sorry

This theorem states that for any integer `d` and for any two Zsqrtd objects `x` and `y`, `x` and `y` are equal if and only if the real part (`re`) and the imaginary part (`im`) of `x` are equal to the real and imaginary parts of `y`, respectively. In other words, two complex numbers with integer coefficients (also referred to as Gaussian integers) are equal if their corresponding real and imaginary components are equal.

Two Zsqrtd objects `x` and `y` with integer coefficients are equal if and only if their real parts `re x` and `re y` are equal and their imaginary parts `im x` and `im y` are equal.


theorem Set.MapsTo.mono_left :
    ∀ {α : Type u_1} {β : Type u_2} {s₁ s₂ : Set α} {t : Set β} {f : α → β},
      Set.MapsTo f s₁ t → s₂ ⊆ s₁ → Set.MapsTo f s₂ t :=
  by sorry

The theorem `Set.MapsTo.mono_left` states that for any types α and β, any two sets `s₁` and `s₂` of α, a set `t` of β, and a function `f` from α to β, if `f` maps every element in `s₁` to `t` (denoted as `Set.MapsTo f s₁ t`) and `s₂` is a subset of `s₁` (denoted as `s₂ ⊆ s₁`), then `f` also maps every element in `s₂` to `t` (denoted as `Set.MapsTo f s₂ t`). In essence, it says if a function maps a larger set to another set, then it also maps any subset of that larger set to the same target set.

If a function maps every element of a set to another set, and the smaller set is a subset of the larger set, then the function maps every element of the smaller set to the same image in the larger set.


theorem instCoeTCSupBotHom.proof_1 :
    ∀ {F : Type u_3} {α : Type u_2} {β : Type u_1} [inst : FunLike F α β] [inst_1 : Sup α] [inst_2 : Sup β]
      [inst_3 : Bot α] [inst_4 : Bot β] [inst_5 : SupBotHomClass F α β] (f : F) (a b : α), f (a ⊔ b) = f a ⊔ f b :=
  by sorry

This theorem, `instCoeTCSupBotHom.proof_1`, states that for any types `F`, `α`, and `β`, if `F` is function-like from `α` to `β`, `α` and `β` both have supremum (`Sup`) and bottom element (`Bot`), and `F` respects these structures (that is, `F` is a `SupBotHomClass`), then for any function `f` of type `F` and any elements `a` and `b` of type `α`, the supremum of `f(a)` and `f(b)` is equal to `f` applied to the supremum of `a` and `b`. This means that the function `f` preserves the supremum operation and the bottom element. This property is a key characteristic of a function in a `SupBotHomClass`.

For any function-like type `F` from types `α` and `β` with supremum and bottom elements, if `F` respects these structures, then for all `a, b ∈ α` and `f : F`, `Sup(f(a), f(b)) = f(Sup(a, b))`.


theorem instCoeTCSupBotHom.proof_2 :
    ∀ {F : Type u_3} {α : Type u_2} {β : Type u_1} [inst : FunLike F α β] [inst_1 : Sup α] [inst_2 : Sup β]
      [inst_3 : Bot α] [inst_4 : Bot β] [inst_5 : SupBotHomClass F α β] (f : F), f ⊥ = ⊥ :=
  by sorry

The theorem `instCoeTCSupBotHom.proof_2` states that for any types `F`, `α`, and `β`, where `F` is a function-like structure from `α` to `β`, `α` and `β` have supremum (`Sup`) and bottom (`Bot`) elements, and `F` is a homomorphism preserving supremum and bottom (`SupBotHomClass`), then for any function `f : F`, the image of the bottom element of `α` under `f` equals the bottom element of `β`. In other words, `f` maps the bottom element of `α` to the bottom element of `β`.

For any function-like structure `F` from type `α` to type `β`, where `α` and `β` have supremum and bottom elements, and `F` is a homomorphism preserving supremum and bottom, the image of the bottom element of `α` under any function `f : F` equals the bottom element of `β`.


theorem monotone_nhdsSet : ∀ {X : Type u_1} [inst : TopologicalSpace X], Monotone nhdsSet := by sorry

The theorem `monotone_nhdsSet` states that for any type `X` that comes equipped with a topological space structure, the function `nhdsSet`, which assigns to each set in `X` the filter of its neighborhoods, is monotone. In other words, if we have two sets `A` and `B` in `X` such that `A` is a subset of `B`, then the filter of neighborhoods of `A` is a subset of the filter of neighborhoods of `B`. This is a key property in the study of topological spaces, reflecting the intuitive idea that larger sets have more or "larger" neighborhoods.

The `nhdsSet` function on a topological space `X`, which maps each set to the filter of its neighborhoods, is monotone with respect to set inclusion.


theorem eVariationOn.edist_le :
    ∀ {α : Type u_1} [inst : LinearOrder α] {E : Type u_2} [inst_1 : PseudoEMetricSpace E] (f : α → E) {s : Set α}
      {x y : α}, x ∈ s → y ∈ s → edist (f x) (f y) ≤ eVariationOn f s :=
  by sorry

The theorem `eVariationOn.edist_le` states that for any types `α` and `E` where `α` is a linear order and `E` is a pseudo emetric space, for any function `f` from `α` to `E` and any set `s` of type `α`, the extended distance between `f(x)` and `f(y)` is less than or equal to the extended variation of function `f` on set `s`, given that `x` and `y` are elements of set `s`. In mathematical terms, if $x, y \in s$, then $edist(f(x), f(y)) \leq eVariationOn(f, s)$.

For any linear order type `α`, pseudo metric space `E`, function `f` from `α` to `E`, and set `s` of type `α`, the extended distance between `f(x)` and `f(y)` for any `x, y` in `s` is less than or equal to the extended variation of `f` on `s`. In symbols: $\forall x, y \in s, edist(f(x), f(y)) \leq eVariationOn(f, s)$.


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

This theorem states that for any type `α` with a linear order, given four elements `a₁`, `a₂`, `b₁`, and `b₂` of this type, the intersection of the interval `(a₁, b₁]` and the interval `(a₂, b₂]` is the interval `(max{a₁, a₂}, min{b₁, b₂}]`. Here, `(a, b]` denotes the set of elements `x` such that `a < x` and `x ≤ b`. The notation `a₁ ⊔ a₂` represents the maximum of `a₁` and `a₂`, and `b₁ ⊓ b₂` represents the minimum of `b₁` and `b₂`.

For any type `α` with a linear order, the intersection of the intervals `(a₁, b₁]` and `(a₂, b₂]` is equal to `(max{a₁, a₂}, min{b₁, b₂}]`.


Order.Ideal.ext

theorem Order.Ideal.ext : ∀ {P : Type u_1} [inst : LE P] {s t : Order.Ideal P}, ↑s = ↑t → s = t := by sorry

This theorem, named "Order.Ideal.ext", states that for any type `P` equipped with a less than or equal to ordering relation, if we have two order ideals `s` and `t` of `P`, and their coerced values are equal, then `s` and `t` themselves must be equal. This is essentially saying that two order ideals are equal if and only if their coerced or 'underlying set' representations are equal. The proof of this theorem is not provided here ("by sorry").

If `s` and `t` are order ideals of a type `P` with an ordering relation, then `s = t` if and only if the coerced values of `s` and `t` are equal.


SimpleGraph.ConnectedComponent.eq

theorem SimpleGraph.ConnectedComponent.eq :
    ∀ {V : Type u} {G : SimpleGraph V} {v w : V},
      SimpleGraph.connectedComponentMk G v = SimpleGraph.connectedComponentMk G w ↔ SimpleGraph.Reachable G v w :=
  by sorry

The theorem `SimpleGraph.ConnectedComponent.eq` states that for any given simple graph `G` of vertices of type `V`, and any two vertices `v` and `w` of that graph, the connected component containing vertex `v` is the same as the connected component containing vertex `w` if and only if `v` and `w` are reachable from each other. In other words, there exists a walk in the graph `G` from vertex `v` to vertex `w`.

Two vertices `v` and `w` of a simple graph `G` belong to the same connected component if and only if they are reachable from each other.


/-- Given a 2-morphism between `f` and `g` in the free bicategory, we have the equality
`normalizeAux p f = normalizeAux p g`.
 -/
theorem CategoryTheory.FreeBicategory.normalizeAux_congr :
    ∀ {B : Type u} [inst : Quiver B] {a b c : B} (p : Quiver.Path a b) {f g : CategoryTheory.FreeBicategory.Hom b c},
      (f ⟶ g) → CategoryTheory.FreeBicategory.normalizeAux p f = CategoryTheory.FreeBicategory.normalizeAux p g :=
  by sorry

This theorem states that in the free bicategory, given a 2-morphism between two 1-morphisms `f` and `g` from objects `b` to `c`, the result of applying the function `normalizeAux` to `p` and `f` is equal to the result of applying `normalizeAux` to `p` and `g`. Here, `p` represents a path in the underlying quiver from object `a` to `b`, `B` is a type equipped with a quiver structure, and the free bicategory is constructed from this quiver.

In the free bicategory constructed from a quiver, the normalization of a path with respect to a 1-morphism `f` from object `b` to `c` is equal to the normalization of the same path with respect to another 1-morphism `g` if and only if `f` and `g` are equivalent as 1-morphisms.


theorem dist_vadd_left :
    ∀ {V : Type u_2} {P : Type u_3} [inst : SeminormedAddCommGroup V] [inst_1 : PseudoMetricSpace P]
      [inst_2 : NormedAddTorsor V P] (v : V) (x : P), dist (v +ᵥ x) x = ‖v‖ :=
  by sorry

This theorem, `dist_vadd_left`, states that for any vector `v` and point `x`, where `V` is a seminormed add commutative group and `P` is a pseudometric space with `V` acting on `P` in a normed add torsor fashion, the distance between the translated point `v +ᵥ x` and the original point `x` is equal to the norm of the vector `v`. In other words, the distance function behaves as expected when translating a point along a vector in a vector space with a norm and pseudometric.

For any vector `v` in a seminormed add commutative group `V` and point `x` in a pseudometric space `P` with `V` acting on `P` as a normed add torsor, the distance between `x` and `v +_× x` is equal to the norm of `v`.


Computable.decode

theorem Computable.decode : ∀ {α : Type u_1} [inst : Primcodable α], Computable Encodable.decode := by sorry

This theorem states that for any type `α` that has a `Primcodable` instance (which means, intuitively, that values of type `α` can be encoded as natural numbers), the function `Encodable.decode` is computable. The `Encodable.decode` function is a decoding function that takes a natural number and returns an optional `α`, i.e., it may fail to return an `α`. In the theorem, `Computable` is a predicate over functions that, roughly speaking, says that there exists an algorithm that computes the function. Therefore, the theorem states that there exists an algorithm that computes the `Encodable.decode` function for any primcodable type.

For any type `α` with a `Primcodable` instance, the decoding function `Encodable.decode` from natural numbers to optional `α` values is computable.


IsIrreducible.nonempty

theorem IsIrreducible.nonempty :
    ∀ {X : Type u_1} [inst : TopologicalSpace X] {s : Set X}, IsIrreducible s → Set.Nonempty s := by sorry

The theorem `IsIrreducible.nonempty` states that for any type `X` equipped with a topological space structure, and any set `s` of type `X`, if the set `s` is irreducible, then `s` is nonempty. In other words, there cannot exist an irreducible set that is empty. This means an irreducible set, by definition, must contain at least one element.

An irreducible subset of a topological space is nonempty.


theorem finsum_cond_eq_sum_of_cond_iff :
    ∀ {α : Type u_1} {M : Type u_5} [inst : AddCommMonoid M] (f : α → M) {p : α → Prop} {t : Finset α},
      (∀ {x : α}, f x ≠ 0 → (p x ↔ x ∈ t)) → (finsum fun i => finsum fun x => f i) = Finset.sum t fun i => f i :=
  by sorry

This theorem states that, for any types `α` and `M` where `M` is an additive commutative monoid, and for any function `f` from `α` to `M`, a predicate `p` on `α`, and a finite set `t` of `α`, if for all `x` from `α`, `f(x)` is not zero implies that `p(x)` is true if and only if `x` is in `t`, then the sum of `f(i)` for `i` ranging over all elements in the support of `f` is equal to the sum of `f(i)` for `i` ranging over all elements of `t`. This sum is calculated using the `finsum` function for the left side and the `Finset.sum` function for the right side.

For any additive commutative monoid M, function f from type α to M, predicate p on α, and finite set t of α, if for all x in α, f(x) is non-zero implies p(x) holds if and only if x is in t, then the sum of f(x) for x in the support of f is equal to the sum of f(x) for x in t.


theorem Polynomial.monic_X_pow : ∀ {R : Type u} [inst : Semiring R] (n : ℕ), Polynomial.Monic (Polynomial.X ^ n) := by
  sorry

The theorem `Polynomial.monic_X_pow` states that for any semiring `R` and for any natural number `n`, the polynomial obtained by raising the polynomial variable `X` to the power `n` is monic. In other words, the leading coefficient of the polynomial `X^n` is 1. A semiring is a type `R` that satisfies certain algebraic properties, including the presence of two binary operations (typically addition and multiplication).

For any semiring R and natural number n, the polynomial X^n is monic (has a leading coefficient of 1).


/-- In a commutative ring, make `simp` prefer leaving the order unchanged.  -/
theorem star_mul' :
    ∀ {R : Type u} [inst : CommSemigroup R] [inst_1 : StarMul R] (x y : R), star (x * y) = star x * star y := by sorry

This theorem states that in a commutative ring with a star operation, the star of the product of two elements is equal to the product of the stars of those elements. In more mathematical terms, given a commutative semigroup `R` with a star operation `star`, for any two elements `x` and `y` in `R`, the operation `star (x * y)` is equivalent to `star x * star y`. This essentially means that the order of operations doesn't matter - you can either multiply the two elements first and then apply the star operation, or you can apply the star operation to each element first and then multiply the results. This property is used to make `simp` prefer leaving the order unchanged in Lean's simplification process.

In a commutative semigroup equipped with a star operation, the star of the product of any two elements equals the product of their stars.


theorem Mathlib.Data.Nat.Parity._auxLemma.10 : Even 1 = False := by sorry

This theorem states that the number 1 is not even. In the context of the definitions provided, an even number is defined as a number `a` that can be expressed as `a = r + r`, for some `r`. The theorem asserts that no such `r` exists for `a = 1`, i.e., 1 cannot be expressed as the sum of two identical numbers.

The theorem asserts that 1 cannot be expressed as the sum of two identical numbers, making it an odd number in the given definition of even and odd numbers.


theorem Measurable.ennreal_ofReal :
    ∀ {α : Type u_1} [inst : MeasurableSpace α] {f : α → ℝ}, Measurable f → Measurable fun x => ENNReal.ofReal (f x) :=
  by sorry

The theorem `Measurable.ennreal_ofReal` states that for any type `α` that has a `MeasurableSpace` instance and any function `f` from `α` to the real numbers `ℝ`, if `f` is a measurable function, then the function that applies `ENNReal.ofReal` to the output of `f` (that is, the function `x => ENNReal.ofReal (f x)`) is also measurable. In other words, the operation of converting the output of a measurable function to its equivalent in extended non-negative real numbers (`ENNReal.ofReal`) preserves measurability.

If `α` is a measurable space and `f : α → ℝ` is a measurable function, then the function `x => ENNReal.ofReal (f x)` is measurable.


theorem MeasureTheory.OuterMeasure.exists_measurable_superset_eq_trim :
    ∀ {α : Type u_1} [inst : MeasurableSpace α] (m : MeasureTheory.OuterMeasure α) (s : Set α),
      ∃ t, s ⊆ t ∧ MeasurableSet t ∧ ↑m t = ↑(MeasureTheory.OuterMeasure.trim m) s :=
  by sorry

This theorem states that for any type `α` equipped with a structure `MeasurableSpace α`, for any outer measure `m` on `α`, and for any set `s` of type `α`, there exists a measurable superset `t` of `s` such that the measure of `t` with respect to the outer measure `m` is equal to the measure of `s` with respect to the trimmed outer measure of `m`. In other words, it's possible to find a measurable superset of any given set that retains the same measure as the original set when we consider the trimmed version of the outer measure.

For any measurable space `(α, Σ, m)`, given a set `s ∈ Σ`, there exists a measurable set `t ⊇ s` with `m(t) = m^{*}(s)`, where `m^{*}` denotes the trimmed outer measure of `m`.


theorem CategoryTheory.Pretriangulated.TriangleMorphism.ext :
    ∀ {C : Type u} {inst : CategoryTheory.Category.{v, u} C} {inst_1 : CategoryTheory.HasShift C ℤ}
      {T₁ T₂ : CategoryTheory.Pretriangulated.Triangle C} (x y : CategoryTheory.Pretriangulated.TriangleMorphism T₁ T₂),
      x.hom₁ = y.hom₁ → x.hom₂ = y.hom₂ → x.hom₃ = y.hom₃ → x = y :=
  by sorry

The theorem `CategoryTheory.Pretriangulated.TriangleMorphism.ext` states that for any given category `C` of type `u`, which has a shift in the integers, and any two Pretriangulated Triangles `T₁` and `T₂` in `C`, any two morphisms `x` and `y` from `T₁` to `T₂` are equal if and only if their corresponding components, `hom₁`, `hom₂`, and `hom₃`, are also equal.

given two Pretriangulated Triangles `T₁` and `T₂` in a category `C` with shift and any morphisms `x : hom₁(T₁) (T₂[1])` and `y : hom₂(T₁) (T₂)`, `x = y` if and only if `hom₃(T₁) (T₂[1])(i) = hom₂(T₁[1]) (T₂) (i)` for all objects `i` in `C`.