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

This theorem states that for any given measurable space `α` and a function `f` from `α` to the extended nonnegative real numbers (usually denoted [0, ∞]), if `f` is a measurable function, then the function which maps each element of `α` to the real part of its image under `f` is also measurable. In other words, the operation of taking the real part preserves measurability in this context.

If `f` is a measurable function from a measurable space `α` to the extended nonnegative real numbers, then the function mapping each element of `α` to the real part of its image under `f` is also measurable.


theorem MeasureTheory.integral_exp_pos :
    ∀ {α : Type u_1} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} {f : α → ℝ} [hμ : NeZero μ],
      MeasureTheory.Integrable (fun x => Real.exp (f x)) μ → 0 < ∫ (x : α), Real.exp (f x) ∂μ :=
  by sorry

The theorem `MeasureTheory.integral_exp_pos` states that for any measurable space `α`, measure `μ` on that space, and function `f` from `α` to real numbers, assuming `μ` is not a zero measure, if the function `exp(f(x))` is integrable with respect to measure `μ`, then the integral of `exp(f(x))` with respect to `μ` is always strictly greater than zero. In other words, the integral of the exponential of a function over a non-zero measure space is always positive if that exponential function is integrable.

If `μ` is a non-zero measure on measurable space `α` and `exp(∫(f(x) dμ(x)))` is integrable with respect to `μ`, then `∫(exp(f(x)) dμ(x)) > 0`.


theorem CategoryTheory.Limits.Cotrident.app_one :
    ∀ {J : Type w} {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} {f : J → (X ⟶ Y)}
      (s : CategoryTheory.Limits.Cotrident f) (j : J),
      CategoryTheory.CategoryStruct.comp (f j) (s.ι.app CategoryTheory.Limits.WalkingParallelFamily.one) =
        s.ι.app CategoryTheory.Limits.WalkingParallelFamily.zero :=
  by sorry

The theorem `CategoryTheory.Limits.Cotrident.app_one` states that for any category `C` with objects `X` and `Y`, and any function `f` from some type `J` to the set of morphisms from `X` to `Y`, if we have a cotrident `s` on `f`, then for any element `j` of `J`, the composition of the morphism `f j` and the morphism from the tip of the cotrident to the object corresponding to `one` in the walking parallel family is equal to the morphism from the tip of the cotrident to the object corresponding to `zero` in the walking parallel family. In category theory, this principle is often referred to as the universal property of cotridents.

For any category C, given a cotrident s on a function f from type J to the morphisms from X to Y in C, for all j in J, we have f j ∘ s.top = s.top\_0, where s.top is the morphism from the tip of the cotrident to an object in C corresponding to one, and s.top\_0 is the morphism from the tip to an object corresponding to zero in the walking parallel family.


theorem Int.ModEq.of_mul_left : ∀ {n a b : ℤ} (m : ℤ), a ≡ b [ZMOD m * n] → a ≡ b [ZMOD n] := by sorry

This theorem states that for all integer numbers `n`, `a`, `b`, and `m`, if `a` is congruent to `b` modulo `m*n` (written as `a ≡ b [ZMOD m * n]`), then `a` is also congruent to `b` modulo `n` (written as `a ≡ b [ZMOD n]`). The congruence modulo is a relation that says that the numbers leave the same remainder when divided by the modulus.

If `a` is congruent to `b` modulo `m*n`, then `a` is congruent to `b` modulo `n`. In other words, `(a ≡ b [ZMOD m * n])` implies `(a ≡ b [ZMOD n])` in the integers modulo `zmod`.


theorem TensorPower.gradedMonoid_eq_of_cast :
    ∀ {R : Type u_1} {M : Type u_2} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
      {a b : GradedMonoid fun n => PiTensorProduct R fun x => M} (h : a.fst = b.fst),
      (TensorPower.cast R M h) a.snd = b.snd → a = b :=
  by sorry

The theorem `TensorPower.gradedMonoid_eq_of_cast` states that for any commutative semiring `R` and any additive commutative monoid `M` that is also an `R`-module, if we have two elements `a` and `b` of a graded monoid (which is defined as a sigma type over a family of types indexed by some type `ι`), where each element of the graded monoid is a Pi tensor product for a given `n`, then if the first elements (`fst`) of `a` and `b` are equal, and if the second elements (`snd`) of `a` and `b` are related by a certain `TensorPower.cast`, then `a` and `b` are equal. The `TensorPower.cast` is a function that casts between "equal" tensor powers, according to some proof of equality `h`, which is given as a parameter to the function.

Given a commutative semiring `R`, an additive commutative monoid `M` that is an `R`-module, and elements `a` and `b` of their corresponding graded monoids with equal first components, if the second components of `a` and `b` are related by `TensorPower.cast` with some proof `h`, then `a` and `b` are equal.


theorem MeasureTheory.ProbabilityMeasure.coeFn_comp_toFiniteMeasure_eq_coeFn :
    ∀ {Ω : Type u_1} [inst : MeasurableSpace Ω] (ν : MeasureTheory.ProbabilityMeasure Ω),
      (fun s => (↑↑↑(MeasureTheory.ProbabilityMeasure.toFiniteMeasure ν) s).toNNReal) = fun s => (↑↑↑ν s).toNNReal :=
  by sorry

This theorem states that, for any given probability measure "ν" on a measure space "Ω", the measure of any set "s" under the composition of the function that converts "ν" into a finite measure and the function that converts the measure value into a non-negative real number, is equal to the measure of "s" under the original probability measure "ν" converted into a non-negative real number. In other words, converting a probability measure into a finite measure does not change its measure values when those values are represented as non-negative real numbers.

For any probability measure ν and set s in a measurable space, the conversion of ν to a finite measure and then to a non-negative real number equals the conversion of ν directly to a non-negative real number for the measure of s.


theorem CategoryTheory.ShortComplex.rightHomologyMap'_add :
    ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
      {S₁ S₂ : CategoryTheory.ShortComplex C} {φ φ' : S₁ ⟶ S₂} (h₁ : CategoryTheory.ShortComplex.RightHomologyData S₁)
      (h₂ : CategoryTheory.ShortComplex.RightHomologyData S₂),
      CategoryTheory.ShortComplex.rightHomologyMap' (φ + φ') h₁ h₂ =
        CategoryTheory.ShortComplex.rightHomologyMap' φ h₁ h₂ +
          CategoryTheory.ShortComplex.rightHomologyMap' φ' h₁ h₂ :=
  by sorry

This theorem states that in a given category `C` that is preadditive (i.e., has the structure of an abelian group on its hom-sets), for any two short complexes `S₁` and `S₂` and any two morphisms `φ` and `φ'` from `S₁` to `S₂`, the right homology map of the sum of `φ` and `φ'` is equal to the sum of the right homology maps of `φ` and `φ'`. In simple terms, the right homology map preserves the addition operation on the morphisms. This property is fundamental in the study of homological algebra where we are interested in the algebraic invariants of complex morphisms.

In a preadditive category, the right homology map commutes with addition of morphisms.


theorem Polynomial.zero_comp : ∀ {R : Type u} [inst : Semiring R] {p : Polynomial R}, Polynomial.comp 0 p = 0 := by
  sorry

This theorem states that for any semiring `R` and any polynomial `p` over `R`, the composition of the zero polynomial with `p` results in the zero polynomial. In other words, if we substitute `p` into the zero polynomial, we get back the zero polynomial. This is like saying that applying any function to zero gives us zero, but in the context of polynomial composition.

For any semiring `R` and polynomial `p` over `R`, the zero polynomial composed with `p` equals the zero polynomial.


theorem Cardinal.power_lt_aleph0 :
    ∀ {a b : Cardinal.{u_1}}, a < Cardinal.aleph0 → b < Cardinal.aleph0 → a ^ b < Cardinal.aleph0 := by sorry

The theorem `Cardinal.power_lt_aleph0` states that for any two cardinal numbers `a` and `b`, if both `a` and `b` are less than `ℵ₀` (the smallest infinite cardinal), then `a` to the power `b` is also less than `ℵ₀`. In other words, raising one cardinal number that is less than `ℵ₀` to the power of another cardinal number that is also less than `ℵ₀` results in a cardinal number that is still less than `ℵ₀`.

For any cardinal numbers `a` and `b` less than `ℵ₀`, `a^b` is also less than `ℵ₀`.


theorem toIcoDiv_add_zsmul :
    ∀ {α : Type u_1} [inst : LinearOrderedAddCommGroup α] [hα : Archimedean α] {p : α} (hp : 0 < p) (a b : α) (m : ℤ),
      toIcoDiv hp a (b + m • p) = toIcoDiv hp a b + m :=
  by sorry

The theorem `toIcoDiv_add_zsmul` states that for any type `α` that has a structure of a linearly ordered additive commutative group and satisfies the Archimedean property, for any positive element `p` of `α`, and for any other two elements `a` and `b` of `α` and an integer `m`, the unique integer `toIcoDiv hp a (b + m • p)` obtained by subtracting `m` times `p` added to `b` from the multiple of `p` that lies in the interval from `a` to `a + p`, is equal to the unique integer `toIcoDiv hp a b` obtained by subtracting `b` from the multiple of `p` that lies in the interval from `a` to `a + p`, plus `m`. This essentially captures the translational invariance property of the division operation in the context of additive groups.

For any type `α` with a linearly ordered additive commutative group structure and the Archimedean property, the integer obtained by dividing `b + m • p` by `p` in the interval `[a, a + p]` is equal to the integer obtained by dividing `a` by `p` and adding `m`, where `p` is positive, `a` and `b` are in `α`, and `m` is an integer.


theorem nhds_translation_mul_inv :
    ∀ {G : Type w} [inst : TopologicalSpace G] [inst_1 : Group G] [inst_2 : TopologicalGroup G] (x : G),
      Filter.comap (fun x_1 => x_1 * x⁻¹) (nhds 1) = nhds x :=
  by sorry

This theorem is about topological groups, which are groups that also have a topological structure compatible with the group operations. The theorem states that for every element `x` of a topological group `G`, the preimage under the function `(fun x_1 => x_1 * x⁻¹)` of the neighborhood filter of the group's identity element `1` is equal to the neighborhood filter of `x` itself. In other words, multiplying each element of the neighborhood of the identity by `x` and taking the inverse gives us the neighborhood of `x`.

For every topological group G and element x in G, the preimage under the function x ↦ x\_1 \* x^(-1) of the neighborhood filter of G's identity element 1 is equal to the neighborhood filter of x.


theorem Int.bit_negSucc : ∀ (b : Bool) (n : ℕ), Int.bit b (Int.negSucc n) = Int.negSucc (Nat.bit (!b) n) := by sorry

The theorem `Int.bit_negSucc` states that for all boolean `b` and natural number `n`, appending the bit `b` to the binary representation of the integer `Int.negSucc n` results in the same integer as appending the bit `!b` (the negation of `b`) to the binary representation of the natural number `n` and then taking `Int.negSucc` of the result. In other words, it relates the binary representation of negative integers with the binary representation of natural numbers considering the bit negation operation.

For all natural numbers `n` and booleans `b`, `Int.negSucc (bit_not b) ^ Int.toBin (n : Int) = Int.negSucc (Int.toBin (b ^ n))`, where `^` denotes concatenation and `Int.toBin` converts an integer to its binary representation as a string.


theorem AddCircle.continuous_mk' :
    ∀ {𝕜 : Type u_1} [inst : LinearOrderedAddCommGroup 𝕜] [inst_1 : TopologicalSpace 𝕜] (p : 𝕜),
      Continuous ⇑(QuotientAddGroup.mk' (AddSubgroup.zmultiples p)) :=
  by sorry

This theorem, named `AddCircle.continuous_mk'`, states that for any given type `𝕜` which is a linearly ordered additive commutative group with a topological space structure, the additive group homomorphism from `𝕜` to the quotient group `𝕜/p𝕜` (where `p𝕜` is the subgroup generated by an element `p`) is continuous. Here, continuity is defined in the topological sense. This theorem basically links group theory and topology, asserting the continuity property of the mapping from a group to its quotient group with respect to a particular subgroup.

The additive group homomorphism from a linearly ordered additive commutative group equipped with a topology to its quotient group by a subgroup is continuous.


theorem MeasureTheory.SimpleFunc.coe_pow :
    ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] [inst_1 : Monoid β] (f : MeasureTheory.SimpleFunc α β)
      (n : ℕ), ↑(f ^ n) = ↑f ^ n :=
  by sorry

This theorem states that for any measurable space `α` and any monoid `β`, for a given simple function `f` from `α` to `β` and a natural number `n`, the coercion of the nth power of `f` (`f ^ n`) is equal to the nth power of the coercion of `f` (`↑f ^ n`). Here, a simple function refers to a Measure Theory concept, where the function only takes on a finite number of values.

For any measurable space `α`, monoid `β`, simple function `f` from `α` to `β`, and natural number `n`, `(↑f ^ n) = ↑(f ^ n)`.


theorem Polynomial.Chebyshev.T_add_two :
    ∀ (R : Type u_1) [inst : CommRing R] (n : ℕ),
      Polynomial.Chebyshev.T R (n + 2) =
        2 * Polynomial.X * Polynomial.Chebyshev.T R (n + 1) - Polynomial.Chebyshev.T R n :=
  by sorry

The theorem `Polynomial.Chebyshev.T_add_two` states that for any commutative ring `R` and any natural number `n`, the `(n + 2)`-th Chebyshev polynomial of the first kind can be calculated from the `(n + 1)`-th and `n`-th Chebyshev polynomials. More precisely, it is twice the polynomial variable times the `(n + 1)`-th Chebyshev polynomial minus the `n`-th Chebyshev polynomial. This is a recursive definition of Chebyshev polynomials, a sequence of orthogonal polynomials which often arise in numerical analysis and approximation theory.

For any commutative ring R and natural number n, the (n + 2)-th Chebyshev polynomial of the first kind is given recursively as T_(n+2)(x) = 2x*T_(n+1)(x) - T\_n(x).


expNegInvGlue.nonneg

/-- The function `expNegInvGlue` is nonnegative.  -/
theorem expNegInvGlue.nonneg : ∀ (x : ℝ), 0 ≤ expNegInvGlue x := by sorry

The theorem `expNegInvGlue.nonneg` states that the function `expNegInvGlue` is nonnegative for all real numbers. In other words, for every real number `x`, the value of `expNegInvGlue` at `x` is always greater than or equal to zero. This affirms that the function `expNegInvGlue`, which equals `exp(-1/x)` for `x > 0` and `0` for `x ≤ 0`, will never yield a negative result.

The theorem `expNegInvGlue.nonneg` asserts that the function `expNegInvGlue` is non-negative for all real numbers, i.e., `expNegInvGlue x ≥ 0` for every `x` in ℝ.


/-- Let `r` be a well-founded relation on `α`, let `f : α → β` be a function,
let `C : β → Prop`, and let `bot : α`.
This induction principle shows that `C (f bot)` holds, given that
* some `a` satisfies `C (f a)`, and
* for each `b` such that `f b ≠ f bot` and `C (f b)` holds, there is `c`
  satisfying `r c b` and `C (f c)`.  -/
theorem WellFounded.induction_bot' :
    ∀ {α : Sort u_4} {β : Sort u_5} {r : α → α → Prop},
      WellFounded r →
        ∀ {a bot : α} {C : β → Prop} {f : α → β},
          (∀ (b : α), f b ≠ f bot → C (f b) → ∃ c, r c b ∧ C (f c)) → C (f a) → C (f bot) :=
  by sorry

This theorem, `WellFounded.induction_bot'`, is an induction principle for well-founded relations. Given a well-founded relation `r` on a type `α`, a function `f` from `α` to another type `β`, a property `C` defined on `β`, and two elements `a` and `bot` of `α`, the theorem asserts that if the property `C` holds for `f(a)`, and for every `b` in `α` such that `f(b)` is not equal to `f(bot)` and `C(f(b))` holds, there exists a `c` such that `r(c, b)` holds and `C(f(c))` holds, then it must also be the case that `C(f(bot))` holds.

If `r` is a well-founded relation on type `α`, `f: α -> β`, `C: β -> Prop`, `a, bot ∈ α`, and for all `b ≠ bot`, `C(f(b))` implies the existence of a `c` with `r(c, b)` and `C(f(c))`, then `C(f(bot))` holds.


theorem Fin.castSucc_pred_eq_pred_castSucc :
    ∀ {n : ℕ} {a : Fin (n + 1)} (ha : a ≠ 0) (ha' : optParam (Fin.castSucc a ≠ 0) ⋯),
      Fin.castSucc (Fin.pred a ha) = Fin.pred (Fin.castSucc a) ha' :=
  by sorry

This theorem, `Fin.castSucc_pred_eq_pred_castSucc`, states that for any natural number `n` and any `a` which is a non-zero element of `Fin (n + 1)`, the operation of first taking the predecessor of `a` and then embedding the result in `Fin (n + 2)` using `Fin.castSucc` is equivalent to the operation of first embedding `a` in `Fin (n + 2)` using `Fin.castSucc` and then taking its predecessor. The second argument of the `Fin.pred` function is a proof that the input is non-zero, and in this case these proofs are represented by `ha` for `a` and `ha'` for `Fin.castSucc a`. The `optParam` is used to provide a default proof for `ha'` in case it is not supplied.

For any natural number `n` and non-zero `a` in `Fin (n + 1)`, `Fin.pred (Fin.castSucc a)` is equivalent to `Fin.castSucc (Fin.pred a)`.


IsMinFilter.sup

theorem IsMinFilter.sup :
    ∀ {α : Type u} {β : Type v} [inst : SemilatticeSup β] {f g : α → β} {a : α} {l : Filter α},
      IsMinFilter f l a → IsMinFilter g l a → IsMinFilter (fun x => f x ⊔ g x) l a :=
  by sorry

The theorem `IsMinFilter.sup` states that for any types `α` and `β`, where `β` is a semilattice, and any two functions `f` and `g` from `α` to `β`, and any element `a` of type `α` and any filter `l` on `α`, if `a` is a minimal point of both `f` and `g` with respect to `l` (meaning that for all `x` in some `l`-neighborhood of `a`, `f a` and `g a` are less than or equal to `f x` and `g x` respectively), then `a` is also a minimal point of the function that takes `x` to the sup (least upper bound) of `f x` and `g x` with respect to `l`. In other words, if `a` minimizes both `f` and `g` in some neighborhood defined by `l`, it also minimizes the combined function where each value is the maximum of the corresponding values in `f` and `g`.

For any functions `f` and `g` from a type `α` to a semilattice `β`, and any filter `l` on `α`, if an element `a` in `α` is minimal with respect to both `f` and `g` in the neighborhood defined by `l`, then it is also minimal with respect to the function that maps `x` to the sup of `f x` and `g x`.


theorem StrictMonoOn.Iic_id_le :
    ∀ {α : Type u_1} [inst : PartialOrder α] [inst_1 : SuccOrder α] [inst_2 : IsSuccArchimedean α] [inst_3 : OrderBot α]
      {n : α} {φ : α → α}, StrictMonoOn φ (Set.Iic n) → ∀ m ≤ n, m ≤ φ m :=
  by sorry

The theorem `StrictMonoOn.Iic_id_le` states that for any type `α` that has a partial order, a successor order, is succ-archimedean, and has a bottom element, and for any function `φ` that is strictly monotone on the left-infinite, right-closed interval (`Set.Iic`) up to a given value `n`, then for any `m` that is less than or equal to `n`, `m` is always less than or equal to `φ(m)`. In simpler terms, for any number `m` up to `n`, applying the function `φ` will either increase `m` or leave it the same, but never decrease it.

For any strictly monotone function `φ` on the left-infinite, right-closed interval of a succ-archimedean type with bottom element, `m` is less than or equal to `φ(m)` for all `m` less than or equal to the given value `n`.


theorem Seminorm.continuous_from_bounded :
    ∀ {𝕝 : Type u_3} {𝕝₂ : Type u_4} {E : Type u_5} {F : Type u_6} {ι : Type u_8} {ι' : Type u_9}
      [inst : AddCommGroup E] [inst_1 : NormedField 𝕝] [inst_2 : Module 𝕝 E] [inst_3 : AddCommGroup F]
      [inst_4 : NormedField 𝕝₂] [inst_5 : Module 𝕝₂ F] {τ₁₂ : 𝕝 →+* 𝕝₂} [inst_6 : RingHomIsometric τ₁₂]
      [inst_7 : Nonempty ι] [inst_8 : Nonempty ι'] {p : SeminormFamily 𝕝 E ι} {q : SeminormFamily 𝕝₂ F ι'}
      {x : TopologicalSpace E},
      WithSeminorms p →
        ∀ {x_1 : TopologicalSpace F},
          WithSeminorms q → ∀ (f : E →ₛₗ[τ₁₂] F), Seminorm.IsBounded p q f → Continuous ⇑f :=
  by sorry

This theorem, `Seminorm.continuous_from_bounded`, states that for all types `𝕝`, `𝕝₂`, `E`, `F`, `ι`, `ι'` where `E` and `F` are additive commutative groups, `𝕝` and `𝕝₂` are normed fields, `E` and `F` are modules over `𝕝` and `𝕝₂` respectively, there is a ring homomorphism `τ₁₂` from `𝕝` to `𝕝₂` which is isometric, and `ι` and `ι'` are nonempty. Given a seminorm family `p` on `𝕝` and `E` indexed by `ι`, and a seminorm family `q` on `𝕝₂` and `F` indexed by `ι'`, if `E` and `F` are topological spaces equipped with the seminorms `p` and `q` respectively, then for any continuous linear map `f` from `E` to `F` (in the sense of seminorms) that is bounded with respect to the seminorm families `p` and `q`, `f` is also a continuous function in the topological sense.

Given normed fields `𝕝` and `𝕝₂`, additive commutative groups `E` and `F`, modules over `𝕝` and `𝕝₂` respectively, a ring homomorphism `τ₁₂` from `𝕝` to `𝕝₂` that is isometric, and seminorm families `p` on `E` and `q` on `F`, if `E`, `F`, `f` (a continuous linear map), and `p`, `q` satisfy the stated conditions, then `f` is a continuous function from `(E, p)` to `(F, q)`.


theorem EReal.neg_le_neg_iff : ∀ {a b : EReal}, -a ≤ -b ↔ b ≤ a := by sorry

This theorem, `EReal.neg_le_neg_iff`, states that for every pair of elements `a` and `b` of the type `EReal` (which represents the extended real numbers, including positive and negative infinity), the negation of `a` is less than or equal to the negation of `b` if and only if `b` is less than or equal to `a`. This is a statement of the property of order reversal under negation for extended real numbers.

For all `a` and `b` in `EReal`, `-a <= -b` if and only if `b <= a`.


/-- Given a MonoidHom `f : M →* N` and Submonoid `S ⊆ M` such that `f(S) ⊆ Nˣ`, for all
`w, z : N` and `y ∈ S`, we have `z = w * (f y)⁻¹ ↔ z * f y = w`.  -/
theorem Submonoid.LocalizationMap.mul_inv_right :
    ∀ {M : Type u_1} [inst : CommMonoid M] {S : Submonoid M} {N : Type u_2} [inst_1 : CommMonoid N] {f : M →* N}
      (h : ∀ (y : ↥S), IsUnit (f ↑y)) (y : ↥S) (w z : N),
      z = w * ↑((IsUnit.liftRight (MonoidHom.restrict f S) h) y)⁻¹ ↔ z * f ↑y = w :=
  by sorry

This theorem describes a property of homomorphisms between monoids in the context of localization of a monoid at a submonoid. Given a monoid homomorphism `f` from a monoid `M` to another monoid `N`, and a submonoid `S` of `M` such that the image of `S` under `f` lies in the group of units of `N`, the theorem states that for any elements `w` and `z` of `N` and any element `y` of `S`, the equation `z = w * (f(y))⁻¹` is equivalent to `z * f(y) = w`. Here, `(f(y))⁻¹` refers to the multiplicative inverse of `f(y)` in the monoid `N`. This property can be useful in the study of localizations in algebra, where we often consider the relation between elements of a ring and its localization.

Given a monoid homomorphism `f` from a monoid `M` to another monoid `N` with `S` a submonoid of `M` such that `f(S)` lies in the group of units of `N`, the equation `z * f(y) = w` is equivalent to `z = w * f(y)⁻¹` for any `w, z ∈ N` and `y ∈ S`.


theorem compare_gt_iff_gt : ∀ {α : Type u} [inst : LinearOrder α] {a b : α}, compare a b = Ordering.gt ↔ a > b := by
  sorry

This theorem states that for any type `α` that has a linear order, given two instances `a` and `b` of this type, the comparison function `compare` will return `Ordering.gt` if and only if `a` is strictly greater than `b`. In other words, it establishes a connection between the result of the `compare` function and the strict inequality relation in a linearly ordered type.

For any linearly ordered type `α`, `compare a b = Ordering.gt` if and only if `a` is strictly greater than `b`.


theorem Set.empty_ne_univ : ∀ {α : Type u} [inst : Nonempty α], ∅ ≠ Set.univ := by sorry

This theorem states that for any non-empty type `α`, the empty set is not equal to the universal set. In other words, for all types `α` that have at least one element, the set that contains no elements (`∅`) is not the same as the set that contains all elements of `α` (`Set.univ`).

For any non-empty type `α`, the empty set `∅` is a proper subset of the universal set `Set.univ`.


/-- In a finite measure space, assume that any open set can be approximated from inside by closed
sets. Then the measure is weakly regular.  -/
theorem MeasureTheory.Measure.InnerRegularWRT.weaklyRegular_of_finite :
    ∀ {α : Type u_1} [inst : MeasurableSpace α] [inst_1 : TopologicalSpace α] [inst_2 : BorelSpace α]
      (μ : MeasureTheory.Measure α) [inst_3 : MeasureTheory.IsFiniteMeasure μ],
      MeasureTheory.Measure.InnerRegularWRT μ IsClosed IsOpen → MeasureTheory.Measure.WeaklyRegular μ :=
  by sorry

In a finite measure space, under the assumptions that the space is both a Measurable and a Topological space, as well as a Borel space, this theorem states that if it's possible to approximate any open set from inside using closed sets, then the given measure is weakly regular. This is expressed formally as: for all sets of a certain type `α`, if the measure `μ` is such that it is inner regular with respect to closed and open sets, then `μ` is weakly regular.

In a finite measure space that is both measurable and topological, and a Borel space, if the measure is inner regular with respect to closed and open sets, then it is weakly regular.


theorem Mathlib.Algebra.Homology.ShortComplex.PreservesHomology._auxLemma.2 :
    ∀ {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.CategoryStruct.comp (CategoryTheory.ShortComplex.leftHomologyMap' φ₁ h₁ h₂)
          (CategoryTheory.ShortComplex.leftHomologyMap' φ₂ h₂ h₃) =
        CategoryTheory.ShortComplex.leftHomologyMap' (CategoryTheory.CategoryStruct.comp φ₁ φ₂) h₁ h₃ :=
  by sorry

The theorem `Mathlib.Algebra.Homology.ShortComplex.PreservesHomology._auxLemma.2` asserts that for any category `C` with zero morphisms, and any three short complexes `S₁`, `S₂`, and `S₃` in `C`, if `φ₁` is a morphism from `S₁` to `S₂`, `φ₂` is a morphism from `S₂` to `S₃`, and `h₁`, `h₂`, and `h₃` are the left homology data of `S₁`, `S₂`, and `S₃` respectively, then the composition of the left homology maps induced by `φ₁` and `φ₂` is equal to the left homology map induced by the composition of `φ₁` and `φ₂`. In other words, the left homology maps respect the composition operation of the category.

The theorem asserts that the left homology maps induced by composable morphisms between short complexes in a category with zero morphisms are equal.


/-- Compact-open topology on `C(α, β)` agrees with the topology of uniform convergence on compacts:
a family of continuous functions `F i` tends to `f` in the compact-open topology
if and only if the `F i` tends to `f` uniformly on all compact sets.  -/
theorem ContinuousMap.tendsto_iff_forall_compact_tendstoUniformlyOn :
    ∀ {α : Type u₁} {β : Type u₂} [inst : TopologicalSpace α] [inst_1 : UniformSpace β] {ι : Type u₃} {p : Filter ι}
      {F : ι → C(α, β)} {f : C(α, β)},
      Filter.Tendsto F p (nhds f) ↔ ∀ (K : Set α), IsCompact K → TendstoUniformlyOn (fun i a => (F i) a) (⇑f) p K :=
  by sorry

The theorem states that for any types `α`, `β`, and `ι`, given a topological space on `α`, a uniform space on `β`, a filter `p` on `ι`, a family of continuous functions `F` from `ι` to the continuous maps from `α` to `β`, and a continuous map `f` from `α` to `β`, the family of functions `F` tends to `f` in the compact-open topology if and only if for all compact sets `K` in `α`, the sequence of functions `F i` tends uniformly on `K` towards the function represented by `f`. In other words, the compact-open topology on the space of continuous functions from `α` to `β` agrees with the topology of uniform convergence on compact sets.

The compact-open topology on the space of continuous functions from `α` to `β` coincides with the topology of uniform convergence on compact sets.


theorem infClosed_sInter :
    ∀ {α : Type u_2} [inst : SemilatticeInf α] {S : Set (Set α)}, (∀ s ∈ S, InfClosed s) → InfClosed (⋂₀ S) := by sorry

The theorem `infClosed_sInter` states that for any type `α` that forms a semilattice under an infimum operation, and any collection `S` of sets of elements of `α`, if every set in `S` is inf-closed (i.e., the infimum of any two elements in the set is also in the set), then the intersection of all sets in `S` is also inf-closed. In mathematical terms, if `S` is a collection of inf-closed sets in a semilattice `α`, then the infimum of any two elements in the intersection of sets in `S` is also in that intersection.

If `α` is a semilattice with infimum and every set in the collection `S` of inf-closed sets is in `α`, then the infimum of any two elements in the intersection of sets in `S` belongs to that intersection.


theorem Option.eq_none_iff_forall_not_mem : ∀ {α : Type u_1} {o : Option α}, o = none ↔ ∀ (a : α), a ∉ o := by sorry

This theorem states that for any type `α` and any option `o` of type `Option α`, `o` is equal to `none` if and only if for every element `a` of type `α`, `a` is not an element of `o`. In other words, an option is `none` if it does not contain any elements of the type it is supposed to hold.

For any type `α` and `Option α` value `o`, `o` is equal to `none` if and only if `o` has no elements of type `α`.


TendstoLocallyUniformlyOn.continuousOn

/-- A locally uniform limit on a set of functions which are continuous on this set is itself
continuous on this set.  -/
theorem TendstoLocallyUniformlyOn.continuousOn :
    ∀ {α : Type u} {β : Type v} {ι : Type x} [inst : UniformSpace β] {F : ι → α → β} {f : α → β} {s : Set α}
      {p : Filter ι} [inst_1 : TopologicalSpace α],
      TendstoLocallyUniformlyOn F f p s →
        (∀ᶠ (n : ι) in p, ContinuousOn (F n) s) → ∀ [inst_2 : Filter.NeBot p], ContinuousOn f s :=
  by sorry

This theorem states that if we have a sequence of functions `F : ι → α → β` that tends locally uniformly to a function `f : α → β` on a set `s : Set α` with respect to a filter `p : Filter ι`, and if almost every function `F n` in this sequence is continuous on the set `s` for `n` in the filter `p`, then the limit function `f` is continuous on the set `s`, assuming the filter `p` is not bottom. The spaces `α` and `β` are endowed with a topological structure, and `β` is also a uniform space.

If a sequence of continuous functions `F : ι → α → β` uniformly converges on a set `s : Set α` to a function `f : α → β` with respect to a non-bottom filter `p : Filter ι`, then `f` is continuous on `s`.


theorem pairwise_disjoint_on_bool :
    ∀ {α : Type u_1} [inst : SemilatticeInf α] [inst_1 : OrderBot α] {a b : α},
      Pairwise (Disjoint on fun c => bif c then a else b) ↔ Disjoint a b :=
  by sorry

This theorem states that for any type `α` that is a semilattice with infimum and has a bottom element, and for any two elements `a` and `b` of type `α`, the pairwise disjointness of a function that maps Boolean values to `a` and `b` (i.e., the function returns `a` for `true` and `b` for `false`) is equivalent to `a` and `b` being disjoint. The function being pairwise disjoint means that for any two different Boolean values, the mapped elements are disjoint, and `a` and `b` being disjoint means that any element of `α` that is less than or equal to both `a` and `b` is also less than or equal to the bottom element of `α`.

For any semilattice with infimum and bottom element α, two elements a and b are disjoint if and only if the function mapping true to a and false to b is pairwise disjoint.


theorem summable_geometric_two : Summable fun n => (1 / 2) ^ n := by sorry

The theorem `summable_geometric_two` states that the infinite geometric series where each term is `(1 / 2) ^ n` for a given n, is summable. In other words, it asserts that the sum of the terms `(1 / 2) ^ n` for all non-negative integers n, exists. The `Summable` function in Lean 4 is used to determine whether a given series or sequence has a finite sum, and this theorem proves that the given geometric series indeed has a finite sum.

The theorem `summable_geometric_two` in Lean 4 asserts that the infinite geometric series with common ratio `1/2` is convergent.


theorem AddSubmonoid.mem_multiples : ∀ {M : Type u_1} [inst : AddMonoid M] (n : M), n ∈ AddSubmonoid.multiples n := by
  sorry

This theorem states that for any type `M` which has an additive monoid structure, any element `n` of `M` belongs to the additive submonoid generated by `n` itself. In other words, an element is always a member of the set formed by multiplying it by the integers.

For any additive monoid `M` and element `n` in `M`, `n` belongs to the additive submonoid generated by `n`.


theorem LieSubmodule.mem_top :
    ∀ {R : Type u} {L : Type v} {M : Type w} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : AddCommGroup M]
      [inst_3 : Module R M] [inst_4 : LieRingModule L M] (x : M), x ∈ ⊤ :=
  by sorry

This theorem states that for any given types R, L, and M, where R is a commutative ring, L is a Lie ring, M is an additive commutative group, M is also an R-module, and M is an L-Lie ring module, any element x of type M belongs to the top or universal Lie submodule. This is a restatement of the universal property of the "top" (universal) element in the lattice structure of submodules, which says that every element of the parent module is contained in this top submodule.

For any commutative ring R, Lie ring L, additive commutative group M being an R-module and an L-Lie ring module, every element of M belongs to the top (universal) Lie submodule of M as an L-Lie submodule.


theorem le_dimH_of_hausdorffMeasure_eq_top :
    ∀ {X : Type u_2} [inst : EMetricSpace X] [inst_1 : MeasurableSpace X] [inst_2 : BorelSpace X] {s : Set X}
      {d : NNReal}, ↑↑(MeasureTheory.Measure.hausdorffMeasure ↑d) s = ⊤ → ↑d ≤ dimH s :=
  by sorry

The theorem `le_dimH_of_hausdorffMeasure_eq_top` states that for any type `X` equipped with an `EMetricSpace`, `MeasurableSpace`, and `BorelSpace` structure, any set `s` of `X`, and nonnegative real number `d`, if the Hausdorff measure of `s` with the exponent equal to `d` is infinite (denoted by `⊤`), then the Hausdorff dimension of `s` is greater than or equal to `d`. The Hausdorff dimension here is defined as the supremum of all `d` for which the `d`-dimensional Hausdorff measure of the set is infinite. Hence, the theorem essentially says that if a set has infinite `d`-dimensional Hausdorff measure, it must have Hausdorff dimension at least `d`.

If the Hausdorff measure of a set in an EMetricSpace with respect to a given exponent is infinite, then its Hausdorff dimension is greater than or equal to that exponent.


theorem StarConvex.is_linear_image :
    ∀ {𝕜 : Type u_1} {E : Type u_2} {F : Type u_3} [inst : OrderedSemiring 𝕜] [inst_1 : AddCommMonoid E]
      [inst_2 : AddCommMonoid F] [inst_3 : Module 𝕜 E] [inst_4 : Module 𝕜 F] {x : E} {s : Set E},
      StarConvex 𝕜 x s → ∀ {f : E → F}, IsLinearMap 𝕜 f → StarConvex 𝕜 (f x) (f '' s) :=
  by sorry

The theorem `StarConvex.is_linear_image` states that for any ordered semiring `𝕜`, types `E` and `F`, additive commutative monoids over `E` and `F`, modules over `𝕜` for `E` and `F`, a fixed point `x` in `E` and a set `s` in `E`, if the set `s` is star-convex at `x`, then for any linear map `f` from `E` to `F`, the image of the set `s` under `f` is star-convex at the image of `x` under `f`. In simpler terms, the image of a star-convex set under a linear map is also star-convex. The star-convexity is preserved under a linear transformation.

For any ordered semiring 𝕜, additive commutative monoids E and F, modules over 𝕜 for E and F, and linear map f from E to F, if a set s in E is star-convex at x in E, then the image of s under f is star-convex at the image of x under f.


theorem Polynomial.zero_divByMonic : ∀ {R : Type u} [inst : Ring R] (p : Polynomial R), 0 /ₘ p = 0 := by sorry

This theorem states that for all types `R`, which are instances of the Ring structure, and any polynomial `p` of `R`, the division of the zero polynomial by `p` is equal to the zero polynomial. In other words, it's stating that dividing zero by any polynomial yields zero, in the context of polynomial rings.

For all rings R and polynomials p in R, 0 / p = 0.


/-- If `P : ℤ → Prop` is a predicate such that the set `{m : P m}` is bounded above and nonempty,
then this set has the greatest element. This lemma uses classical logic to avoid assumption
`[DecidablePred P]`. See `Int.greatestOfBdd` for a constructive counterpart.  -/
theorem Int.exists_greatest_of_bdd :
    ∀ {P : ℤ → Prop}, (∃ b, ∀ (z : ℤ), P z → z ≤ b) → (∃ z, P z) → ∃ ub, P ub ∧ ∀ (z : ℤ), P z → z ≤ ub := by sorry

This theorem states that if we have a predicate `P : ℤ → Prop` such that the set of integers, `{m : P m}`, that satisfy this predicate is bounded above and nonempty, then this set has a greatest element, denoted as `ub`. That is, there exists an integer `ub` such that `P ub` and for any integer `z` that satisfies `P`, `z` is less than or equal to `ub`. This theorem uses classical logic and does not require the predicate `P` to be decidable. There is a constructive counterpart to this theorem, `Int.greatestOfBdd`, which does require decidability of `P`.

If `P : ℤ → Prop` is a nonempty, bounded above predicate on integers, then it has a greatest element.


theorem WittVector.one_coeff_eq_of_pos :
    ∀ (p : ℕ) (R : Type u_1) [hp : Fact (Nat.Prime p)] [inst : CommRing R] (n : ℕ), 0 < n → 1.coeff n = 0 := by sorry

The theorem `WittVector.one_coeff_eq_of_pos` states that for any natural number `p`, any type `R` with a commutative ring structure, and any natural number `n` where `n > 0` and `p` is a prime number, the `n-th` coefficient of the number `1` in the Witt vector ring over `R` with respect to the prime `p`, is `0`. Hence, apart from the zeroth coefficient, all other coefficients of `1` in the Witt vector representation are `0`.

For any prime number `p` and natural number `n > 0` in a commutative ring `R`, the `n-th` coefficient of `1` in its Witt vector representation is `0`.


theorem spectrum.mem_resolventSet_of_norm_lt_mul :
    ∀ {𝕜 : Type u_1} {A : Type u_2} [inst : NormedField 𝕜] [inst_1 : NormedRing A] [inst_2 : NormedAlgebra 𝕜 A]
      [inst_3 : CompleteSpace A] {a : A} {k : 𝕜}, ‖a‖ * ‖1‖ < ‖k‖ → k ∈ resolventSet 𝕜 a :=
  by sorry

The theorem `spectrum.mem_resolventSet_of_norm_lt_mul` states that for any normed field `𝕜`, normed ring `A`, normed algebra over `𝕜` on `A`, and `A` being a complete space, given an element `a` from `A` and an element `k` from `𝕜`, if the norm of `a` multiplied by the norm of `1` is less than the norm of `k`, then `k` belongs to the resolvent set of `a` with respect to `𝕜`. In other words, `k` is a scalar in `𝕜` such that `k•1 - a` is a unit in the algebra `A`.

If `𝕜` is a normed field, `A` is a normed ring and algebra over `𝕜` that is complete, and `a ∈ A`, `k ∈ 𝕜` satisfy `||a|| ||1|| < ||k||`, then `k` is in the resolvent set of `a` in `A` with respect to `𝕜`.


theorem SimpleGraph.Walk.reverseAux_append :
    ∀ {V : Type u} {G : SimpleGraph V} {u v w x : V} (p : SimpleGraph.Walk G u v) (q : SimpleGraph.Walk G u w)
      (r : SimpleGraph.Walk G w x),
      SimpleGraph.Walk.append (SimpleGraph.Walk.reverseAux p q) r =
        SimpleGraph.Walk.reverseAux p (SimpleGraph.Walk.append q r) :=
  by sorry

This theorem, `SimpleGraph.Walk.reverseAux_append`, states that given a simple graph `G` over vertices of type `V` and three walks `p`, `q`, and `r` in `G` such that `p` is a walk from `u` to `v`, `q` is a walk from `u` to `w`, and `r` is a walk from `w` to `x`, the operation of appending the walk `r` to the reversed walk obtained by applying the `reverseAux` function to `p` and `q` is equivalent to the reversed walk obtained by applying the `reverseAux` function to `p` and the appended walk of `q` and `r`. In simpler terms, the theorem deals with the commutativity of reversing and appending walks in a graph.

Given a simple graph and walks `p` from `u` to `v`, `q` from `u` to `w`, and `r` from `w` to `x`, the reversed walks obtained by appending `r` to `reverseAux(p, q)` and applying `reverseAux` to `p` and appending `q` and `r` are equal.


theorem sub_le_sub_right :
    ∀ {α : Type u} [inst : AddGroup α] [inst_1 : LE α]
      [inst_2 : CovariantClass α α (Function.swap fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] {a b : α},
      a ≤ b → ∀ (c : α), a - c ≤ b - c :=
  by sorry

This theorem, "sub_le_sub_right", states that for any type `α` that is an additive group and has a less-than-or-equal-to (`≤`) operation, satisfying the covariance condition with respect to addition, if `a` and `b` are elements of `α` with `a` less than or equal to `b`, then for any other element `c` of `α`, the subtraction of `c` from `a` is less than or equal to the subtraction of `c` from `b`. In common mathematical notation, this could be stated as: if $a \leq b$, then $a - c \leq b - c$ for all $c$ in the additive group $\alpha$.

If `α` is an additive group with a covariant `≤` operation, then for all `a ≤ b` in `α` and any `c` in `α`, we have `a - c ≤ b - c`.


theorem LinearMap.ker_comp :
    ∀ {R : Type u_1} {R₂ : Type u_3} {R₃ : Type u_4} {M : Type u_6} {M₂ : Type u_8} {M₃ : Type u_9} [inst : Semiring R]
      [inst_1 : Semiring R₂] [inst_2 : Semiring R₃] [inst_3 : AddCommMonoid M] [inst_4 : AddCommMonoid M₂]
      [inst_5 : AddCommMonoid M₃] [inst_6 : Module R M] [inst_7 : Module R₂ M₂] [inst_8 : Module R₃ M₃] {τ₁₂ : R →+* R₂}
      {τ₂₃ : R₂ →+* R₃} {τ₁₃ : R →+* R₃} [inst_9 : RingHomCompTriple τ₁₂ τ₂₃ τ₁₃] (f : M →ₛₗ[τ₁₂] M₂)
      (g : M₂ →ₛₗ[τ₂₃] M₃), LinearMap.ker (LinearMap.comp g f) = Submodule.comap f (LinearMap.ker g) :=
  by sorry

This theorem states that for any three semirings R, R₂, R₃ and three modules M, M₂, M₃ over those rings, and two ring homomorphisms τ₁₂, τ₂₃ (with τ₁₃ being the composite of τ₁₂ and τ₂₃), if we have two linear maps: one from M to M₂ and another from M₂ to M₃, then the kernel of the composition of the two linear maps (g composed with f) is equal to the preimage of the kernel of the second map (g) under the first map (f). In other words, all elements in M that are mapped to zero by the composed map (g composed with f) are exactly those elements that are mapped by f into elements of M₂ that are then mapped to zero by g.

The kernel of the composition of two linear maps f : M -> M₂ and g : M₂ -> M₃ between modules over rings is equal to the preimage of the kernel of g under f.


theorem Mathlib.Geometry.Euclidean.PerpBisector._auxLemma.2 :
    ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V]
      [inst_2 : MetricSpace P] [inst_3 : NormedAddTorsor V P] {c p₁ p₂ : P},
      (c ∈ AffineSubspace.perpBisector p₁ p₂) = (dist c p₁ = dist c p₂) :=
  by sorry

The theorem `Mathlib.Geometry.Euclidean.PerpBisector._auxLemma.2` states that for any types `V` and `P`, where `V` is a normed additive commutative group, `P` is a metric space, and `V` acts on `P` normed additively, and for any points `c`, `p₁`, and `p₂` in `P`, `c` is in the perpendicular bisector of the segment `p₁ p₂` if and only if the distance from `c` to `p₁` is equal to the distance from `c` to `p₂`. In other words, the perpendicular bisector of a line segment is the set of all points that are equidistant from the endpoints of the line segment.

A point is on the perpendicular bisector of a line segment if and only if it has equal distance to both segment endpoints.


theorem Set.smul_set_univ :
    ∀ {α : Type u_2} {β : Type u_3} [inst : Group α] [inst_1 : MulAction α β] {a : α}, a • Set.univ = Set.univ := by
  sorry

This theorem states that for any given types `α` and `β`, where `α` is a group and there is a multiplicative action defined from `α` to `β`, the scaled universal set `a • Set.univ` (where `a` is an element of the group `α` and `•` is the scalar multiplication operation) is equivalent to the universal set `Set.univ`. The universal set in this context is the set containing all elements of the type `β`. In other words, scaling the universal set by any factor from the group does not change the set.

For any group `α` and type `β`, the scalar multiplication of the universal set `Set.univ` by any element `a` from the group `α` results in the same set. In symbols: `a • Set.univ = Set.univ`.


theorem MeasureTheory.integral_nonpos_of_ae :
    ∀ {α : Type u_1} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} {f : α → ℝ},
      f ≤ᶠ[MeasureTheory.Measure.ae μ] 0 → ∫ (a : α), f a ∂μ ≤ 0 :=
  by sorry

This theorem states that for any type `α`, measurable space `m`, measure `μ` on that measurable space, and any real-valued function `f` defined on `α`, if `f` is less than or equal to zero almost everywhere (i.e., except possibly on a set of measure zero) with respect to measure `μ`, then the integral of `f` with respect to `μ` is less than or equal to zero. Essentially, it posits that if a function is non-positive almost everywhere, then its integral can't be positive.

If a real-valued function defined on a measurable space is almost everywhere non-positive with respect to a given measure, then its integral with respect to that measure is less than or equal to zero.


theorem CategoryTheory.MorphismProperty.RespectsIso.cancel_left_isIso :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {P : CategoryTheory.MorphismProperty C},
      CategoryTheory.MorphismProperty.RespectsIso P →
        ∀ {X Y Z : C} (f : X ⟶ Y) (g : Y ⟶ Z) [inst_1 : CategoryTheory.IsIso f],
          P (CategoryTheory.CategoryStruct.comp f g) ↔ P g :=
  by sorry

The theorem `CategoryTheory.MorphismProperty.RespectsIso.cancel_left_isIso` states that for any category `C` and any morphism property `P` that respects isomorphisms, for any objects `X`, `Y`, and `Z` in `C` and any morphisms `f` from `X` to `Y` and `g` from `Y` to `Z`, where `f` is an isomorphism, the property `P` holds for the composition of `f` and `g` if and only if `P` holds for `g`. In other words, if `P` respects isomorphisms, then the property `P` of a composition of an isomorphism and another morphism can be "cancelled" to just the property of the latter morphism.

For any category, morphism property respecting isomorphisms, and composable morphisms where the first is an isomorphism, the morphism property holds for their composition if and only if it holds for the right morphism.


theorem CategoryTheory.MorphismProperty.RespectsIso.monomorphisms :
    ∀ (C : Type u) [inst : CategoryTheory.Category.{v, u} C],
      CategoryTheory.MorphismProperty.RespectsIso (CategoryTheory.MorphismProperty.monomorphisms C) :=
  by sorry

This theorem states that in any category `C`, the property of being a monomorphism is preserved under composition with an isomorphism. More concretely, if we have morphisms in `C` such that one is a monomorphism and the other is an isomorphism, the composition of these two morphisms (in any order) is also a monomorphism. This result is a fundamental property in category theory that connects the concepts of monomorphisms and isomorphisms.

In any category, the composition of a monomorphism and an isomorphism is a monomorphism.


theorem IsAddGroupHom.image_addSubgroup :
    ∀ {G : Type u_1} {H : Type u_2} [inst : AddGroup G] [inst_1 : AddGroup H] {f : G → H},
      IsAddGroupHom f → ∀ {s : Set G}, IsAddSubgroup s → IsAddSubgroup (f '' s) :=
  by sorry

This theorem, named `IsAddGroupHom.image_addSubgroup`, asserts that for any two additive groups `G` and `H` and a function `f` from `G` to `H`, if `f` is an additive group homomorphism and `s` is an additive subgroup of `G`, then the image of `s` under `f` is an additive subgroup of `H`. In other words, the image of an additive subgroup under an additive group homomorphism is also an additive subgroup.

Given an additive group `H`, an additive group `G`, and an additive group homomorphism `f` from `G` to `H`, the image of an additive subgroup `s` of `G` under `f` is an additive subgroup of `H`.


/-- If one has `get l i hi` in a formula and `h : l = l'`, one can not `rw h` in the formula as
`hi` gives `i < l.length` and not `i < l'.length`. The theorem `get_of_eq` can be used to make
such a rewrite, with `rw (get_of_eq h)`.
 -/
theorem List.get_of_eq :
    ∀ {α : Type u_1} {l l' : List α} (h : l = l') (i : Fin (List.length l)),
      List.get l i = List.get l' { val := ↑i, isLt := ⋯ } :=
  by sorry

This theorem, `List.get_of_eq`, states that for any two lists `l` and `l'` of the same type `α`, if `l` equals `l'` as per the assumption `h`, then for any index `i` that is a non-negative integer less than the length of the list `l`, the elements at the index `i` in both lists `l` and `l'` are the same. This theorem is useful for rewriting expressions involving the `get` function applied to `l` in terms of `l'`. In other words, if you have an expression of the form `get l i hi` and you have an equality `h : l = l'`, then you can replace `get l i hi` with `get l' { val := ↑i, isLt := ⋯ }` using the `rw (get_of_eq h)` rewrite rule.

If two lists `l` and `l'` of the same type `α` are equal, then for any index `i` less than the length of `l`, the element at index `i` in both lists is equal.


theorem Asymptotics.isLittleO_abs_left :
    ∀ {α : Type u_1} {F : Type u_4} [inst : Norm F] {g : α → F} {l : Filter α} {u : α → ℝ},
      (fun x => |u x|) =o[l] g ↔ u =o[l] g :=
  by sorry

This theorem, `Asymptotics.isLittleO_abs_left`, states that for any type `α`, a type `F` which has a norm, a function `g` from `α` to `F`, a filter `l` on `α`, and a function `u` from `α` to real numbers, the absolute value function applied to `u` is little-o of `g` at the filter `l` if and only if `u` itself is little-o of `g` at the same filter. In more mathematical terms, it says that $|u(x)| = o(g(x))$ as $x$ approaches the limit defined by the filter `l` if and only if $u(x) = o(g(x))$ under the same conditions.

For any type `α`, function `g : α → F` with norm, filter `l` on `α`, and function `u : α → ℝ`, the absolute value of `u` is little-o of `g` at `l` if and only if `u` is little-o of `g` at `l`. |`|u|` is `o(g)` at `l` if and only if `u` is `o(g)` at `l`.


/-- The gamma pdf is measurable.  -/
theorem ProbabilityTheory.measurable_gammaPDFReal : ∀ (a r : ℝ), Measurable (ProbabilityTheory.gammaPDFReal a r) := by
  sorry

This theorem states that the probability density function (pdf) of the gamma distribution is measurable. In other words, for any two real numbers 'a' and 'r', which are the scale and rate parameters of the gamma distribution, the function that describes the gamma pdf is such that the preimage of every measurable set is also measurable.

The gamma distribution's probability density function is a measurable function.


/-- The cosine of `π / 6` is `√3 / 2`.  -/
theorem Real.cos_pi_div_six : Real.cos (Real.pi / 6) = Real.sqrt 3 / 2 := by sorry

The theorem `Real.cos_pi_div_six` states that the cosine of `π / 6` is equal to the square root of 3 divided by 2. This is a well-known result in trigonometry. Here, `Real.cos` refers to the cosine function over real numbers, `Real.pi` denotes the mathematical constant π (approximately 3.14159), and `Real.sqrt` indicates the square root function over real numbers. Therefore, in conventional mathematical notation, this theorem can be written as: cos(π / 6) = √3 / 2.

The cosine of π/6 equals the square root of 3/2.


theorem Mathlib.Order.Filter.Ultrafilter._auxLemma.1 :
    ∀ {α : Type u} {f : Ultrafilter α} {s : Set α}, (s ∈ ↑f) = (s ∈ f) := by sorry

This theorem states that for any type `α`, any ultrafilter `f` of type `α`, and any set `s` of type `α`, the membership of the set `s` in the coercion of the ultrafilter `f` is equivalent to the membership of the set `s` in the ultrafilter `f` itself. In other words, the set `s` is a member of the ultrafilter `f` if and only if `s` is also a member of the ultrafilter `f` after it has been coerced.

For any ultrafilter `f` on type `α` and any set `s` of type `α`, the set `s` is in the ultrafilter `f` if and only if `s` is in the coercion of `f`.


theorem Set.chainHeight_dual :
    ∀ {α : Type u_1} [inst : LT α] (s : Set α), Set.chainHeight (⇑OrderDual.ofDual ⁻¹' s) = Set.chainHeight s := by
  sorry

This theorem states that for any set `s` of a type `α` under a less-than relation (`LT α`), the maximal length of a strictly ascending sequence (also known as the chain height) remains the same whether we consider the set `s` or its order dual. The order dual of a set is the set with the reverse order. So, this theorem basically says that reversing the order of a set does not change the maximal length of strictly ascending sequences within the set.

For any set `s` of type `α` under a less-than relation `LT α`, the maximal length of a strictly ascending sequence in `s` equals the maximal length of a strictly ascending sequence in its order dual.


theorem Complex.arg_conj :
    ∀ (x : ℂ), Complex.arg ((starRingEnd ℂ) x) = if Complex.arg x = Real.pi then Real.pi else -Complex.arg x := by sorry

This theorem states that for any complex number `x`, the argument of the complex conjugate of `x` (denoted by `(starRingEnd ℂ) x`) is equal to the negation of the argument of `x`, except when the argument of `x` is equal to π (`Real.pi`). In that specific case, the argument of the complex conjugate of `x` is also π. Here, `Complex.arg` refers to the function that calculates the argument (phase) of a complex number, `starRingEnd` is a function that computes the complex conjugate of a given complex number, and `Real.pi` refers to the mathematical constant π.

The argument of the complex conjugate of a complex number is the negation of its argument, except when the argument is π, in which case it is π again.


/-- If the angle between two vectors is 0, the inner product equals the product of the norms.  -/
theorem InnerProductGeometry.inner_eq_mul_norm_of_angle_eq_zero :
    ∀ {V : Type u_1} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] {x y : V},
      InnerProductGeometry.angle x y = 0 → ⟪x, y⟫_ℝ = ‖x‖ * ‖y‖ :=
  by sorry

The theorem `InnerProductGeometry.inner_eq_mul_norm_of_angle_eq_zero` states that if the angle between two vectors is zero, then the inner product of the vectors equals the product of their norms. Here, the angle between the vectors is defined using the `InnerProductGeometry.angle` function, which is the undirected angle obtained using the real arccosine of the inner product of the vectors divided by the product of their norms. The vectors are elements of a normed add commutative group with a real inner product space. The inner product of the vectors and their norms are denoted by `⟪x, y⟫_ℝ` and `‖x‖`, `‖y‖` respectively.

If the angle between two vectors x and y in a real inner product space is zero, then their inner product equals the product of their norms: ⟪x, y⟫\_ℝ = ‖x‖ \* ‖y‖.


theorem Polynomial.IsPrimitive.content_eq_one :
    ∀ {R : Type u_1} [inst : CommRing R] [inst_1 : IsDomain R] [inst_2 : NormalizedGCDMonoid R] {p : Polynomial R},
      Polynomial.IsPrimitive p → Polynomial.content p = 1 :=
  by sorry

The theorem `Polynomial.IsPrimitive.content_eq_one` states that for any ring `R` which is a commutative ring, a domain, and has a normalized GCD monoid structure, if a polynomial `p` over `R` is primitive, then the content of `p` is equal to 1. Here, a polynomial is considered primitive if the only constant polynomials dividing it are units, and the content of a polynomial is defined as the greatest common divisor (GCD) of its coefficients.

If `R` is a commutative ring, a domain, and has a normalized GCD monoid structure, and `p` is a primitive polynomial over `R`, then the content of `p` equals 1.


theorem Nonneg.coe_add :
    ∀ {α : Type u_1} [inst : AddZeroClass α] [inst_1 : Preorder α]
      [inst_2 : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] (a b : { x // 0 ≤ x }),
      ↑(a + b) = ↑a + ↑b :=
  by sorry

This theorem, `Nonneg.coe_add`, states that for any type `α` that is an `AddZeroClass` (i.e., it supports addition and has a zero element), is a `Preorder` (i.e., it supports a less than or equal to relation that is transitive and reflexive), and is a `CovariantClass` (i.e., it supports a binary operation that preserves the relation), if `a` and `b` are non-negative instances of this type (denoted by `{ x // 0 ≤ x }`), then the operation of adding `a` and `b` and then applying the coercion to `α` (denoted by `↑(a + b)`) is the same as adding the results of coercing `a` and `b` to `α` individually and then adding those results (denoted by `↑a + ↑b`). In simpler terms, for non-negative numbers `a` and `b` in such a type, coercion and addition commute with each other.

For any `AddZeroClass` and `Preorder` type `α` that is a `CovariantClass`, if `a` and `b` are non-negative instances of `α`, then `↑(a + b) = ↑a + ↑b`.


theorem IsIntegrallyClosed.integralClosure_eq_bot_iff :
    ∀ {R : Type u_1} [inst : CommRing R] (K : Type u_3) [inst_1 : CommRing K] [inst_2 : Algebra R K]
      [ifr : IsFractionRing R K], integralClosure R K = ⊥ ↔ IsIntegrallyClosed R :=
  by sorry

The theorem `IsIntegrallyClosed.integralClosure_eq_bot_iff` states that for any commutative ring `R` and for any field of fractions `K` of `R`, the integral closure of `R` in `K` is the trivial (or bottom) subalgebra if and only if `R` is integrally closed. Here, a ring is said to be integrally closed if any element in its field of fractions that is integral over the ring is actually an element of the ring.

A commutative ring is integrally closed if and only if its integral closure in its field of fractions is the trivial subalgebra.


theorem MeasureTheory.setToFun_congr_ae :
    ∀ {α : Type u_1} {E : Type u_2} {F : Type u_3} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E]
      [inst_2 : NormedAddCommGroup F] [inst_3 : NormedSpace ℝ F] {m : MeasurableSpace α} {μ : MeasureTheory.Measure α}
      [inst_4 : CompleteSpace F] {T : Set α → E →L[ℝ] F} {C : ℝ} {f g : α → E}
      (hT : MeasureTheory.DominatedFinMeasAdditive μ T C),
      f =ᶠ[MeasureTheory.Measure.ae μ] g → MeasureTheory.setToFun μ T hT f = MeasureTheory.setToFun μ T hT g :=
  by sorry

This theorem, `MeasureTheory.setToFun_congr_ae`, states that for any types `α`, `E`, and `F`, given that `E` and `F` form normed additively commutative groups and are also normed spaces over the real numbers, and that `F` is a complete space. If we also have a measurable space `α` and a measure `μ` on it, a function `T` from the set of `α` to the space of bounded linear maps from `E` to `F`, and real number `C`, then for any two functions `f` and `g` from `α` to `E`, if `T` is a dominated finitely additive measure with respect to `μ` and `C`, and `f` is almost everywhere equal to `g` with respect to the measure `μ`, then applying the `setToFun` function to `f` and `g` with these settings will yield the same result.

In other words, if two functions are almost everywhere equal with respect to a certain measure, the function that maps sets to bounded linear maps treats them equivalently under a dominated finitely additive measure.

If `α` is a measurable space, `E` and `F` are normed additively commutative groups and complete normed spaces over the real numbers, `μ` is a measure on `α`, `T` is a dominated finitely additive measure from `α` to the bounded linear maps from `E` to `F`, and `f` and `g` are almost everywhere equal `α`-measurable functions from `α` to `E`, then `setToFun(f)` and `setToFun(g)` are equal as elements of the space of functions from `α` to the space of bounded linear maps from `E` to `F`.


theorem Polynomial.leadingCoeff_monic_mul :
    ∀ {R : Type u} [inst : Semiring R] {p q : Polynomial R},
      Polynomial.Monic p → Polynomial.leadingCoeff (p * q) = Polynomial.leadingCoeff q :=
  by sorry

This theorem states that for any semiring `R` and any polynomials `p` and `q` from `R`, if the polynomial `p` is monic (i.e., its leading coefficient is 1), then the leading coefficient of the polynomial obtained by multiplying `p` and `q` is the same as the leading coefficient of `q` itself.

For any semiring `R` and monic polynomials `p` and `q` from `R`, the leading coefficient of their product `p * q` equals the leading coefficient of `q`.


theorem lt_mul_of_le_of_one_lt :
    ∀ {α : Type u_1} [inst : MulOneClass α] [inst_1 : Preorder α]
      [inst_2 : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x < x_1] {a b c : α},
      b ≤ c → 1 < a → b < c * a :=
  by sorry

This theorem states that for any type `α` that has a multiplication and a one element (`MulOneClass`), and has a preorder relation (`Preorder`), and also satisfies the covariant property for multiplication and less than relation (`CovariantClass`), if `b` is less than or equal to `c` and `a` is more than one, then `b` is less than the product of `c` and `a`. In mathematical terms, given $b \leq c$ and $1 < a$ in this setting, we have $b < c \cdot a$.

Given a type `α` with `MulOneClass`, `Preorder`, and `CovariantClass` structures, if `1 < a` and `b <= c`, then `b < c * a`.


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

The theorem `AddSubgroup.closure_union` states that for any type `G` that has `AddGroup` instance and for any two sets `s` and `t` of type `G`, the additive subgroup generated by the union of `s` and `t` is equal to the supremum of the additive subgroups generated by `s` and `t` individually. In other words, this theorem is expressing the property that the closure operation of an additive subgroup preserves the union operation.

The additive subgroup generated by the union of two sets is equal to the sum of their additive subgroups.


theorem CategoryTheory.ShortComplex.HomologyData.leftRightHomologyComparison'_eq :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
      {S : CategoryTheory.ShortComplex C} (h : CategoryTheory.ShortComplex.HomologyData S),
      CategoryTheory.ShortComplex.leftRightHomologyComparison' h.left h.right = h.iso.hom :=
  by sorry

This theorem states that for any Category `C` that has zero morphisms, and any `ShortComplex` `S` in `C`, given a `HomologyData` `h` for `S`, the left-right homology comparison of the left and right data of `h` is equal to the `homomorphism` of the `iso` of `h`. In the language of category theory, this is a statement about the relation between the homological properties of short complexes and their associated homology data.

Given a Category `C` with zero morphisms and any ShortComplex `S` in `C` with HomologyData `h`, the left-right homology comparison of `h` equals the homomorphism of `h`'s isomorphism.


theorem Disjoint.le_symmDiff_sup_symmDiff_left :
    ∀ {α : Type u_2} [inst : BooleanAlgebra α] {a b c : α}, Disjoint a b → c ≤ symmDiff a c ⊔ symmDiff b c := by sorry

This theorem states that for any type `α` that forms a Boolean algebra, and any elements `a`, `b`, and `c` of that type, if `a` and `b` are disjoint (meaning their greatest lower bound, or infimum, is the bottom element of the lattice), then `c` is less than or equal to the supremum (or join operation) of the symmetric difference of `a` and `c` and the symmetric difference of `b` and `c`. In mathematical terms, if `a` and `b` are disjoint, then $c \leq ((a \setminus c) \cup (b \setminus c))$. Note that the symmetric difference operation `\` is represented mathematically by set subtraction, and the supremum operation `⊔` is represented by set union.

For any Boolean algebra type `α` and disjoint elements `a`, `b` of `α`, `c` satisfies `c ≤ (a \ b) ∪ (b \ c)`.


/-- The biUnion of a family of preconnected sets is preconnected if the graph determined by
whether two sets intersect is preconnected.  -/
theorem IsPreconnected.biUnion_of_reflTransGen :
    ∀ {α : Type u} [inst : TopologicalSpace α] {ι : Type u_3} {t : Set ι} {s : ι → Set α},
      (∀ i ∈ t, IsPreconnected (s i)) →
        (∀ i ∈ t, ∀ j ∈ t, Relation.ReflTransGen (fun i j => Set.Nonempty (s i ∩ s j) ∧ i ∈ t) i j) →
          IsPreconnected (⋃ n ∈ t, s n) :=
  by sorry

The theorem `IsPreconnected.biUnion_of_reflTransGen` states that for any type `α` with a topological space structure, and any set `t` of another type `ι`, if each element `i` of `t` indexes a preconnected set `s i` in the space, and furthermore for any two elements `i` and `j` in `t`, there exists a reflexivity-transitive relation that indicates the intersection of the sets they index is not empty and `i` belongs to `t`, then the union of all sets indexed by elements in `t` is also preconnected. This theorem can be interpreted as describing a certain condition under which the union of a family of preconnected sets remains preconnected.

If for each index `i` in a set `t`, `s i` is a preconnected subset of a topological space `α`, and there exists a reflexivity-transitive relation connecting any pair of indices `i` and `j` such that the intersection of `s i` and `s j` is non-empty, then the union of all `s i` is preconnected.


theorem Ordinal.lsub_lt_ord_lift :
    ∀ {ι : Type u} {f : ι → Ordinal.{max u v}} {c : Ordinal.{max u v}},
      Cardinal.lift.{v, u} (Cardinal.mk ι) < Ordinal.cof c → (∀ (i : ι), f i < c) → Ordinal.lsub f < c :=
  by sorry

The theorem `Ordinal.lsub_lt_ord_lift` asserts that for any type `ι`, a function `f` from `ι` to an ordinal `c` (both in the same or different universes), if the cardinality of `ι` after lifting to the universe of `c` is strictly less than the cofinality of `c`, and for any element `i` of `ι`, `f(i)` is less than `c`, then the least strict upper bound of the family `f` (denoted by `Ordinal.lsub f`) is strictly less than `c`. In simple words, if the associated set for `c` is "large enough" (as measured by its cofinality) and all elements of the set mapped by `f` are less than `c`, then the least upper bound of this function is also less than `c`.

If `ι` is a type, `c` is an ordinal, `f : ι → c`, `ℵ(ι) < cofinality(c)`, and for all `i ∈ ι`, `f(i) < c`, then `Ordinal.lsub f < c`.


theorem IsPGroup.iff_orderOf :
    ∀ {p : ℕ} {G : Type u_1} [inst : Group G] [hp : Fact (Nat.Prime p)],
      IsPGroup p G ↔ ∀ (g : G), ∃ k, orderOf g = p ^ k :=
  by sorry

This theorem states that for any natural number `p` and a type `G` that forms a group, if `p` is a prime number, then `G` is a p-group if and only if for every element `g` in the group, there exists a natural number `k` such that the order of `g` is equal to `p` raised to the power `k`. A p-group is a group in which every element's order is a power of a prime number. The order of an element `g` is the smallest positive natural number `n` such that `g` raised to the power `n` is the identity of the group, or `0` if no such `n` exists (i.e., `g` has infinite order).

For a prime number `p` and group `G`, `G` is a `p`-group if and only if for each `g` in `G`, there exists a natural number `k` such that the order of `g` equals `p^k`.


theorem smul_lt_smul_iff_of_pos_right :
    ∀ {α : Type u_1} {β : Type u_2} {a₁ a₂ : α} {b : β} [inst : SMul α β] [inst_1 : Preorder α] [inst_2 : Preorder β]
      [inst_3 : Zero β] [inst_4 : SMulPosStrictMono α β] [inst_5 : SMulPosReflectLT α β],
      0 < b → (a₁ • b < a₂ • b ↔ a₁ < a₂) :=
  by sorry

This theorem states that for any two elements `a₁` and `a₂` of a partially ordered type `α`, and any element `b` of a partially ordered type `β`, given the conditions that `β` has a zero element, `α` and `β` have a scalar multiplication operation, and this scalar multiplication operation is strictly monotonically increasing and reflects the less than operator when multiplied by a positive element, then if `b` is positive, `a₁` is less than `a₂` if and only if the result of scalar multiplication of `a₁` and `b` is less than the result of scalar multiplication of `a₂` and `b`. In mathematical terms, if `0 < b`, then `a₁ • b < a₂ • b` is equivalent to `a₁ < a₂`.

For any partially ordered types `α` and `β` with a zero element and a strictly monotonically increasing scalar multiplication operation, if `β` has a positive element `b`, then `a₁ < a₂` if and only if `a₁ · b < a₂ · b` for all `a₁, a₂ ∈ α`.


CategoryTheory.Presheaf.w

theorem CategoryTheory.Presheaf.w :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {A : Type u₂}
      [inst_1 : CategoryTheory.Category.{v₂, u₂} A] {U : C} (R : CategoryTheory.Presieve U)
      (P : CategoryTheory.Functor Cᵒᵖ A) [inst_2 : CategoryTheory.Limits.HasProducts A]
      [inst_3 : CategoryTheory.Limits.HasPullbacks C],
      CategoryTheory.CategoryStruct.comp (CategoryTheory.Presheaf.forkMap R P) (CategoryTheory.Presheaf.firstMap R P) =
        CategoryTheory.CategoryStruct.comp (CategoryTheory.Presheaf.forkMap R P)
          (CategoryTheory.Presheaf.secondMap R P) :=
  by sorry

The theorem `CategoryTheory.Presheaf.w` states that for any category `C` and `A`, a codomain `U` in `C`, a set of arrows `R` with codomain `U` (a presieve on `U`), and a presheaf `P` from the opposite category of `C` to `A`, if `A` has all products and `C` has all pullbacks, then the composition of the fork map of `R` and `P` with the first map of `R` and `P` is equal to the composition of the fork map of `R` and `P` with the second map of `R` and `P`. In other words, in the context of category theory, this theorem ensures the commutativity of a certain diagram related to presheaves, morphisms, and limits.

For any presheaf P from the opposite category of a category C with pullbacks and products, the diagram commutes where the fork map of a set of arrows R with codomain U and the first and second maps of R with P are concerned.


Infinite.false

theorem Infinite.false : ∀ {α : Sort u_1} [inst : Finite α], Infinite α → False := by sorry

This theorem states that for any type α, if α is finite, then it cannot be infinite. In other words, it's a contradiction to assert that a certain type is both finite and infinite at the same time. This is represented by the `False` return value, which in Lean's logic represents a contradiction or an impossible scenario.


CategoryTheory.IsSeparating.mono

theorem CategoryTheory.IsSeparating.mono :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {𝒢 : Set C},
      CategoryTheory.IsSeparating 𝒢 → ∀ {ℋ : Set C}, 𝒢 ⊆ ℋ → CategoryTheory.IsSeparating ℋ :=
  by sorry

The theorem `CategoryTheory.IsSeparating.mono` states that, given any category `C` and any set `𝒢` of objects from `C` that is a separating set, then for any other set of objects `ℋ` from `C` such that `𝒢` is a subset of `ℋ`, `ℋ` is also a separating set. Here, a separating set is defined as a set where, if for every object `G` in the set, every morphism `h` from `G` to object `X`, the composite of `h` with morphisms `f` and `g` (both from `X` to `Y`) are the same, then `f` and `g` must be the same morphism. In simpler terms, the theorem is about preserving the property of being a 'separating set' under taking superset in the category theory context.

Given a category `C` and a separating set `𝒢` of objects, any larger set `ℋ` containing `𝒢` is also a separating set.


theorem NNReal.coe_zero : ↑0 = 0 := by sorry

This theorem states that the non-negative real number representation of zero (`↑0`) is equal to zero (`0`). In simpler words, when zero is cast as a non-negative real number, it remains zero. The proof for this theorem is not provided here (represented by `sorry`).

The theorem asserts that `↑0 = 0` in Lean 4's non-negative real numbers.


/-- A sufficient condition for the Church-Rosser property.  -/
theorem Relation.church_rosser :
    ∀ {α : Type u_1} {r : α → α → Prop} {a b c : α},
      (∀ (a b c : α), r a b → r a c → ∃ d, Relation.ReflGen r b d ∧ Relation.ReflTransGen r c d) →
        Relation.ReflTransGen r a b → Relation.ReflTransGen r a c → Relation.Join (Relation.ReflTransGen r) b c :=
  by sorry

The theorem `Relation.church_rosser` states a sufficient condition for the Church-Rosser property in relation to a given relation `r` on a type `α`. The Church-Rosser property is characterized by the ability of two elements `b` and `c` to be related by the join of the reflexive transitive closure of `r`, given that they both are related to some common element `a` through the reflexive transitive closure of `r`. The sufficient condition to ensure this property holds is that for any three elements `a`, `b`, and `c`, if both `b` and `c` can be directly reached from `a` by the relation `r`, then there exists a common element `d` which can be reached from `b` via reflexive relation and from `c` via reflexive-transitive relation.

If relation `r` on type `α` satisfies the property that for all `a`, `b`, `c`, if `b` and `c` are related to `a` by `r`, then there exists an element `d` reachable from `b` by the reflexive relation and from `c` by the reflexive-transitive relation, then `r` has the Church-Rosser property.


theorem PartENat.dom_of_le_natCast : ∀ {x : PartENat} {y : ℕ}, x ≤ ↑y → x.Dom := by sorry

This theorem states that for any partially defined natural number `x` and any fully defined natural number `y`, if `x` is less than or equal to the embedding of `y` into the type of partially defined natural numbers, then `x` is defined. In other words, it guarantees that `x` is not the infinity element in the set of partially defined natural numbers when it is less than or equal to a concrete natural number.

If `x` is a partially defined natural number and `y` is a fully defined natural number such that `x ≤ embedding of y`, then `x` is defined.


theorem Real.rpow_lt_rpow_iff_of_neg : ∀ {x y z : ℝ}, 0 < x → 0 < y → z < 0 → (x ^ z < y ^ z ↔ y < x) := by sorry

This theorem states that for any three real numbers `x`, `y`, and `z`, if `x` and `y` are both positive and `z` is negative, then `x` raised to the power of `z` is less than `y` raised to the power of `z` if and only if `y` is less than `x`. This essentially lays down a condition under which we can compare the powers of two positive numbers, given a negative exponent.

For real numbers x, y, and z with x > 0, y > 0, and z < 0, x^z < y^z if and only if y < x.


theorem Order.lt_succ_bot_iff :
    ∀ {α : Type u_1} [inst : PartialOrder α] [inst_1 : SuccOrder α] {a : α} [inst_2 : OrderBot α]
      [inst_3 : NoMaxOrder α], a < Order.succ ⊥ ↔ a = ⊥ :=
  by sorry

This theorem states that for any type `α` which has a partial order, a successor order, a least element (denoted by `⊥`), and no maximal element, an element `a` of this type is less than the successor of `⊥` if and only if `a` is equal to `⊥`. Here, the successor of an element is the least element that is greater than the element, unless the element is a maximal element, in which case its successor is the element itself.

For any type with a partial order, successor, least element, and no maximal element, an element is less than the successor of the least element if and only if it is equal to the least element.


theorem tendsto_of_monotone :
    ∀ {ι : Type u_3} {α : Type u_4} [inst : Preorder ι] [inst_1 : TopologicalSpace α]
      [inst_2 : ConditionallyCompleteLinearOrder α] [inst_3 : OrderTopology α] {f : ι → α},
      Monotone f → Filter.Tendsto f Filter.atTop Filter.atTop ∨ ∃ l, Filter.Tendsto f Filter.atTop (nhds l) :=
  by sorry

This theorem, `tendsto_of_monotone`, states that for any type `ι` with a preorder and any type `α` with a topological space structure, a conditionally complete linear order and an order topology, if we have a function `f` from `ι` to `α` that is monotone, then either `f` tends to infinity as `ι` tends to infinity, or there exists a limit `l` such that `f` tends to `l` as `ι` tends to infinity. In mathematical terms, we could express it as: if $f$ is a monotone function, then $\lim_{x\to\infty} f(x) = \infty$ or $\lim_{x\to\infty} f(x) = l$ for some $l$ in the codomain.

A monotone function from a preordered type with a topology to a type with a complete order topology either converges to infinity or has a limit.


theorem isLocallyInjective_iff_isOpen_diagonal :
    ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] {f : X → Y},
      IsLocallyInjective f ↔ IsOpen (Function.pullbackDiagonal f) :=
  by sorry

This theorem states that for any topological space `X` and any type `Y`, and any function `f` from `X` to `Y`, the function `f` is locally injective if and only if the pullback of the diagonal of `Y` under the function `f` is an open set in the product topology on `X` x `X`. In other words, near every point in `X`, `f` doesn't send two different points to the same value (`f` is locally injective), if and only if the set of all pairs `(x, x')` in `X` x `X` such that `f(x) = f(x')` is an open set.

A function from a topological space to another type is locally injective if and only if the pullback of the diagonal relation is an open subset in the product topology.


theorem AddCommute.nsmul_right :
    ∀ {M : Type u_2} [inst : AddMonoid M] {a b : M}, AddCommute a b → ∀ (n : ℕ), AddCommute a (n • b) := by sorry

This theorem states that if addition of two elements `a` and `b` of a type `M` (that forms an additive monoid) is commutative, i.e., `a + b = b + a`, then addition of `a` and any natural number multiple of `b` is also commutative. In other words, if `a` and `b` commute additively, then `a` and `n•b` will also commute additively for any natural number `n`. Here, `n•b` represents the operation of adding `b` to itself `n` times.

If `a` and `b` commute in an additive monoid `M` (i.e., `a + b = b + a`), then for any natural number `n`, `a` and `n` times `b` (`n•b`) also commute in `M` (i.e., `a + n•b = n•b + a`).


/-- The closure (as a submodule) of the graph is equal to the graph of the closure
(as a `LinearPMap`).  -/
theorem LinearPMap.IsClosable.graph_closure_eq_closure_graph :
    ∀ {R : Type u_1} {E : Type u_2} {F : Type u_3} [inst : CommRing R] [inst_1 : AddCommGroup E]
      [inst_2 : AddCommGroup F] [inst_3 : Module R E] [inst_4 : Module R F] [inst_5 : TopologicalSpace E]
      [inst_6 : TopologicalSpace F] [inst_7 : ContinuousAdd E] [inst_8 : ContinuousAdd F] [inst_9 : TopologicalSpace R]
      [inst_10 : ContinuousSMul R E] [inst_11 : ContinuousSMul R F] {f : E →ₗ.[R] F},
      LinearPMap.IsClosable f →
        Submodule.topologicalClosure (LinearPMap.graph f) = LinearPMap.graph (LinearPMap.closure f) :=
  by sorry

This theorem states that for a given linear map `f` from a module `E` over a commutative ring `R` to a module `F` over the same ring, under certain conditions, the closure of the graph of `f` (viewed as a submodule of `E × F`) is equal to the graph of the closure of `f` (viewed as a `LinearPMap`). The conditions include that `R`, `E`, and `F` have topological space structures and addition and scalar multiplication are continuous operations. "Closure" in this context means the smallest closed set (in the topological sense) that contains the set. A `LinearPMap` is a partially defined linear map, and its graph is the set of all pairs `(x, f(x))` for `x` in the domain of definition.

Given a linear map `f` between modules `E` and `F` over a commutative ring `R` with topological structures such that addition and scalar multiplication are continuous, the closure of `f`'s graph as a submodule of `E × F` equals the graph of the closure of `f` as a `LinearPMap`.


theorem RingEquiv.symm_comp :
    ∀ {R : Type u_4} {S : Type u_5} [inst : NonAssocSemiring R] [inst_1 : NonAssocSemiring S] (e : R ≃+* S),
      RingHom.comp ↑(RingEquiv.symm e) ↑e = RingHom.id R :=
  by sorry

This theorem states that for any non-associative semiring `R` and `S`, given a ring isomorphism `e` from `R` to `S`, the composition of the ring homomorphism of `e` and its inverse is equal to the identity ring homomorphism on `R`. In other words, applying the isomorphism and then its inverse leaves any element in the semiring `R` unchanged, which is a characteristic property of isomorphisms in mathematics.

For any non-associative semiring isomorphism `e` from `R` to `S`, `e ∘ eᵀ = id_R`, where `id_R` is the identity ring homomorphism on `R`.


theorem ContractingWith.eq_or_edist_eq_top_of_fixedPoints :
    ∀ {α : Type u_1} [inst : EMetricSpace α] {K : NNReal} {f : α → α},
      ContractingWith K f → ∀ {x y : α}, Function.IsFixedPt f x → Function.IsFixedPt f y → x = y ∨ edist x y = ⊤ :=
  by sorry

The theorem `ContractingWith.eq_or_edist_eq_top_of_fixedPoints` states that for any type `α` equipped with an extended metric space structure, any nonnegative real `K`, and any function `f` from `α` to `α`, if `f` is contracting with `K` (meaning `K` is less than 1 and `f` is Lipschitz with `K`), then for any two points `x` and `y` in `α` that are fixed points of `f` (meaning `f(x)` equals `x` and `f(y)` equals `y`), either `x` is equal to `y` or the extended distance between `x` and `y` is infinite. This theorem essentially states that a contracting function in an extended metric space can have at most one fixed point, unless there are points infinitely far apart.

In an extended metric space, a contracting function with Lipschitz constant less than 1 has at most one fixed point, or all fixed points are infinitely far apart.


theorem Cubic.leadingCoeff_of_a_ne_zero :
    ∀ {R : Type u_1} {P : Cubic R} [inst : Semiring R], P.a ≠ 0 → Polynomial.leadingCoeff (Cubic.toPoly P) = P.a := by
  sorry

The theorem `Cubic.leadingCoeff_of_a_ne_zero` states that for any type `R` and any cubic polynomial `P` of type `Cubic R`, under the condition that there is a semiring structure on `R` and the coefficient `P.a` of the cubic term in `P` is non-zero, the leading coefficient of the polynomial obtained by converting `P` to a polynomial using the `Cubic.toPoly` function is equal to `P.a`.

Given a cubic polynomial `P` over a semiring `R` with non-zero cubic coefficient `P.a`, the leading coefficient of `Cubic.toPoly P` equals `P.a`.


theorem ContinuousAt.comp_lowerSemicontinuousAt :
    ∀ {α : Type u_1} [inst : TopologicalSpace α] {x : α} {γ : Type u_3} [inst_1 : LinearOrder γ]
      [inst_2 : TopologicalSpace γ] [inst_3 : OrderTopology γ] {δ : Type u_4} [inst_4 : LinearOrder δ]
      [inst_5 : TopologicalSpace δ] [inst_6 : OrderTopology δ] {g : γ → δ} {f : α → γ},
      ContinuousAt g (f x) → LowerSemicontinuousAt f x → Monotone g → LowerSemicontinuousAt (g ∘ f) x :=
  by sorry

This theorem states that if we have a function `g` from some ordered topological space `\gamma` to another ordered topological space `\delta`, and another function `f` from a topological space `\alpha` to `\gamma`, then if `g` is continuous at `f(x)` for some `x` in `\alpha`, `f` is lower semicontinuous at `x`, and `g` is monotone, then the composition `g ∘ f` is lower semicontinuous at `x`.

In less formal terms, it says that the composition of a continuous function and a lower semicontinuous function is also lower semicontinuous, assuming that the continuous function is monotone. This is under the condition that the first function is continuous at the point where the second function is lower semicontinuous.

If a monotone, continuous function `g` from an ordered topological space `\delta` to another ordered topological space `\gamma`, and a lower semicontinuous function `f` from a topological space `\alpha` to `\gamma` are such that `g` is continuous at `f(x)` for some `x` in `\alpha`, then their composition `g ∘ f` is lower semicontinuous at `x`.


theorem CategoryTheory.Limits.coequalizer.π_desc :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} {f g : X ⟶ Y}
      [inst_1 : CategoryTheory.Limits.HasCoequalizer f g] {W : C} (k : Y ⟶ W)
      (h : CategoryTheory.CategoryStruct.comp f k = CategoryTheory.CategoryStruct.comp g k),
      CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.coequalizer.π f g)
          (CategoryTheory.Limits.coequalizer.desc k h) =
        k :=
  by sorry

The theorem `CategoryTheory.Limits.coequalizer.π_desc` states that in any category `C`, for any objects `X`, `Y`, and `W` in `C`, and for any morphisms `f`, `g` from `X` to `Y`, and `k` from `Y` to `W` such that the composition of `f` and `k` is equal to the composition of `g` and `k`, if `f` and `g` have a coequalizer, then the composition of the projection from the coequalizer of `f` and `g` and the descendent of `k` with respect to the coequalizer is equal to `k`. This property encapsulates the universal property of the coequalizer in the language of category theory.

If in a category `C` objects `X`, `Y`, `W`, morphisms `f: X → Y`, `g: X → Y`, and `k: Y → W` satisfy `f ∘ k = g ∘ k`, and `f` and `g` have a coequalizer, then the composition of the coequalizer's projection and `k`'s descent is equal to `k`.


theorem Module.finite_of_finrank_pos :
    ∀ {R : Type u} {M : Type v} [inst : Ring R] [inst_1 : StrongRankCondition R] [inst_2 : AddCommGroup M]
      [inst_3 : Module R M] [inst_4 : Module.Free R M], 0 < FiniteDimensional.finrank R M → Module.Finite R M :=
  by sorry

This theorem states that if a module `M` over a ring `R` has a positive finite rank (the rank is a natural number and greater than zero), and if `R` satisfies the strong rank condition (a condition related to the finiteness of bases of modules) and `M` is a free module over `R` (it has a basis), then the module `M` is a finite module. In the context of linear algebra, this essentially means that the module (which can be thought of as a vector space) has a finite basis.

If `M` is a free module of positive finite rank over a ring `R` satisfying the strong rank condition, then `M` is a finite module.


/-- If two additive homomorphisms from `Π₀ i, β i` are equal on each `single a b`, then
they are equal.  -/
theorem DFinsupp.addHom_ext :
    ∀ {ι : Type u} {β : ι → Type v} [inst : DecidableEq ι] [inst_1 : (i : ι) → AddZeroClass (β i)] {γ : Type w}
      [inst_2 : AddZeroClass γ] ⦃f g : (Π₀ (i : ι), β i) →+ γ⦄,
      (∀ (i : ι) (y : β i), f (DFinsupp.single i y) = g (DFinsupp.single i y)) → f = g :=
  by sorry

This theorem states that for any type `ι`, and a function `β` from `ι` to some type, given a decidable equality on `ι` and an additive zero class on each `β i`, and a third type `γ` that also has an additive zero class, if there are two additive homomorphisms `f` and `g` from `Π₀ i, β i` to `γ` that are equal on each `DFinsupp.single i y`, then these two homomorphisms are equal.

In simpler terms, if you have two homomorphisms that map a direct sum of the types `β i` to `γ` and they agree on each "singleton" direct sum (`DFinsupp.single i y`), then the two homomorphisms are actually the same. The singleton direct sum is a function that sends `i` to `y` and all other points to `0`.

Given types `ι`, a function `β : ι → T`, a decidable equality on `ι`, additive zero classes on `β i` and `γ`, and two additive homomorphisms `f` and `g` from `Π₀ i, β i` to `γ`, if `f (DFinsupp.single i y) = g (DFinsupp.single i y)` for all `i` and `y`, then `f = g`.


theorem AddSubgroup.map_comap_eq :
    ∀ {G : Type u_1} [inst : AddGroup G] {N : Type u_5} [inst_1 : AddGroup N] (f : G →+ N) (H : AddSubgroup N),
      AddSubgroup.map f (AddSubgroup.comap f H) = AddMonoidHom.range f ⊓ H :=
  by sorry

This theorem states that for any additive group homomorphism `f` from an additive group `G` to another additive group `N`, and for any additive subgroup `H` of `N`, the image under `f` of the preimage of `H` under `f` equals the intersection of the range of `f` and `H`. In simpler terms, if you start with a subgroup `H` of `N`, pull it back to `G` using `f`, push it forward again to `N` using `f`, you get exactly the elements of `H` that are in the image of `G` under `f`.

For any additive group homomorphism $f$ from group $G$ to group $N$ and any subgroup $H$ of $N$, the image of the preimage $f^{-1}(H)$ under $f$ equals the intersection of $H$ and the range of $f$.


/-- See `lt_tsub_iff_left_of_le_of_le` for a weaker statement in a partial order.  -/
theorem tsub_lt_tsub_iff_left_of_le :
    ∀ {α : Type u_1} [inst : CanonicallyLinearOrderedAddCommMonoid α] [inst_1 : Sub α] [inst_2 : OrderedSub α]
      {a b c : α} [inst_3 : ContravariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1],
      b ≤ a → (a - b < a - c ↔ c < b) :=
  by sorry

This theorem, `tsub_lt_tsub_iff_left_of_le`, is about subtraction in a particular type of algebraic structure, canonically linearly ordered additive commutative monoids with a subtraction operation that is ordered. Given elements `a`, `b`, and `c` of such a structure, if `b` is less than or equal to `a`, then `a - b` is less than `a - c` if and only if `c` is less than `b`. This theorem provides a way to compare the results of subtraction operations in this type of structure.

For all additively commutative, ordered monoids with subtraction `M`, and all elements `a`, `b`, and `c` in `M` with `b ≤ a`, if `a - b < a - c`, then `b < c`.


theorem DFinsupp.sigmaCurry_apply :
    ∀ {ι : Type u} [inst : DecidableEq ι] {α : ι → Type u_2} {δ : (i : ι) → α i → Type v}
      [inst_1 : (i : ι) → (j : α i) → Zero (δ i j)] (f : Π₀ (i : (x : ι) × α x), δ i.fst i.snd) (i : ι) (j : α i),
      ((DFinsupp.sigmaCurry f) i) j = f { fst := i, snd := j } :=
  by sorry

The theorem `DFinsupp.sigmaCurry_apply` states that for any type `ι` with decidable equality, any dependent function `α` from `ι` to some type, and any dependent function `δ` from pairs of `ι` and `α i` to some type, given the zero value of `δ i j` for any `i` in `ι` and `j` in `α i`, for any Direct Function (DFinsupp) `f` from pairs of `ι` and `α` to `δ`, and any value `i` of `ι` and `j` of `α i`, the application of `DFinsupp.sigmaCurry f` at `i` and `j` equals the application of `f` at the pair formed by `i` and `j`. In other words, the function `DFinsupp.sigmaCurry` transforms a function of pairs into a curried function.

For any type `ι` with decidable equality, dependent functions `α : ι → Type, δ : (ι × α) → Type,` and given `δ (i, j) = 0` for all `i ∈ ι, j ∈ α i,` the curried function `DFinsupp.sigmaCurry f at (i, j) = f (i, j)` for any Dependent Function (DFinsupp) `f : (ι × α) → δ.`


/-- Pythagorean theorem, if-and-only-if vector inner product form.  -/
theorem norm_add_sq_eq_norm_sq_add_norm_sq_iff_real_inner_eq_zero :
    ∀ {F : Type u_3} [inst : NormedAddCommGroup F] [inst_1 : InnerProductSpace ℝ F] (x y : F),
      ‖x + y‖ * ‖x + y‖ = ‖x‖ * ‖x‖ + ‖y‖ * ‖y‖ ↔ ⟪x, y⟫_ℝ = 0 :=
  by sorry

This theorem is a variant of the Pythagorean theorem in the context of inner product spaces over the real numbers. Specifically, it states that for any two vectors `x` and `y` in a normed additively commutative group that also forms an inner product space over the real numbers, the squared norm of the sum of `x` and `y` equals the sum of the squared norms of `x` and `y` if and only if the real inner product of `x` and `y` is zero. In other words, the vectors `x` and `y` are orthogonal (perpendicular) if and only if the Pythagorean relation holds for their norms.

In a real inner product space, two vectors are orthogonal if and only if the sum of their squared norms equals the square of the norm of their sum.


theorem MeasureTheory.Content.outerMeasure_lt_top_of_isCompact :
    ∀ {G : Type w} [inst : TopologicalSpace G] (μ : MeasureTheory.Content G) [inst_1 : R1Space G]
      [inst_2 : WeaklyLocallyCompactSpace G] {K : Set G}, IsCompact K → ↑(MeasureTheory.Content.outerMeasure μ) K < ⊤ :=
  by sorry

This theorem states that for any topological space `G`, given a measure content `μ` and a particular set `K` in `G`, if `K` is compact, then the outer measure of `K` under `μ`, when considered as a real number, is strictly less than infinity. Here, the space `G` is assumed to be an `R1Space` (a real number system) and a `WeaklyLocallyCompactSpace` (a space where every point has a compact neighborhood). This theorem is essentially enforcing that compact sets in such a space have finite outer measure.

In an `R1Space` and `WeaklyLocallyCompactSpace` `G`, the outer measure of a compact set `K` is finite.


theorem UniformSpace.ofCoreEq_toCore :
    ∀ {α : Type ua} (u : UniformSpace α) (t : TopologicalSpace α)
      (h : t = UniformSpace.Core.toTopologicalSpace (UniformSpace.toCore u)),
      UniformSpace.ofCoreEq (UniformSpace.toCore u) t h = u :=
  by sorry

The theorem `UniformSpace.ofCoreEq_toCore` states that for any type `α`, given a UniformSpace `u` and a TopologicalSpace `t` such that `t` equals the TopologicalSpace generated by the core of `u`, the UniformSpace constructed from the core of `u` and `t` (with the equality condition) is exactly `u`. In other words, this theorem assures that the process of transitioning from a UniformSpace to its core and back to a UniformSpace while retaining the same TopologicalSpace structure, does not change the original UniformSpace.

For any UniformSpace `u` and TopologicalSpace `t` such that `t` is the topology generated by `u`'s core, the UniformSpace constructed from `u`'s core and `t` is equal to `u`.


theorem Nat.Partrec.Code.curry_prim : Primrec₂ Nat.Partrec.Code.curry := by sorry

The theorem `Nat.Partrec.Code.curry_prim` states that the function `Nat.Partrec.Code.curry`, which takes a code `c` and a natural number `n`, returning a new code that uses `n` as the first argument to `c`, is a binary primitive recursive function. In other words, the process of currying in the context of partial recursive functions on natural numbers, as defined by `Nat.Partrec.Code.curry`, is itself a primitive recursive operation. This means that it can be computed using only a finite number of steps, each of which may be a basic arithmetic operation, a conditional, or a composition of such steps.

The function `Nat.Partrec.Code.curry` that curries a partial recursive function on natural numbers is a primitive recursive function.


theorem Sum.map_id_id : ∀ {α : Type u_1} {β : Type u_2}, Sum.map id id = id := by sorry

The theorem `Sum.map_id_id` states that for any types `α` and `β`, the application of the `Sum.map` function with identity functions for both its arguments is itself an identity function. In other words, if you have a sum type of `α` and `β`, and you map each component of the sum type to itself (i.e., you don't change it), the overall effect is the same as if you hadn't done anything. This is analogous to the mathematical property that the identity function applied to any function results in the original function.

For any types `α` and `β`, the function `Sum.map` with identity functions as arguments is the identity function on the sum type `α ⊕ β`.


theorem AlgebraicTopology.DoldKan.P_f_naturality :
    ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.Preadditive C] (q n : ℕ)
      {X Y : CategoryTheory.SimplicialObject C} (f : X ⟶ Y),
      CategoryTheory.CategoryStruct.comp (f.app (Opposite.op (SimplexCategory.mk n)))
          ((AlgebraicTopology.DoldKan.P q).f n) =
        CategoryTheory.CategoryStruct.comp ((AlgebraicTopology.DoldKan.P q).f n)
          (f.app (Opposite.op (SimplexCategory.mk n))) :=
  by sorry

The theorem `AlgebraicTopology.DoldKan.P_f_naturality` states that for any category `C` that is preadditive, for any natural numbers `q` and `n`, and for any morphism `f` between two simplicial objects `X` and `Y` in `C`, the composition of the application of `f` to the opposite of the simplex category object created from `n`, and the application of the Dold-Kan correspondence `P` (for a given `q`) to `n`, is equal to the composition of the application of `P` to `n` and the application of `f` to the opposite of the simplex category object created from `n`. This essentially asserts the naturality of the Dold-Kan correspondence.

For any preadditive category C, any natural numbers q and n, and any morphism f between simplicial objects X and Y in C, the diagram commutes: P(f)(Ob(n)) ≅ Ob(P(n)) ∘ f, where Ob denotes the application of the opposite functor to the simplex category object.


theorem List.map_replicate :
    ∀ {α : Type u} {β : Type v} (f : α → β) (n : ℕ) (a : α), List.map f (List.replicate n a) = List.replicate n (f a) :=
  by sorry

The theorem `List.map_replicate` states that for any types `α` and `β`, a function `f` from `α` to `β`, a natural number `n` and a value `a` of type `α`, applying `f` to each element of a list that consists of `n` copies of `a` results in a new list that consists of `n` copies of `f(a)`. In other terms, it is saying that mapping a function over a list that has been created by replicating a value `n` times is the same as replicating the function applied to the value `n` times.

For any types `α` and `β`, function `f` from `α` to `β`, natural number `n`, and value `a` of type `α`, `List.map (λ x => f x) (List.repeat a n) = List.repeat (f a) n`.


/-- Assumes left covariance.
The lemma assuming right covariance is `Right.add_pos_of_nonneg_of_pos`. -/
theorem Left.add_pos_of_nonneg_of_pos :
    ∀ {α : Type u_1} [inst : AddZeroClass α] [inst_1 : Preorder α]
      [inst_2 : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x < x_1] {a b : α}, 0 ≤ a → 0 < b → 0 < a + b :=
  by sorry

This theorem, `Left.add_pos_of_nonneg_of_pos`, states that for any type `α` that has an addition operation with a zero element (`AddZeroClass α`), a preorder relationship (`Preorder α`), and a left covariant property (`CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x < x_1`), if we have two elements `a` and `b` where `a` is non-negative (i.e., `0 ≤ a`) and `b` is positive (i.e., `0 < b`), then the sum `a + b` is also positive (`0 < a + b`). This is under the assumption of left covariance, and there is a corresponding lemma assuming right covariance named `Right.add_pos_of_nonneg_of_pos`.

If `α` is a type with an additive structure, a preorder, and left covariance, and `a` is non-negative and `b` is positive, then `a + b` is positive.


theorem isLUB_Ico :
    ∀ {γ : Type w} [inst : SemilatticeInf γ] [inst_1 : DenselyOrdered γ] {a b : γ}, a < b → IsLUB (Set.Ico a b) b := by
  sorry

The theorem `isLUB_Ico` states that for any type `γ` with a semilattice structure and a densely ordered structure, and for any two elements `a` and `b` of `γ` such that `a < b`, the element `b` is a least upper bound of the left-closed right-open interval from `a` to `b` (denoted as `[a, b)`). In other words, `b` is the smallest element that is greater than or equal to every element in the interval `[a, b)`.

For any semilattice and densely ordered type `γ` with elements `a` and `b` such that `a < b`, the element `b` is the least upper bound of the interval `[a, b)`.