theorem Finset.image_val :
    ∀ {α : Type u_1} {β : Type u_2} [inst : DecidableEq β] (f : α → β) (s : Finset α),
      (Finset.image f s).val = Multiset.dedup (Multiset.map f s.val) :=
  by sorry

The theorem `Finset.image_val` states that for all types `α` and `β`, given a decidable equality on `β`, a function `f` mapping from `α` to `β`, and a finite set `s` of type `α`, the value of the image of `s` under `f` (computed using `Finset.image`) is equal to the multiset resulting from removing duplicates (using `Multiset.dedup`) from the multiset obtained by mapping `f` over the value of `s` (using `Multiset.map`). Essentially, it's defining what it means to apply a function to each element of a finite set: we get a new finite set with no duplicates, where each element is the result of applying the function to an element of the original set.

For any types `α` and `β`, given a decidable equality on `β` and a function `f` from `α` to `β`, the image of a finite set `s` under `f`, computed as `Finset.image s f`, is equal to the multiset obtained by mapping `f` over `s` and removing duplicates, denoted as `Multiset.dedup (Multiset.map f s)`.


theorem Filter.Eventually.prod_mk :
    ∀ {α : Type u_1} {β : Type u_2} {la : Filter α} {pa : α → Prop},
      (∀ᶠ (x : α) in la, pa x) →
        ∀ {lb : Filter β} {pb : β → Prop}, (∀ᶠ (y : β) in lb, pb y) → ∀ᶠ (p : α × β) in la ×ˢ lb, pa p.1 ∧ pb p.2 :=
  by sorry

This theorem, `Filter.Eventually.prod_mk`, states that for any types `α` and `β`, any filters `la` on `α` and `lb` on `β`, and any properties `pa` on `α` and `pb` on `β`, if almost all elements `x` in the filter `la` satisfy property `pa` and almost all elements `y` in the filter `lb` satisfy property `pb`, then almost all pairs `(p : α × β)` in the product filter `la ×ˢ lb` satisfy both properties `pa` on the first element and `pb` on the second element. Here, "almost all" is described by the `∀ᶠ` symbol, which means "eventually for all" or "for all outside a set of measure zero" in the context of filters.

If filters `la` on `α` and `lb` on `β` have almost all elements satisfying properties `pa` and `pb` respectively, then the product filter `la ×ˢ lb` has almost all pairs satisfying both `pa` and `pb`.


theorem subset_trans :
    ∀ {α : Type u} [inst : HasSubset α] [inst_1 : IsTrans α fun x x_1 => x ⊆ x_1] {a b c : α}, a ⊆ b → b ⊆ c → a ⊆ c :=
  by sorry

This theorem, `subset_trans`, states that for any type `α` that has a subset operation and a transitive relation, if `a`, `b`, and `c` are elements of `α`, and `a` is a subset of `b` and `b` is a subset of `c`, then `a` is a subset of `c`. This is a formalization of the transitivity property for subset relationships.

If `a` is a subset of `b` and `b` is a subset of `c`, then `a` is a subset of `c`.


/-- **Markov's inequality** also known as **Chebyshev's first inequality**.  -/
theorem MeasureTheory.mul_meas_ge_le_lintegral₀ :
    ∀ {α : Type u_1} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} {f : α → ENNReal},
      AEMeasurable f μ → ∀ (ε : ENNReal), ε * ↑↑μ {x | ε ≤ f x} ≤ ∫⁻ (a : α), f a ∂μ :=
  by sorry

The Lean 4 statement describes **Markov's inequality**, also known as **Chebyshev's first inequality**. This theorem states that, for any measure space `α` with measure `μ` and any almost everywhere measurable function `f` from `α` to the extended nonnegative real numbers `ENNReal`, the product of any extended nonnegative real number `ε` and the measure of the set of elements `x` in `α` where `ε` is less than or equal to `f(x)` is less than or equal to the Lebesgue integral of `f` with respect to `μ`.

For any measure space `(α, μ)`, and any almost everywhere measurable function `f : α → [0, +∞]`, we have ε · μ({x : α | f(x) ≤ ε}) ≤ ∫α f dμ.


theorem and_forall_ne : ∀ {α : Sort u_2} {p : α → Prop} (a : α), (p a ∧ ∀ (b : α), b ≠ a → p b) ↔ ∀ (b : α), p b := by
  sorry

This theorem states that for any type `α` and any property `p` of `α`, given an element `a` of `α`, the property `p` holds for `a` and for all other elements `b` of `α` that are not equal to `a` if and only if the property `p` holds for all elements `b` of `α`. In other words, if you know that a property is true for one specific element and all other different elements, then it is indeed true for all elements of the type.

For any type `α` and property `p` of `α`, if `p` holds for all `a` in `α` and all other distinct `b` in `α`, then `p` holds for all elements in `α`.


theorem lt_of_pow_lt_pow_left' :
    ∀ {M : Type u_3} [inst : Monoid M] [inst_1 : LinearOrder M]
      [inst_2 : CovariantClass M M (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1]
      [inst_3 : CovariantClass M M (Function.swap fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1] {a b : M} (n : ℕ),
      a ^ n < b ^ n → a < b :=
  by sorry

The theorem `lt_of_pow_lt_pow_left'` asserts that for any types `M` that forms a monoid and has a linear order, with two additional properties expressed by the `CovariantClass` conditions. The properties describe the relationship between multiplication and the order relation in `M`. Given any two elements `a` and `b` of `M` and a natural number `n`, if `a` raised to the power `n` is less than `b` raised to the power `n`, then `a` is less than `b`. In other words, this theorem captures the fact that the power function preserves the order relation in a monoid that also has a linear order and satisfies the specified covariance conditions.

For any monoid `M` with a linear order and satisfying the given covariance conditions, if `a^n < b^n` for some natural number `n`, then `a < b`.


/-- If `K` is a compact set in an R₁ space and `s ⊇ K` is a Borel measurable superset,
then `s` includes the closure of `K` as well.  -/
theorem IsCompact.closure_subset_measurableSet :
    ∀ {γ : Type u_3} [inst : TopologicalSpace γ] [inst_1 : MeasurableSpace γ] [inst_2 : BorelSpace γ]
      [inst_3 : R1Space γ] {K s : Set γ}, IsCompact K → MeasurableSet s → K ⊆ s → closure K ⊆ s :=
  by sorry

The theorem `IsCompact.closure_subset_measurableSet` states that in a topological space `γ` which is also an R₁ space and Borel space, given any compact set `K` and any measurable set `s` such that `K` is a subset of `s`, the closure of `K` is also a subset of `s`. In other words, if a set `K` is compact and is contained within a measurable set `s`, then the smallest closed set that contains `K` is also contained within `s`.

In a topological R₁ Borel space, if a compact set is contained in a measurable set, then its closure is also contained in that measurable set.


theorem List.pairwise_singleton : ∀ {α : Type u_1} (R : α → α → Prop) (a : α), List.Pairwise R [a] := by sorry

This theorem states that for any type `α` and any binary relation `R` over `α`, a singleton list containing an element `a` of type `α` is pairwise related by `R`. In other words, `List.Pairwise R [a]` always holds true since there are no distinct pair of elements in the list to contradict the pairwise property.

For any type `α` and binary relation `R` over `α`, the singleton list `[a]` (where `a : α`) satisfies the pairwise property `R` (i.e., `List.Pairwise R [a]` holds true).


theorem UpperHalfPlane.dist_eq :
    ∀ (z w : UpperHalfPlane),
      dist z w = 2 * Real.arsinh (dist ↑z ↑w / (2 * Real.sqrt (UpperHalfPlane.im z * UpperHalfPlane.im w))) :=
  by sorry

The theorem `UpperHalfPlane.dist_eq` states that for any two points `z` and `w` in the open upper half plane, the distance between `z` and `w` is twice the area hyperbolic sine of the ratio of the distance between `z` and `w` in the complex plane and twice the square root of the product of the imaginary parts of `z` and `w`. In other words, the theorem defines a distance metric on the open upper half plane using the area hyperbolic sine function. This function is geometrically significant in hyperbolic geometry and is used here to relate the Euclidean geometry of the complex plane with the hyperbolic geometry of the upper half plane.

The theorem `UpperHalfPlane.dist_eq` asserts that the distance between two points in the open upper half plane is equal to twice the area hyperbolic sine of half the difference of their coordinates in the complex plane.


theorem MvQPF.comp_map :
    ∀ {n : ℕ} {F : TypeVec.{u} n → Type u_1} [inst : MvFunctor F] [q : MvQPF F] {α β γ : TypeVec.{u} n}
      (f : TypeVec.Arrow α β) (g : TypeVec.Arrow β γ) (x : F α),
      MvFunctor.map (TypeVec.comp g f) x = MvFunctor.map g (MvFunctor.map f x) :=
  by sorry

The theorem `MvQPF.comp_map` states that for any natural number `n`, any multivariate functor `F` of `TypeVec n` to some type, and any three `n`-tuples of types `α`, `β`, and `γ`, if we have arrows `f` from `α` to `β` and `g` from `β` to `γ`, and an element `x` of the functor applied to `α`, then mapping the composition of `g` and `f` over `x` is the same as first mapping `f` over `x`, and then mapping `g` over the result. In other words, the process of mapping over the functor respects the composition of arrows, a property that is commonly expected in many kinds of structure in mathematics.

For any multivariate functor `F` and natural number `n`, if `f : α → β` and `g : β → γ` are functions, then the application of the composition `g ∘ f` to an element `x : F α` is equal to the composition of the application of `g` to the application of `f` to `x`. In symbols, `(g ∘ f) (F x) = g (F (f x))`.


/-- Ring homomorphisms preserve `bit1`.  -/
theorem map_bit1 :
    ∀ {F : Type u_1} {α : Type u_2} {β : Type u_3} [inst : FunLike F α β] [inst_1 : NonAssocSemiring α]
      [inst_2 : NonAssocSemiring β] [inst_3 : RingHomClass F α β] (f : F) (a : α), f (bit1 a) = bit1 (f a) :=
  by sorry

The theorem `map_bit1` states that for any types `F`, `α`, and `β`, if `F` has an structure of function from `α` to `β` (as expressed by `FunLike F α β`), `α` and `β` have structures of non-associative semirings, and `F` has an structure of ring homomorphism from `α` to `β` (as expressed by `RingHomClass F α β`), then for any function `f : F` and any element `a : α`, applying `f` to `bit1 a` (where `bit1` is a function that maps an element `a` to `bit0 a + 1`, essentially representing the operation of multiplying by 2 and then adding 1) is the same as applying `f` to `a` and then applying `bit1` to the result. In other words, ring homomorphisms preserve the `bit1` operation.

For any function `F : α -> β` with ring homomorphism structure between non-associative semirings `α` and `β`, `F (bit1 a) = bit1 (F a)` for all `a : α`, where `bit1` is the operation of adding 1 after multiplying by 2.


theorem convex_Iio :
    ∀ {𝕜 : Type u_1} {β : Type u_4} [inst : OrderedSemiring 𝕜] [inst_1 : OrderedCancelAddCommMonoid β]
      [inst_2 : Module 𝕜 β] [inst_3 : OrderedSMul 𝕜 β] (r : β), Convex 𝕜 (Set.Iio r) :=
  by sorry

The theorem `convex_Iio` states that for any instance of an ordered semiring `𝕜`, an ordered cancel additive commutative monoid `β`, a module over `𝕜` of `β`, and an ordered scalar multiplication of `𝕜` over `β`, and given any element `r` of type `β`, the left-infinite right-open interval (denoted by `Set.Iio r`) is a convex set with respect to `𝕜`. In other words, any left-infinite right-open interval forms a convex set in the context of the specified algebraic structures.

For any ordered semiring `𝕜`, ordered cancel additive commutative monoid `β`, module over `𝕜` of `β`, and ordered scalar multiplication of `𝕜` over `β`, the left-infinite right-open interval `Set.Iio r` of any element `r` in `β` is a convex set.


theorem Real.differentiableAt_log : ∀ {x : ℝ}, x ≠ 0 → DifferentiableAt ℝ Real.log x := by sorry

This theorem states that for all real numbers `x`, provided `x` is not equal to zero, the real logarithm function `Real.log` is differentiable at `x`. Differentiability, in this context, means that the function has a derivative (possibly non-unique) at that point. The derivative of a function at a point gives the slope of the tangent line to the function's graph at that point, effectively capturing the instantaneous rate of change of the function at that point. The condition `x ≠ 0` is necessary because the logarithm function is not defined at `x = 0`.

For all non-zero real numbers `x`, the real logarithm function `Real.log` is differentiable at `x`.


theorem convex_Iic :
    ∀ {𝕜 : Type u_1} {β : Type u_4} [inst : OrderedSemiring 𝕜] [inst_1 : OrderedAddCommMonoid β] [inst_2 : Module 𝕜 β]
      [inst_3 : OrderedSMul 𝕜 β] (r : β), Convex 𝕜 (Set.Iic r) :=
  by sorry

This theorem states that for any given type `𝕜` which is an ordered semiring, type `β` which is an ordered additive commutative monoid, and also a module over `𝕜` with the scalar multiplication being ordered, and for any element `r` of type `β`, the set `Set.Iic r` is convex. In other words, an interval of the form `(-∞, r]` in the ordered additive commutative monoid `β` is a convex set under the scalar multiplication ordered semiring `𝕜`.

Given an ordered semiring `𝕜`, an ordered additive commutative monoid `β` that is a `𝕜`-module with ordered scalar multiplication, and an element `r` of `β`, the interval `Set.Iic r` is convex.


theorem AbsoluteValue.map_sub :
    ∀ {R : Type u_3} {S : Type u_4} [inst : OrderedCommRing S] [inst_1 : Ring R] (abv : AbsoluteValue R S)
      [inst_2 : NoZeroDivisors S] (a b : R), abv (a - b) = abv (b - a) :=
  by sorry

This theorem states that for any two elements `a` and `b` from a ring `R` and an absolute value function `abv` mapping from this ring `R` to an ordered commutative ring `S` that has no zero divisors, the absolute value of the difference `a - b` is equal to the absolute value of the difference `b - a`. In mathematical terms, this can be written as |a - b| = |b - a|. This is a fundamental property of absolute values, reflecting the idea that the absolute value of a difference is insensitive to the order of subtraction.

For any ring `R` with absolute value function `abv` mapping from `R` to an ordered commutative ring `S` with no zero divisors, |a - b| = |b - a| for all `a, b` in `R`.


theorem Mathlib.Data.Set.Lattice._auxLemma.9 :
    ∀ {α : Type u} {β : Type v} (f : α → β) (s : Set α) (y : β), (y ∈ f '' s) = ∃ x ∈ s, f x = y := by sorry

This theorem, titled `Mathlib.Data.Set.Lattice._auxLemma.9`, states that for any types `α` and `β`, for any function `f` from `α` to `β`, for any set `s` of elements of type `α`, and for any element `y` of type `β`, the condition "y is in the image of set s under function f" is equivalent to saying "there exists an element x in set s such that f applied to x equals y". In other words, it characterizes membership in the image of a set under a function in terms of the existence of a pre-image under the function.

For any functions between types and sets, an element belongs to the image of a set under the function if and only if there exists an element in the set mapping to that image under the function.


theorem PartialEquiv.image_source_inter_eq' :
    ∀ {α : Type u_1} {β : Type u_2} (e : PartialEquiv α β) (s : Set α),
      ↑e '' (e.source ∩ s) = e.target ∩ ↑(PartialEquiv.symm e) ⁻¹' s :=
  by sorry

This theorem states that for any given partial equivalence `e` between types `α` and `β`, and for any set `s` of elements of type `α`, the image of the intersection between the source of `e` and `s` under `e` is equal to the intersection of the target of `e` and the pre-image of `s` under the inverse of `e`. In simpler words, this is about how intersections behave under the mapping of a partial equivalence and its inverse.

Let `e` be a partial equivalence between types `α` and `β`, then `e''(α∩s) = β∩e′"(s)`, where `s` is a set of elements from `α`, `e''` is the image function of `e`, and `e'` is the inverse of `e`.


/-- If `F` is cover-preserving and compatible-preserving,
then `F` is a continuous functor.

This result is basically <https://stacks.math.columbia.edu/tag/00WW>.
 -/
theorem CategoryTheory.Functor.isContinuous_of_coverPreserving :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂}
      [inst_1 : CategoryTheory.Category.{v₂, u₂} D] {F : CategoryTheory.Functor C D}
      {J : CategoryTheory.GrothendieckTopology C} {K : CategoryTheory.GrothendieckTopology D},
      CategoryTheory.CompatiblePreserving K F →
        CategoryTheory.CoverPreserving J K F → CategoryTheory.Functor.IsContinuous F J K :=
  by sorry

This theorem states that, given two categories `C` and `D` along with a functor `F` from `C` to `D`, and two Grothendieck topologies `J` on `C` and `K` on `D`, if `F` is compatible-preserving with respect to the topology `K` and cover-preserving with respect to the topologies `J` and `K`, then `F` is a continuous functor between `C` and `D` with respect to the topologies `J` and `K`. This is essentially a Lean formulation of the mathematical result found at https://stacks.math.columbia.edu/tag/00WW.

Given functors F : C -> D between categories C and D, and Grothendieck topologies J on C and K on D, if F preserves covers with respect to J and K, and is compatible-preserving with respect to K, then F is a continuous functor between (C, J) and (D, K).


theorem sq_pos_of_ne_zero : ∀ {R : Type u_3} [inst : LinearOrderedRing R] (a : R), a ≠ 0 → 0 < a ^ 2 := by sorry

This theorem, `sq_pos_of_ne_zero`, states that for any type `R` that is a linearly ordered ring (as specified by the type class `LinearOrderedRing R`), if an element `a` of `R` is not zero, then the square of `a` (denoted as `a ^ 2`) is always greater than zero. In other words, squaring any non-zero element in a linearly ordered ring gives a positive result.

For any linearly ordered ring `R` and non-zero element `a` in `R`, `a^2` is positive.


IsCoveringMap.isLocalHomeomorph

theorem IsCoveringMap.isLocalHomeomorph :
    ∀ {E : Type u_1} {X : Type u_2} [inst : TopologicalSpace E] [inst_1 : TopologicalSpace X] {f : E → X},
      IsCoveringMap f → IsLocalHomeomorph f :=
  by sorry

This theorem states that for any types `E` and `X` equipped with topological space structures and for any function `f` from `E` to `X`, if `f` is a covering map (i.e., it is continuous, its fibers are discrete, and each point in `X` has an evenly covered neighborhood), then `f` is also a local homeomorphism. In other words, each point in `E` is contained in the source of some partial homeomorphism from `E` to `X` that coincides with `f`.

If `f` : `E` → `X` is a continuous function between topological spaces `E` and `X` such that `f` is a covering map (i.e., its fibers are discrete and each point in `X` has an evenly covered neighborhood), then `f` is a local homeomorphism.


theorem Function.iterate_zero : ∀ {α : Type u} (f : α → α), f^[0] = id := by sorry

This theorem states that for every function `f` from type `α` to `α`, the zeroth iteration of `f` is the identity function. In other words, applying `f` zero times to any input produces the input itself. This is akin to raising a number to the power of zero - the output is always 1, the multiplicative identity. Here, instead of multiplication, we're doing function composition, and the identity function is the "do nothing" operation.

For every function `f` from type `α` to `α`, the identity function is the identity of function composition with `f`, i.e., `id ∘ f = f ∘ id = f`.


theorem ENNReal.le_tsum : ∀ {α : Type u_1} {f : α → ENNReal} (a : α), f a ≤ ∑' (a : α), f a := by sorry

This theorem states that for any type `α` and for any function `f` from `α` to the extended nonnegative real numbers (`ENNReal`), for any element `a` of `α`, the value of the function `f` at `a` is less than or equal to the sum over all elements of `α` of the function `f`. In other words, in mathematical notation, for all `a` in `α`, we have `f(a) ≤ Σ f(a')` where the sum is taken over all `a'` in `α`. This represents a fundamental property of sums in the context of measure theory.

For any function `f` from a type `α` to extended nonnegative real numbers, and for any `a` in `α`, we have `f(a) ≤ Σ (f a')` where the sum is taken over all `a'` in `α`.


theorem Nat.Partrec.of_primrec : ∀ {f : ℕ → ℕ}, Nat.Primrec f → Nat.Partrec ↑f := by sorry

This theorem states that for any function `f` from natural numbers to natural numbers, if `f` is primitive recursive (denoted as `Nat.Primrec f`), then `f` is partially recursive (denoted as `Nat.Partrec ↑f`). In other words, the set of primitive recursive functions is a subset of the set of partial recursive functions.

Every primitive recursive function is partially recursive.


/-- If all `f i`, `i ∈ s`, are nonnegative and each `f i` is less than or equal to `g i`, then the
product of `f i` is less than or equal to the product of `g i`. See also `Finset.prod_le_prod'` for
the case of an ordered commutative multiplicative monoid.  -/
theorem Finset.prod_le_prod :
    ∀ {ι : Type u_1} {R : Type u_8} [inst : CommMonoidWithZero R] [inst_1 : PartialOrder R] [inst_2 : ZeroLEOneClass R]
      [inst_3 : PosMulMono R] {f g : ι → R} {s : Finset ι},
      (∀ i ∈ s, 0 ≤ f i) → (∀ i ∈ s, f i ≤ g i) → (Finset.prod s fun i => f i) ≤ Finset.prod s fun i => g i :=
  by sorry

The theorem `Finset.prod_le_prod` states that for a given set `s` of type `ι` and two functions `f, g: ι → R` where `R` is a commutative monoid with zero, a partial order, and where multiplication is monotonic for nonnegative elements, if all elements `f i` for `i ∈ s` are nonnegative, and each `f i` is less than or equal to `g i`, then the total product of `f i` over all `i` in `s` is less than or equal to the total product of `g i` over all `i` in `s`. This theorem is also applicable to an ordered commutative multiplicative monoid.

Given a commutative monoid with zero, partial order, and monotonic multiplication for nonnegative elements `R`, and functions `f, g: ι → R` with nonnegative and `≤`-related images on a set `s`, the total product of `f i` over `i ∈ s` is less than or equal to the total product of `g i` over `i ∈ s`.


theorem Finsupp.supported_eq_span_single :
    ∀ {α : Type u_1} (R : Type u_5) [inst : Semiring R] (s : Set α),
      Finsupp.supported R R s = Submodule.span R ((fun i => fun₀ | i => 1) '' s) :=
  by sorry

This theorem states that for any given set `s` of type `α` and a semiring `R`, the `R`-submodule of all functions `p : α → R` such that the support of `p` is a subset of `s` (defined as `Finsupp.supported R R s`) is equal to the smallest submodule of `R` that contains the image set under the function which maps each element `i` in `s` to the function `fun₀ | i => 1` (defined as `Submodule.span R ((fun i => fun₀ | i => 1) '' s)`). Essentially, it says that the submodule of functions with support in `s` is the same as the submodule spanned by the singleton functions for each element in `s`.

The submodule of functions on a set `α` with support in a subset `s` is equal to the submodule spanned by the singleton functions for elements in `s`.


theorem and_congr_left_iff : ∀ {a c b : Prop}, (a ∧ c ↔ b ∧ c) ↔ c → (a ↔ b) := by sorry

This theorem, `and_congr_left_iff`, states that for any three propositions `a`, `b`, and `c`, the equivalence between "a and c" and "b and c" is equivalent to the implication from `c` to the equivalence of `a` and `b`. In other words, if `c` is true, then "a and c" is equivalent to "b and c" if and only if `a` is equivalent to `b`.

For propositions `a`, `b`, and `c`, `(a ∧ c) ≈ (b ∧ c)` if and only if `a ≈ b`.


theorem Finset.image_id' : ∀ {α : Type u_1} {s : Finset α} [inst : DecidableEq α], Finset.image (fun x => x) s = s := by
  sorry

The theorem `Finset.image_id'` states that for all types `α` and all finite sets `s` of this type, assuming `α` has decidable equality, the image of the set `s` under the identity function (i.e., each element of the set is mapped to itself) is equal to the original set `s`. This essentially means applying the identity function to a finite set does not change the set.

For any type `α` with decidable equality and finite set `s` of `α`, the image of `s` under the identity function is equal to `s`.


theorem DirectSum.of_mul_of :
    ∀ {ι : Type u_1} [inst : DecidableEq ι] {A : ι → Type u_2} [inst_1 : Add ι] [inst_2 : (i : ι) → AddCommMonoid (A i)]
      [inst_3 : DirectSum.GNonUnitalNonAssocSemiring A] {i j : ι} (a : A i) (b : A j),
      (DirectSum.of A i) a * (DirectSum.of A j) b = (DirectSum.of A (i + j)) (GradedMonoid.GMul.mul a b) :=
  by sorry

The theorem `DirectSum.of_mul_of` states that for any type `ι` with decidable equality, a type `A` which is a function from `ι` to another type, and for any `i` and `j` of type `ι`, and `a` and `b` of type `A i` and `A j` respectively, the product of the direct sum of `A i` and `A j` equals the direct sum of `A` at the sum of `i` and `j` with the graded monoid multiplication of `a` and `b`. This theorem is applicable under the condition that `A i` and `A j` are additive commutative monoids and `A` is a graded non-unital non-associative semiring. The result basically outlines the interaction between the direct sum operation and the multiplication operation in a graded algebraic structure.

For any additive commutative monoids `A i` indexed by a decidably equal type `ι`, the graded product of `A i` in a graded non-unital non-associative semiring equals the direct sum of the graded multiplication of their elements.


AEMeasurable.inv

theorem AEMeasurable.inv :
    ∀ {G : Type u_2} {α : Type u_3} [inst : Inv G] [inst_1 : MeasurableSpace G] [inst_2 : MeasurableInv G]
      {m : MeasurableSpace α} {f : α → G} {μ : MeasureTheory.Measure α},
      AEMeasurable f μ → AEMeasurable (fun x => (f x)⁻¹) μ :=
  by sorry

The theorem `AEMeasurable.inv` states that for any types `G` and `α` where `G` has an `Inv` instance and a `MeasurableSpace` instance and also a `MeasurableInv` instance, and given a measurable space `m` on `α`, a function `f` from `α` to `G`, and a measure `μ` on `α`, if `f` is almost everywhere measurable (i.e., it is equal almost everywhere to a measurable function), then the function that takes `x` to the inverse of `f(x)` is also almost everywhere measurable.

If `f` is almost everywhere measurable from a measurable space `(α, Σ, μ)` to a measurable space `(G, ℬ, ν)` where `G` has an `Inv` and `MeasurableSpace` instance, then the function `x ↦ Inv(f(x))` is almost everywhere measurable.


/-- If `x` is not an isolated point of a topological space, then `{x}ᶜ` is dense in the whole
space.  -/
theorem dense_compl_singleton :
    ∀ {X : Type u} [inst : TopologicalSpace X] (x : X) [inst_1 : Filter.NeBot (nhdsWithin x {x}ᶜ)], Dense {x}ᶜ := by
  sorry

The theorem `dense_compl_singleton` states that for any topological space `X` and any point `x` in `X`, if `x` is not an isolated point (which means that every neighborhood of `x` contains other points than `x` itself), then the set of all points in `X` excluding `x` (denoted by `{x}ᶜ`) is dense in `X`. In mathematical terms, every point in `X` is either in `{x}ᶜ` or it is a limit point of `{x}ᶜ`, i.e., every neighborhood of the point contains a point from `{x}ᶜ`.

If a point in a topological space is not isolated, then the complement of that point is dense in the space.


theorem WithTop.top_mul :
    ∀ {α : Type u_1} [inst : DecidableEq α] [inst_1 : MulZeroClass α] {b : WithTop α}, b ≠ 0 → ⊤ * b = ⊤ := by sorry

The `WithTop.top_mul` theorem states that for any type `α` that has a decidable equality and a multiplication operation with a zero, if we extend this type `α` to include a top element `⊤` (which we do by using `WithTop α`), then the product of the `⊤` and any element `b` of this extended type, provided `b` is not zero, is also `⊤`. This property is similar to some properties of infinity in mathematics, where, barring exceptions, the product of infinity and any non-zero number is still infinity.

If `α` is a type with decidable equality and a multiplication operation with a zero, then in the extended type `WithTop α`, `⊤ * b = ⊤` for all `b ≠ 0` in `α`.


theorem MonoidHom.rangeRestrict_surjective :
    ∀ {G : Type u_1} [inst : Group G] {N : Type u_5} [inst_1 : Group N] (f : G →* N),
      Function.Surjective ⇑(MonoidHom.rangeRestrict f) :=
  by sorry

The theorem `MonoidHom.rangeRestrict_surjective` states that for all groups `G` and `N` and for any group homomorphism `f` from `G` to `N`, the canonical surjective group homomorphism `MonoidHom.rangeRestrict f` is surjective. In other words, for every element in the codomain of `MonoidHom.rangeRestrict f`, there exists at least one element in the domain `G` such that the function `MonoidHom.rangeRestrict f` applied to this element gives the element in the codomain. This makes the range restriction of a group homomorphism a surjective function.

For any group homomorphism from a group to another, the range restriction is a surjective function.


theorem Cardinal.toNat_apply_of_aleph0_le : ∀ {c : Cardinal.{u_1}}, Cardinal.aleph0 ≤ c → Cardinal.toNat c = 0 := by
  sorry

The theorem `Cardinal.toNat_apply_of_aleph0_le` asserts that for any cardinal number `c`, if `c` is greater than or equal to `ℵ₀` (the smallest infinite cardinal number), the function `Cardinal.toNat` applied to `c` equals to zero. In other words, this theorem is stating that the function `Cardinal.toNat` maps infinite cardinal numbers to zero. The function `Cardinal.toNat` is designed to send finite cardinal numbers to their corresponding natural numbers, and all infinite cardinal numbers to zero.

For any cardinal number `c` greater than or equal to `ℵ₀`, `Cardinal.toNat c = 0`.


theorem Function.IsPeriodicPt.minimalPeriod_dvd :
    ∀ {α : Type u_1} {f : α → α} {x : α} {n : ℕ}, Function.IsPeriodicPt f n x → Function.minimalPeriod f x ∣ n := by
  sorry

The theorem `Function.IsPeriodicPt.minimalPeriod_dvd` states that for any type `α`, function `f` of type `α → α`, point `x` of type `α`, and natural number `n`, if `x` is a periodic point of `f` with period `n`, then the minimal period of `x` under `f` divides `n`. In other words, if the function `f`, when applied `n` times to `x`, brings us back to `x`, then `n` is a multiple of the smallest such number of applications of `f` to `x` that bring us back to `x`.

If `x` is a periodic point of period `n` for function `f: α → α`, then the minimal period of `x` under `f` divides `n`.


/-- For every prime `p` dividing the order of a finite group `G` there exists an element of order
`p` in `G`. This is known as Cauchy's theorem.  -/
theorem exists_prime_orderOf_dvd_card :
    ∀ {G : Type u_3} [inst : Group G] [inst_1 : Fintype G] (p : ℕ) [hp : Fact (Nat.Prime p)],
      p ∣ Fintype.card G → ∃ x, orderOf x = p :=
  by sorry

The theorem `exists_prime_orderOf_dvd_card` states that for any prime number `p` that divides the order (i.e., number of elements) of a finite group `G`, there exists an element in `G` whose order is `p`. This is known as Cauchy's theorem in group theory. In other words, if the size of a finite group is divisible by a prime number, then the group contains an element of which the order is equal to that prime number.

For any prime number `p` that divides the order of a finite group `G`, there exists an element in `G` with order `p`.


theorem Mathlib.Order.OmegaCompletePartialOrder._auxLemma.12 :
    ∀ {α : Type u} [inst : OmegaCompletePartialOrder α] (c : OmegaCompletePartialOrder.Chain α) (x : α),
      (OmegaCompletePartialOrder.ωSup c ≤ x) = ∀ (i : ℕ), c i ≤ x :=
  by sorry

This theorem states that for any type `α` equipped with an Omega Complete Partial Order structure, any chain `c` of elements of type `α`, and any element `x` of type `α`, the condition that the supremum (ωSup) of the chain `c` is less than or equal to `x` is equivalent to the condition that every element of the chain `c` is less than or equal to `x`. In more mathematical terms, for all i in ℕ (the set of natural numbers), the i-th element of the chain `c` is less than or equal to `x`.

For any Omega Complete Partial Order (OP) `α`, chain `c` in `α`, and `x` in `α`, `sup c <= x` if and only if `c.i <= x` for all `i` in `N`.


theorem Polynomial.eraseLead_support :
    ∀ {R : Type u_1} [inst : Semiring R] (f : Polynomial R),
      Polynomial.support (Polynomial.eraseLead f) = Finset.erase (Polynomial.support f) (Polynomial.natDegree f) :=
  by sorry

This theorem states that for any polynomial `f` over a semiring `R`, the support set (the set of all exponents `n` such that `X^n` has a non-zero coefficient) of the polynomial obtained by erasing the leading term of `f` is equal to the support set of `f` with the degree of `f` removed. In other words, when you remove the highest degree term from a polynomial, the set of remaining non-zero coefficients corresponds to the original polynomial's support set minus the highest degree.

For any polynomial `f` over a semiring `R`, the support sets of `f` and the polynomial obtained by erasing its leading term differ only by the highest degree.


theorem Real.IsConjExponent.conj_eq : ∀ {p q : ℝ}, Real.IsConjExponent p q → q = p / (p - 1) := by sorry

The theorem `Real.IsConjExponent.conj_eq` states that for any two real numbers `p` and `q`, if `p` and `q` are conjugate exponents (as defined by the relation `Real.IsConjExponent p q`), then `q` is equal to `p` divided by `p - 1`. This relationship is a key aspect of the definition of conjugate exponents in mathematical analysis.

If `p` and `q` are conjugate exponents in the real numbers, then `q = p / (p - 1)`.


theorem Int.neg_log_inv_eq_clog :
    ∀ {R : Type u_1} [inst : LinearOrderedSemifield R] [inst_1 : FloorSemiring R] (b : ℕ) (r : R),
      -Int.log b r⁻¹ = Int.clog b r :=
  by sorry

This theorem states that for any natural number `b` and any value `r` from a linear ordered semifield `R` that also forms a floor semiring, the negative logarithm base `b` of the inverse of `r` is equal to the ceiling logarithm base `b` of `r`. In simpler terms, it suggests an equivalence between the greatest power of `b` that is not greater than the inverse of `r`, and the smallest power of `b` that is not less than `r`, when the signs are flipped.

For any natural number `b` and any element `r` in a linear ordered semigroup with floor semilattices, the ceiling logarithm base `b` of `r` equals the negative logarithm base `b` of `r^(-1)`.


Symmetric.iff

theorem Symmetric.iff : ∀ {α : Type u_1} {r : α → α → Prop}, Symmetric r → ∀ (x y : α), r x y ↔ r y x := by sorry

The theorem `Symmetric.iff` states that for any type `α` and a binary relation `r` on `α`, if the relation `r` is symmetric, then for all elements `x` and `y` of `α`, `r x y` is true if and only if `r y x` is true. In other words, a relation is symmetric if it holds that whenever `x` is related to `y`, `y` is also related to `x`.

For any binary relation `r` on type `α`, `r` is symmetric if and only if for all `x` and `y` in `α`, `r x y` implies `r y x`.


/-- See also `interior_preimage_subset_preimage_interior`.  -/
theorem preimage_interior_subset_interior_preimage :
    ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {f : X → Y} {t : Set Y},
      Continuous f → f ⁻¹' interior t ⊆ interior (f ⁻¹' t) :=
  by sorry

This theorem states that for any two types `X` and `Y`, each equipped with a topological space structure, along with a function `f` from `X` to `Y` and a set `t` of type `Y`, if the function `f` is continuous, then the preimage of the interior of set `t` under `f` is a subset of the interior of the preimage of `t` under `f`. In other words, if you first take the interior of a set and then find the preimage under a continuous function, this will always be a subset of what you get if you first find the preimage of the original set and then take the interior. This theorem is a fundamental property that relates the concepts of continuity, preimages, and interiors in the context of topological spaces.

For any continuous function between topological spaces and any sets with interiors, the interior of the preimage is contained in the preimage of the interior.


/-- The Jordan decomposition of a signed measure is unique.  -/
theorem MeasureTheory.JordanDecomposition.toSignedMeasure_injective :
    ∀ {α : Type u_1} [inst : MeasurableSpace α], Function.Injective MeasureTheory.JordanDecomposition.toSignedMeasure :=
  by sorry

The theorem states that the Jordan decomposition of a signed measure is unique. In other words, in the context of a measurable space, the function `MeasureTheory.JordanDecomposition.toSignedMeasure` is injective, which means that given any two Jordan decompositions, if their associated signed measures are the same, it implies that the two Jordan decompositions themselves are identical. This reflects that each signed measure has a unique Jordan decomposition.

The Jordan decomposition of a signed measure is unique. That is, if two measures have the same Jordan decomposition, then they are equal.


theorem SetTheory.PGame.lt_congr : ∀ {x₁ y₁ x₂ y₂ : SetTheory.PGame}, x₁ ≈ x₂ → y₁ ≈ y₂ → (x₁ < y₁ ↔ x₂ < y₂) := by
  sorry

This theorem states that in set theory, specifically regarding games, if two games `x₁` and `x₂` are equivalent, and two other games `y₁` and `y₂` are also equivalent, then the inequality (less than) relationship between `x₁` and `y₁` is the same as the inequality relationship between `x₂` and `y₂`. Essentially, equivalence in games preserves the inequality relationship.

If games `x₁` and `x₂`, and `y₁` and `y₂` are equivalent, then `x₁ < y₁` if and only if `x₂ < y₂`.


theorem Polynomial.aeval_X_pow :
    ∀ {R : Type u} {A : Type z} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A] (x : A) {n : ℕ},
      (Polynomial.aeval x) (Polynomial.X ^ n) = x ^ n :=
  by sorry

The theorem `Polynomial.aeval_X_pow` states that for any commutative semiring `R`, any semiring `A`, and any algebra `A` over `R`, giving any element `x` from `A` and any natural number `n`, the application of the unique `R`-algebra homomorphism (denoted as `Polynomial.aeval x`) to the `n`-th power of the polynomial variable `Polynomial.X` is equal to the `n`-th power of `x`. In other words, when we evaluate the `n`-th power of the polynomial variable at `x`, we get the `n`-th power of `x`. This is a property of algebra homomorphisms that map polynomial expressions in `R[X]` to members of an `R`-algebra `A` by replacing the polynomial variable `X` with a specific value `x` from `A`.

For any commutative semiring `R`, semiring `A` with an `R`-algebra structure, and `x` in `A`, the `R`-algebra homomorphism `Polynomial.aeval` satisfies `Polynomial.aeval (X ^ n) x = x ^ n` for all natural numbers `n`.


theorem EuclideanDomain.mod_lt :
    ∀ {R : Type u} [inst : EuclideanDomain R] (a : R) {b : R}, b ≠ 0 → EuclideanDomain.r (a % b) b := by sorry

This theorem states that for any type `R` having the structure of a Euclidean Domain, and for any elements `a` and `b` of `R` where `b` is not zero, the relation `EuclideanDomain.r` holds between the modulus of `a` and `b` and `b` itself. This captures the property of the Euclidean algorithm where the remainder of division (`a % b`) is less than the divisor (`b`). In essence, this is the well-foundedness condition that ensures the Euclidean algorithm always terminates.

For any Euclidean Domain `R` and non-zero elements `a` and `b` in `R`, the relation `|a| >= |b|` implies `|a mod b| < |b|`.


theorem AddSubgroup.eq_bot_iff_forall :
    ∀ {G : Type u_1} [inst : AddGroup G] (H : AddSubgroup G), H = ⊥ ↔ ∀ x ∈ H, x = 0 := by sorry

This theorem states that for any given additive subgroup `H` of an additive group `G`, `H` is identical to the trivial group (denoted as `⊥`) if and only if all elements `x` in `H` are the zero element of the group. In other words, an additive subgroup is the trivial group if every element in it is zero.

An additive subgroup of a group is the trivial subgroup if and only if every element in it is the additive identity.


theorem Real.Angle.sign_neg : ∀ (θ : Real.Angle), Real.Angle.sign (-θ) = -Real.Angle.sign θ := by sorry

This theorem states that for every real angle `θ`, the sign of the negative of that angle is the negative of the sign of the angle. In other words, if we negate an angle and then take the sign, it's the same as taking the sign of the original angle and then negating it. This is equivalent to the mathematical statement that for all real angles θ, sign(-θ) = -sign(θ), where sign refers to the definition provided which determines the sign based on the sine of the angle.

For all real angles θ, sign(-θ) = -sign(θ).


theorem Nat.eq_mul_of_div_eq_right : ∀ {a b c : ℕ}, b ∣ a → a / b = c → a = b * c := by sorry

This theorem states that for any three natural numbers `a`, `b`, and `c`, if `b` divides `a` and the result of dividing `a` by `b` is `c`, then `a` is equal to the product of `b` and `c`. In other words, it formalizes the arithmetic property that if a number `a` is evenly divisible by `b` yielding a quotient `c`, then `a` can also be represented by the multiplication of `b` and `c`.

If `a` is divisible by `b` with remainder `c`, then `a` equals `b` times `c`.


theorem quasiIsoAt_iff :
    ∀ {ι : Type u_2} {C : Type u} [inst : CategoryTheory.Category.{v, u} C]
      [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] {c : ComplexShape ι} {K L : HomologicalComplex C c}
      (f : K ⟶ L) (i : ι) [inst_2 : HomologicalComplex.HasHomology K i] [inst_3 : HomologicalComplex.HasHomology L i],
      QuasiIsoAt f i ↔ CategoryTheory.ShortComplex.QuasiIso ((HomologicalComplex.shortComplexFunctor C c i).map f) :=
  by sorry

In the setting of category theory, the theorem `quasiIsoAt_iff` establishes an equivalence between two properties concerning homological complexes. Given types `ι` and `C`, with `C` being a category that has zero morphisms, a complex shape `c`, and two homological complexes `K` and `L` over `C` with shape `c`, as well as a morphism `f` from `K` to `L` and an index `i` in `ι`, the theorem states that `f` is a quasi-isomorphism at the level `i` if and only if the map induced by `f` on the short complexes associated with `K` and `L` at level `i` is a quasi-isomorphism in the category of short complexes. This equivalence holds under the assumption that both `K` and `L` have homology at degree `i`.

A morphism between homological complexes over a zero-morphism category is a quasi-isomorphism at a given degree if and only if the induced map on short complexes at that degree is a quasi-isomorphism. (Assumes homology exists at that degree.)


theorem MeasureTheory.ae_restrict_iff :
    ∀ {α : Type u_2} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} {s : Set α} {p : α → Prop},
      MeasurableSet {x | p x} → ((∀ᵐ (x : α) ∂μ.restrict s, p x) ↔ ∀ᵐ (x : α) ∂μ, x ∈ s → p x) :=
  by sorry

The theorem `MeasureTheory.ae_restrict_iff` states that for any type `α`, measurable space `m0`, measure `μ`, set `s` of `α`, and a property `p` of `α`, if the set of elements that satisfy the property `p` is a measurable set, then a property `p` holds almost everywhere (`∀ᵐ (x : α)`) under the restriction of the measure `μ` to the set `s` if and only if (`↔`) the property `p` holds almost everywhere under the measure `μ` whenever the element `x` is in the set `s`. This theorem essentially captures the relationship between a property holding almost everywhere under a restricted measure and the same property holding almost everywhere under the original measure conditional on set membership.

For any measurable space `(α, Σ, μ)`, set `s ∈ Σ`, and property `p(x) : Prop` such that `{x : α | p x} ∈ Σ`, the property `p` holds almost everywhere in `s` if and only if it holds almost everywhere in `α` for elements `x` in `s`.


theorem NNReal.rpow_self_rpow_inv : ∀ {y : ℝ}, y ≠ 0 → ∀ (x : NNReal), (x ^ (1 / y)) ^ y = x := by sorry

The theorem `NNReal.rpow_self_rpow_inv` states that for any non-zero real number `y`, and for any non-negative real number `x`, when `x` is raised to the power of `1/y` and the result is then raised to the power `y`, we get back the original number `x`. In mathematical terms, this can be written as \((x^{(1/y)})^y = x\). This theorem is essentially a version of the property of exponents which states that raising a number to the power of a fraction and then raising the result to the inverse of that fraction will return the original number.

For any non-zero real number `y` and non-negative real number `x`, `x^(1/y) * x^y = x`.


theorem MonoidAlgebra.liftNC_single :
    ∀ {k : Type u₁} {G : Type u₂} {R : Type u_2} [inst : Semiring k] [inst_1 : NonUnitalNonAssocSemiring R] (f : k →+ R)
      (g : G → R) (a : G) (b : k), (MonoidAlgebra.liftNC f g) (MonoidAlgebra.single a b) = f b * g a :=
  by sorry

The theorem `MonoidAlgebra.liftNC_single` states that for any semiring `k`, any type `G`, and any non-unital, non-associative semiring `R`, given a semiring homomorphism `f` from `k` to `R`, a function `g` from `G` to `R`, an element `a` of `G` and an element `b` of `k`, applying the `liftNC` function of the monoid algebra on the `single` function of the monoid algebra for `a` and `b` equals the multiplication of the result of applying `f` on `b` and applying `g` on `a`. In mathematical terms, this can be written as $(\text{liftNC } f \; g)(\text{single } a \; b) = f(b) \cdot g(a)$.

For any semiring homomorphism $f$ from $k$ to a non-unital, non-associative semiring $R$, any function $g$ from a type $G$ to $R$, and any elements $a$ in $G$ and $b$ in $k$, we have $(\text{liftNC } f \; g)(\text{single } a \; b) = f(b) \cdot g(a)$.


theorem Subgroup.relindex_bot_left :
    ∀ {G : Type u_1} [inst : Group G] (H : Subgroup G), Subgroup.relindex ⊥ H = Nat.card ↥H := by sorry

This theorem states that for any given group `G` and a subgroup `H` of `G`, the relative index of the trivial subgroup (denoted by `⊥`) and `H` is equal to the cardinality of `H` expressed as a natural number. In other words, this is saying that the number of cosets of `H` in the trivial subgroup is equal to the number of elements in `H`. This makes sense since the trivial subgroup contains only the identity element of the group, so each element of `H` forms its own coset.

The relative index of the trivial subgroup and a subgroup `H` of a group `G` is equal to the cardinality of `H`.


theorem Set.BijOn.perm_inv :
    ∀ {α : Type u_1} {f : Equiv.Perm α} {s : Set α}, Set.BijOn (⇑f) s s → Set.BijOn (⇑f⁻¹) s s := by sorry

This theorem states that for any type `α`, given a permutation `f` (a bijective function) from `α` to `α` and a set `s` of type `α`, if `f` is bijective on the set `s` to itself (that is, `f` maps every element of `s` to a unique element in `s` and covers all elements of `s`), then the inverse of `f` is also bijective on the set `s` to itself. In other words, the inverse of a bijective function (permutation) on a set is again a bijective function on that same set.

If `f` is a bijective function from a set `α` to itself, then the inverse function `f⁻¹` is also a bijective function from `f`'s image in `α` back to `α`.


AEMeasurable.fst

theorem AEMeasurable.fst :
    ∀ {α : Type u_1} {β : Type u_3} {γ : Type u_5} [inst : MeasurableSpace α] [inst_1 : MeasurableSpace β]
      [inst_2 : MeasurableSpace γ] {μ : MeasureTheory.Measure α} {ν : MeasureTheory.Measure β}
      [inst_3 : MeasureTheory.SFinite ν] {f : α → γ},
      AEMeasurable f μ → AEMeasurable (fun z => f z.1) (MeasureTheory.Measure.prod μ ν) :=
  by sorry

This theorem states that for any function `f`, from a type `α` to a type `γ`, which is almost everywhere measurable with respect to a measure `μ` on `α`, the function that takes a pair `(z1, z2)` to `f(z1)` is also almost everywhere measurable with respect to the product measure of `μ` and another measure `ν` on a type `β`. This holds under the condition that the measure `ν` is s-finite, meaning it can be decomposed into a countably finite union of sets with finite measure.

If `μ` is a measure on `α` and `ν` is an s-finite measure on `β`, then the function `(z1, z2) mapsto f(z1)` is almost everywhere measurable with respect to the product measure of `μ` and `ν`, for any almost everywhere measurable function `f` from `α` to `γ`.


theorem CategoryTheory.Limits.IsTerminal.hasTerminal :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X : C},
      CategoryTheory.Limits.IsTerminal X → CategoryTheory.Limits.HasTerminal C :=
  by sorry

This theorem states that for any Category `C` and object `X` in this category, if `X` is a terminal object (i.e., `CategoryTheory.Limits.IsTerminal X` holds), then the category `C` itself has a terminal object (i.e., `CategoryTheory.Limits.HasTerminal C` holds). In category theory, a terminal object is one for which there is a unique morphism from any other object in the category to the terminal object. Thus, the theorem essentially establishes the existence of a terminal object in the category if any one of its objects is terminal.

If an object `X` in a category `C` is terminal, then `C` itself has a terminal object.


ContDiffBump.nonneg

theorem ContDiffBump.nonneg :
    ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [inst_2 : HasContDiffBump E] {c : E}
      (f : ContDiffBump c) {x : E}, 0 ≤ ↑f x :=
  by sorry

This theorem states that for any type `E`, given it forms a normalized additive commutative group and a normalized real vector space, and has a continuously differentiable "bump" function (a function that is equal to one at a particular point and decreases to zero as you move away from that point), then for any such bump function `f` centered at a point `c` and any point `x` in `E`, the value of the bump function at `x` is always non-negative. This means that the bump function never dips below the x-axis, regardless of the point you're evaluating it at.

Given a normalized additive commutative group `E` with a real vector space structure and a continuously differentiable "bump" function `f` on `E` with center `c`, the function `f` is non-negative on `E`, i.e., `f x ≥ 0` for all `x` in `E`.


BoxIntegral.HasIntegral.integrable

theorem BoxIntegral.HasIntegral.integrable :
    ∀ {ι : Type u} {E : Type v} {F : Type w} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E]
      [inst_2 : NormedAddCommGroup F] [inst_3 : NormedSpace ℝ F] {I : BoxIntegral.Box ι} [inst_4 : Fintype ι]
      {l : BoxIntegral.IntegrationParams} {f : (ι → ℝ) → E} {vol : BoxIntegral.BoxAdditiveMap ι (E →L[ℝ] F) ⊤} {y : F},
      BoxIntegral.HasIntegral I l f vol y → BoxIntegral.Integrable I l f vol :=
  by sorry

This theorem states that for any function `f` from a real-valued vector to a normed add-commutative group `E` and any `vol` (which is a box-additive map from `ι` to the continuous linear map from `E` to a normed add-commutative group `F`), if `f` has an integral over a given box `I` according to a set of integration parameters `l`, that yields an element `y` of `F`, then `f` is integrable over box `I` with respect to the volume element `vol` and the integration parameters `l`. This holds for any given types `ι`, `E`, `F` and for any `I`, `l`, `f`, `vol`, `y` which satisfy the conditions described.

If a real-valued function `f` over a box `I` has an integral `y` with respect to a box-additive volume map `vol` and integration parameters `l` in the sense of Lean 4, then `f` is integrable over `I` with respect to `vol` and `l`.


FreeGroupBasis.isFreeGroup

/-- A group admitting a free group basis is a free group.  -/
theorem FreeGroupBasis.isFreeGroup :
    ∀ {ι : Type u_1} {G : Type u_3} [inst : Group G], FreeGroupBasis ι G → IsFreeGroup G := by sorry

This theorem states that for any types `ι` and `G`, given that `G` is a group, if `G` admits a free group basis indexed by `ι`, then `G` is itself a free group. In terms of abstract algebra, this means that if we can find a subset of a group that forms a free basis (i.e., each element of the group can be represented uniquely as a finite product of elements in the basis and their inverses), then the group is a free group.

If `G` is a group with a basis indexed by `ι`, then `G` is a free group.


IsSeparable.isIntegral

theorem IsSeparable.isIntegral :
    ∀ (F : Type u_1) {K : Type u_2} [inst : CommRing F] [inst_1 : Ring K] [inst_2 : Algebra F K]
      [inst_3 : IsSeparable F K] (x : K), IsIntegral F x :=
  by sorry

This theorem states that for every element `x` of a ring `K`, which is an algebra over a commutative ring `F`, the element `x` is integral if the algebra `K` over `F` is separable. In other words, the element `x` is a root of some monic polynomial with coefficients in `F`. This holds true for all types `F` and `K` where `F` is a commutative ring, `K` is a ring, `K` is an algebra over `F`, and `K` is separable over `F`.

If `K` is a separable algebra over the commutative ring `F`, then every element `x` in `K`, being an algebra over `F`, is a root of some monic polynomial with coefficients in `F`.


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

The theorem `isLUB_Ioo` states that for any type `γ` that is a semilattice under the infimum operation and is densely ordered, and for any two elements `a` and `b` of `γ` such that `a` is less than `b`, `b` is a least upper bound of the open interval `(a, b)`. In other words, no element in the open interval `(a, b)` is greater than `b`, and any element greater than or equal to `b` is not in the interval `(a, b)`.

For any semilattice `γ` with dense order and any `a < b` in `γ`, `b` is the least upper bound of the open interval `(a, b)`.


theorem Cycle.chain_coe_cons :
    ∀ {α : Type u_1} (r : α → α → Prop) (a : α) (l : List α), Cycle.Chain r ↑(a :: l) ↔ List.Chain r a (l ++ [a]) := by
  sorry

This theorem, `Cycle.chain_coe_cons`, states that for any type `α`, relation `r` over `α`, element `a` of type `α`, and a list `l` of elements of type `α`, the property `Cycle.Chain` holding for the cycle formed by appending `a` to the front of `l` is equivalent to the property `List.Chain` holding for the list formed by appending `a` to the end of `l`. In other words, a cycle `a :: l` has the chain property with respect to `r` if and only if the list `l ++ [a]` does. This property checks if the relation `r` holds between adjacent elements of the cycle or list.

For any type `α`, relation `r` over `α`, element `a` of type `α`, and list `l` of elements of type `α`, the cycle `[a] ++ l` has the chain property with respect to `r` if and only if the list `l ++ [a]` does.


theorem Representation.asAlgebraHom_single :
    ∀ {k : Type u_1} {G : Type u_2} {V : Type u_3} [inst : CommSemiring k] [inst_1 : Monoid G]
      [inst_2 : AddCommMonoid V] [inst_3 : Module k V] (ρ : Representation k G V) (g : G) (r : k),
      ((Representation.asAlgebraHom ρ) fun₀ | g => r) = r • ρ g :=
  by sorry

The theorem `Representation.asAlgebraHom_single` states that for any commutative semiring `k`, monoid `G`, and additively commutative monoid `V` that forms a `k`-module, and for any representation `ρ` of `G` on `V` over `k`, and any element `g` of `G` and `r` of `k`, applying the algebra homomorphism corresponding to the representation `ρ` to the monoid algebra element that maps `g` to `r` (and everything else to zero) results in the same as scaling the linear transformation corresponding to `g` under the representation `ρ` by `r`. In terms of linear algebra, this is asserting an interaction between the scalar multiplication in the module and the action of the group on the module via the representation.

For any commutative semiring `k`, monoid `G`, additively commutative `k`-module `V`, representation `ρ` of `G` on `V`, and `g` in `G` and `r` in `k`, the algebra homomorphism `ρ` applied to the monoid algebra element `r * ∑ (x : G) (ρ(x) * x)` equals the scalar multiplication `r * (ρ(g))` in `V` where `ρ(g)` is the linear transformation corresponding to `g` under the representation `ρ`.


theorem AbstractCompletion.continuous_extend :
    ∀ {α : Type u_1} [inst : UniformSpace α] (pkg : AbstractCompletion α) {β : Type u_2} [inst_1 : UniformSpace β]
      {f : α → β} [inst_2 : CompleteSpace β], Continuous (AbstractCompletion.extend pkg f) :=
  by sorry

The theorem `AbstractCompletion.continuous_extend` states that for any types `α` and `β` equipped with a uniform space structure, a completion `pkg` of `α`, and a function `f` from `α` to `β`, if `β` is a complete space, then the extension of the function `f` to the completed space `pkg.space` is continuous. Here, the extension of `f` is achieved by the `AbstractCompletion.extend` function.

Given a uniform space `α`, a completion `pkg.space` of `α`, a function `f : α → β` where `β` is a complete space, the theorem asserts that the extension of `f` to `pkg.space` via `AbstractCompletion.extend` is a continuous function.


theorem totallyBounded_Icc :
    ∀ {α : Type u} [inst : PseudoMetricSpace α] [inst_1 : Preorder α] [inst_2 : CompactIccSpace α] (a b : α),
      TotallyBounded (Set.Icc a b) :=
  by sorry

The theorem `totallyBounded_Icc` states that, for any type `α` which is a pseudometric space, has a preorder (an order relation that is reflexive and transitive), and has a compact interval [a, b], the closed interval [a, b] is totally bounded. In mathematical terms, this means that for any given metric `d` in the uniformity of `α`, there exists a finite set of points `t` such that every element in the interval [a, b] is `d`-near to at least one element in `t`. This property is fundamental in the study of compactness in metric spaces.

Given a pseudometric space `α` with a preorder and a compact interval `[a, b]`, the closed interval `[a, b]` is totally bounded, meaning for any metric `d` in the uniformity of `α`, there exists a finite set `t` such that every element in `[a, b]` is `d`-close to some element in `t`.


theorem List.perm_cons_erase :
    ∀ {α : Type u_1} [inst : DecidableEq α] {a : α} {l : List α}, a ∈ l → List.Perm l (a :: List.erase l a) := by sorry

The theorem `List.perm_cons_erase` states that for any type `α` with decidable equality, for any element `a` of type `α`, and for any list `l` of elements of type `α`, if `a` is an element of `l`, then the list `l` is a permutation of the list obtained by appending `a` to the front of the list `l` with `a` removed. In other words, any list is a permutation of itself with any of its elements moved to the front.

For any type `α` with decidable equality and any list `l` of elements of type `α`, if `a` is an element of `l`, then the list `[a] ++ l` and `l` are permutations of each other.


theorem Set.smul_set_neg :
    ∀ {α : Type u_2} {β : Type u_3} [inst : Monoid α] [inst_1 : AddGroup β] [inst_2 : DistribMulAction α β] (a : α)
      (t : Set β), a • -t = -(a • t) :=
  by sorry

The theorem `Set.smul_set_neg` states that for any type `α` with a monoid structure, another type `β` with an additive group structure, and a distributive multiplicative action of `α` on `β`, given an element `a` of type `α` and a set `t` of type `β`, the scalar multiplication of `a` with the additive inverse of `t` (`-t`) is equal to the additive inverse of the scalar multiplication of `a` with `t`. In mathematical terms, this is `a • (-t) = - (a • t)`. This assertion formalizes the compatibility between scalar multiplication and negation operation in the context of distributed multiplicative action.

For any monoid `α`, additive group `β`, and distributive multiplicative action of `α` on `β`, we have `a * (-t) = - (a * t)` for all `a ∈ α` and `t ∈ β`.


theorem EReal.add_lt_add : ∀ {x y z t : EReal}, x < y → z < t → x + z < y + t := by sorry

This theorem states that for all extended real numbers `x`, `y`, `z`, and `t`, if `x` is less than `y` and `z` is less than `t`, then the sum of `x` and `z` is less than the sum of `y` and `t`. This theorem is a property of order in the set of extended real numbers, which contains all real numbers plus negative and positive infinity. This is similar to the property in real numbers where the sum of two smaller numbers is smaller than the sum of two larger numbers.

For all extended real numbers x, y, z, and t, if x < y and z < t then x + z < y + t.


theorem CategoryTheory.LaxMonoidalFunctor.μ_natural :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C]
      {D : Type u₂} [inst_2 : CategoryTheory.Category.{v₂, u₂} D] [inst_3 : CategoryTheory.MonoidalCategory D]
      (F : CategoryTheory.LaxMonoidalFunctor C D) {X Y X' Y' : C} (f : X ⟶ Y) (g : X' ⟶ Y'),
      CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategory.tensorHom (F.map f) (F.map g)) (F.μ Y Y') =
        CategoryTheory.CategoryStruct.comp (F.μ X X') (F.map (CategoryTheory.MonoidalCategory.tensorHom f g)) :=
  by sorry

This theorem, `CategoryTheory.LaxMonoidalFunctor.μ_natural`, states that for any two objects `X`, `X'`, `Y`, and `Y'` in a category `C` that has a monoidal category structure, and any two morphisms `f : X ⟶ Y` and `g : X' ⟶ Y'` in `C`, for a lax monoidal functor `F` from `C` to a category `D` that also has a monoidal category structure, the composition of the tensor product of the mappings of `f` and `g` with the `μ` function of `F` applied to `Y` and `Y'` is equal to the composition of the `μ` function of `F` applied to `X` and `X'` with the mapping of the tensor product of `f` and `g`. In terms of category theory, this asserts a form of coherence between the `μ` function, the mapping function of `F`, and the composition and tensor product operations, which is a crucial property for lax monoidal functors.

For any lax monoidal functor F between monoidal categories, and objects X, X', Y, and Y' with morphisms f : X ⟶ Y and g : X' ⟶ Y' in the source category, the diagram commutes: μF(Y, Y') ∘ (F(f) ⊗ F(g)) ≡ F(f ⊗ g) ∘ μF(X, X').


theorem AlgHom.map_neg :
    ∀ {R : Type u} {A : Type v} {B : Type w} [inst : CommSemiring R] [inst_1 : Ring A] [inst_2 : Ring B]
      [inst_3 : Algebra R A] [inst_4 : Algebra R B] (φ : A →ₐ[R] B) (x : A), φ (-x) = -φ x :=
  by sorry

This theorem states that for any types `R`, `A`, `B`, where `R` is a Commutative Semiring, `A` and `B` are Rings, and both `A` and `B` are `R`-algebras, any algebra homomorphism `φ` from `A` to `B` preserves the negation operation. That is, applying `φ` to the negative of an element `x` in `A` gives the same result as first applying `φ` to `x` and then taking the negative of the result. In mathematical terms, for any `x` in `A`, `φ(-x) = -φ(x)`.

For any commutative semiring `R`, and `R`-algebras `A` and `B` that are rings, any algebra homomorphism `φ` from `A` to `B` satisfies `φ(-x) = -φ(x)` for all `x` in `A`.


theorem Int.ceil_lt_add_one :
    ∀ {α : Type u_2} [inst : LinearOrderedRing α] [inst_1 : FloorRing α] (a : α), ↑⌈a⌉ < a + 1 := by sorry

This theorem, `Int.ceil_lt_add_one`, states that for any element `a` of a certain type `α`, the ceiling of `a` (i.e., the smallest integer not smaller than `a`) is strictly less than `a + 1`. Here, `α` is a type that forms a linear ordered ring with an associated floor ring structure. In mathematical terms, it is saying that for all `a` in a floor ring, the inequality $\lceil a \rceil < a + 1$ holds.

For all elements `a` in a floor ring, the ceiling of `a` is strictly less than `a + 1`.


theorem Part.mem_assert_iff :
    ∀ {α : Type u_1} {p : Prop} {f : p → Part α} {a : α}, a ∈ Part.assert p f ↔ ∃ (h : p), a ∈ f h := by sorry

The theorem `Part.mem_assert_iff` states that for any type `α`, proposition `p`, function `f` from `p` to `Part α`, and element `a` of type `α`, `a` is an element of `Part.assert p f` if and only if there exists a proof `h` of the proposition `p` such that `a` is an element of `f h`. In other words, `a` is in the partial function produced by `Part.assert` given `p` and `f` precisely when `a` is in the domain of the `f` applied to some proof of `p`.

For any type `α`, proposition `p`, function `f` from `p` to the powerset of `α`, and element `a` of type `α`, `a` belongs to `Part.assert p f` if and only if there exists a proof `h` of `p` such that `a` is in `f(h)`.


theorem Mathlib.Algebra.Group.Prod._auxLemma.1 :
    ∀ {M : Type u_5} {N : Type u_6} [inst : One M] [inst_1 : One N] {x : M} {y : N}, ((x, y) = 1) = (x = 1 ∧ y = 1) :=
  by sorry

This theorem, from the Mathematical Library Algebra Group section, states that for any types `M` and `N` that have an associated identity element (`One M` and `One N`, respectively), the tuple `(x, y)` where `x` is an element of `M` and `y` is an element of `N`, is equal to the identity element `1` if and only if both `x` and `y` are equal to their respective identity elements. In essence, this theorem is making a statement about the nature of the identity element in a product space.

For any types `M` and `N` with identity elements `One M` and `One N`, respectively, the tuple `(x, y)` is equal to the identity element `(One M, One N)` if and only if `x = One M` and `y = One N`.


theorem IntermediateField.adjoin.powerBasis_gen :
    ∀ {K : Type u} [inst : Field K] {L : Type u_3} [inst_1 : Field L] [inst_2 : Algebra K L] {x : L}
      (hx : IsIntegral K x), (IntermediateField.adjoin.powerBasis hx).gen = IntermediateField.AdjoinSimple.gen K x :=
  by sorry

This theorem states that for any fields `K` and `L` with `L` being an algebra over `K`, and for any element `x` of `L` that is integral over `K`, the generator of the power basis of `K⟮x⟯` is equivalent to the generator of `F⟮α⟯`. In other words, the element that generates the power basis, which is composed of powers of `x` up to the degree of its minimal polynomial, coincides with `x` itself when it is considered as an element adjoined to `K`.

For any field extension `L` over `K` and any element `x` in `L` integral over `K`, the generator of the power basis of `K[x]` equals `x` itself.


theorem Subgroup.index_ne_zero_of_finite :
    ∀ {G : Type u_1} [inst : Group G] {H : Subgroup G} [hH : Finite (G ⧸ H)], Subgroup.index H ≠ 0 := by sorry

This theorem asserts that for any group `G` and its subgroup `H`, if the quotient group `G/H` (the set of all left cosets of `H` in `G`) is finite, then the index of `H` in `G` (the number of distinct left cosets of `H` in `G`) is not equal to zero. This simply means when the quotient group is finite, there is at least one distinct left coset of `H` in `G`.

If `G` is a group and `H` is a subgroup of `G` such that the quotient group `G/H` is finite, then the index of `H` in `G` is nonzero.


/-- `Set.image` is monotone. See `Set.image_subset` for the statement in terms of `⊆`.  -/
theorem Set.monotone_image : ∀ {α : Type u_1} {β : Type u_2} {f : α → β}, Monotone (Set.image f) := by sorry

The theorem `Set.monotone_image` states that for any function `f` mapping elements from a type `α` to a type `β`, the operation of taking the image of a set under `f` (`Set.image f`) is a monotone function. In other words, if we have two sets `A` and `B` such that `A` is a subset of `B` (denoted `A ⊆ B`), then the image of `A` under `f` is also a subset of the image of `B` under `f`, i.e., `f(A) ⊆ f(B)`. This property of `Set.image` is known as monotonicity.

Given a function `f` from type `α` to type `β`, the image of a subset under `f` is a subset of the image of its superset, i.e., `Set.image (f : α → β) (A ⊆ B)` implies `Set.image f A ⊆ Set.image f B`.


theorem GradedMonoid.mk_zero_smul :
    ∀ {ι : Type u_1} {A : ι → Type u_2} [inst : AddZeroClass ι] [inst_1 : GradedMonoid.GMul A] {i : ι} (a : A 0)
      (b : A i), GradedMonoid.mk i (a • b) = GradedMonoid.mk 0 a * GradedMonoid.mk i b :=
  by sorry

The theorem `GradedMonoid.mk_zero_smul` states that for any type `ι`, any family of types `A : ι → Type`, given an additive zero class on `ι` and a graded multiplication on `A`, for any element `a` of type `A 0` and any element `b` of type `A i`, the element of the graded monoid constructed from `i` and the scalar product of `a` and `b` is equal to the multiplication of the elements of the graded monoid constructed from `0` and `a`, and `i` and `b`. In other words, it says that the scalar product can be moved out of the graded monoid construction.

For any graded monoid `{A: ι → Type, ∏: ι × ι → A, 0: A 0, add: A → A → A, smul: ℝ → A 0 → A}`, where `ℝ` is the real numbers, the scalar multiplication of the graded monoid element `smul r a` by an element `a` in `A 0` and another element `b` in `A i` is equal to the graded monoid multiplication of the elements `smul r 0` and `a` with `b`.


Function.Injective.noZeroSMulDivisors

/-- Pullback a `NoZeroSMulDivisors` instance along an injective function.  -/
theorem Function.Injective.noZeroSMulDivisors :
    ∀ {R : Type u_9} {M : Type u_10} {N : Type u_11} [inst : Zero R] [inst_1 : Zero M] [inst_2 : Zero N]
      [inst_3 : SMul R M] [inst_4 : SMul R N] [inst_5 : NoZeroSMulDivisors R N] (f : M → N),
      Function.Injective f → f 0 = 0 → (∀ (c : R) (x : M), f (c • x) = c • f x) → NoZeroSMulDivisors R M :=
  by sorry

The theorem `Function.Injective.noZeroSMulDivisors` states that, given two types `R` and `M` and another type `N`, along with instances of `Zero R`, `Zero M`, `Zero N`, `SMul R M`, `SMul R N`, and `NoZeroSMulDivisors R N`, and given an injective function `f` from `M` to `N` that maps zero in `M` to zero in `N` and preserves scalar multiplication (i.e., for all scalar `c` in `R` and all `x` in `M`, `f` applied to `c` scalar multiplied by `x` equals `c` scalar multiplied by `f` applied to `x`), then `M` has the property `NoZeroSMulDivisors R M`.

In other words, if scalar multiplication by a non-zero element in `R` results in zero in `N`, then either the scalar was zero or the original element in `M` was zero, under the condition that `f` is injective and preserves scalar multiplication. This theorem allows the property of having no zero scalar multiplication divisors to be pulled back along an injective function from `M` to `N`.

If `f` is an injective function from `M` to `N` that maps zero in `M` to zero in `N` and preserves scalar multiplication, then `M` has no zero scalar multiplication divisors if and only if `N` has no zero scalar multiplication divisors.


theorem Complex.abs_cos_add_sin_mul_I : ∀ (x : ℝ), Complex.abs (Complex.cos ↑x + Complex.sin ↑x * Complex.I) = 1 := by
  sorry

The theorem `Complex.abs_cos_add_sin_mul_I` states that for every real number `x`, the absolute value of the complex number formed by the sum of the complex cosine of `x` and the complex sine of `x` multiplied by the imaginary unit `I`, is always equal to 1. This corresponds to the well-known result from trigonometry that the square root of the sum of the squares of the sine and cosine of any real number is 1, but extended to the complex number domain.

The theorem asserts that |cos(x) + i*sin(x)| = 1 for all real numbers x.


theorem Cardinal.power_one : ∀ {a : Cardinal.{u}}, a ^ 1 = a := by sorry

This theorem states that for any cardinal number `a`, when `a` is raised to the power of one, the result is `a` itself. This is consistent with the general mathematical rule that any number (including cardinal numbers) to the power of one equals the number itself. The power operation in this context is defined in terms of cardinal numbers, a type used to represent the size of a set in set theory, abstracted to higher type levels in Lean.

For any cardinal number `a`, `a^1` equals `a`.


theorem UniformSpace.Completion.uniformContinuous_coe :
    ∀ (α : Type u_1) [inst : UniformSpace α], UniformContinuous ↑α := by sorry

This theorem states that for any type `α` accompanied by a `UniformSpace` structure, the coercion function from `α` to its completion is uniformly continuous. In other words, if `x` and `y` are close enough in `α`, then their images under the coercion function are also close in the completion of `α`, regardless of their specific locations in `α`. This property holds for all elements in the type `α`.

For any uniform space `(α, δ)` with a coercion to its completion `C α`, the coercion function is uniformly continuous, i.e., for all `x, y ∈ α` with `δ(x, y)` small enough, `δ(x, y) ≤ ε` implies `∥coe α x - coe α y∥ ≤ ε`, where `coe α : α → C α` is the coercion function and `∥.∥` denotes the metric on the completion `C α`.


theorem CategoryTheory.Abelian.image.proof_1 :
    ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
      [inst_2 : CategoryTheory.Limits.HasKernels C] [inst_3 : CategoryTheory.Limits.HasCokernels C] {P Q : C}
      (f : P ⟶ Q), CategoryTheory.Limits.HasKernel (CategoryTheory.Limits.cokernel.π f) :=
  by sorry

This theorem states that for any morphism `f` from object `P` to object `Q` in category `C` (which has zero morphisms, kernels, and cokernels), the map from the target of `f` to the cokernel of `f` has a kernel. In the language of category theory, this means that there exists an object and a morphism, such that the morphism is a kernel of the cokernel map of `f`. This is a property of abelian categories.

In an abelian category with zero morphisms, kernels, and cokernels, for any morphism `f` from object `P` to object `Q`, the cokernel of `f` has a kernel, i.e., there exists an object `K` and a morphism `i` such that `fi = 0` and for all `h`, `hfi = h` implies `h = 0`.


theorem IsAdjoinRoot.aequiv.proof_1 :
    ∀ {R : Type u_2} [inst : CommRing R] {f : Polynomial R} {T : Type u_1} [inst_1 : CommRing T] [inst_2 : Algebra R T]
      (h' : IsAdjoinRoot T f), (Polynomial.aeval (IsAdjoinRoot.root h')) f = 0 :=
  by sorry

The theorem `IsAdjoinRoot.aequiv.proof_1` states that for all commutative rings `R` and `T`, for all polynomials `f` over `R`, and for all `T` that is an `R`-algebra, if `T` is generated by adjoining a root of `f`, then applying the unique `R`-algebra homomorphism from `R[X]` to `T` (represented by `Polynomial.aeval`) to `f` results in `0`. In other words, the polynomial `f` evaluates to `0` at the root that was adjoined to generate `T`.

For all commutative rings R and T being an R-algebra generated by adjoining a root of a polynomial f over R, the image of f under the unique R-algebra homomorphism from R[X] to T is 0.


/-- If functions `m₁` and `m₂` are eventually equal at a filter `f`, then
they map this filter to the same filter.  -/
theorem Filter.map_congr :
    ∀ {α : Type u} {β : Type v} {m₁ m₂ : α → β} {f : Filter α}, m₁ =ᶠ[f] m₂ → Filter.map m₁ f = Filter.map m₂ f := by
  sorry

The theorem `Filter.map_congr` states that for any types `α` and `β`, any two functions `m₁` and `m₂` from `α` to `β`, and any filter `f` on `α`, if `m₁` and `m₂` are eventually equal at the filter `f` (denoted by `m₁ =ᶠ[f] m₂`), then the forward maps of the filter `f` under `m₁` and `m₂`, denoted by `Filter.map m₁ f` and `Filter.map m₂ f` respectively, are equal. In simpler terms, if two functions agree on the elements of a set that are close enough to a particular value, then the filters obtained by applying these functions to the original filter are the same.

If two functions agree at the filter convergence, then their filter maps are equal.


/-- If there is a forgetful functor into `Type` that preserves enough (co)limits, then `D.ι` will
be jointly surjective.  -/
theorem CategoryTheory.GlueData.ι_jointly_surjective :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v, u₁} C] (D : CategoryTheory.GlueData C)
      [inst_1 : CategoryTheory.Limits.HasMulticoequalizer (CategoryTheory.GlueData.diagram D)]
      (F : CategoryTheory.Functor C (Type v))
      [inst_2 :
        CategoryTheory.Limits.PreservesColimit
          (CategoryTheory.Limits.MultispanIndex.multispan (CategoryTheory.GlueData.diagram D)) F]
      [inst_3 :
        (i j k : D.J) → CategoryTheory.Limits.PreservesLimit (CategoryTheory.Limits.cospan (D.f i j) (D.f i k)) F]
      (x : F.obj (CategoryTheory.GlueData.glued D)), ∃ i y, F.map (CategoryTheory.GlueData.ι D i) y = x :=
  by sorry

The theorem `CategoryTheory.GlueData.ι_jointly_surjective` states that if there is a forgetful functor from a category `C` into the category of types `Type` that preserves enough colimits, then the family of maps `D.ι`, indexed by elements of `D.J`, from the objects `D.U i` to the glued object `D.glued` in the glueing data `D` will be jointly surjective. In other words, for every element `x` in the functor applied to the glued object, there exists an index `i` in `D.J` and an element `y` in `D.U i` such that `x` is the image of `y` under the functor applied to the map `D.ι i`.

If a forgetful functor from a category preserving sufficient colimits maps the glued object to an element, then there exists an object in the domain of the functor and a map to the glued object whose image under the functor is that element.


theorem Complex.two_cosh : ∀ (x : ℂ), 2 * Complex.cosh x = Complex.exp x + Complex.exp (-x) := by sorry

The theorem `Complex.two_cosh` states that for any complex number `x`, twice the complex hyperbolic cosine of `x` is equal to the sum of the complex exponential of `x` and the complex exponential of the negation of `x`. In mathematical terms, this can be written as: for all `x` in the complex numbers, `2 * cosh(x) = exp(x) + exp(-x)`. This is a complex number version of the familiar identity from real number hyperbolic trigonometry.

For all complex numbers `x`, `2 * cosh(x) = exp(x) + exp(-x)`.


theorem IsLprojection.coe_inf :
    ∀ {X : Type u_1} [inst : NormedAddCommGroup X] {M : Type u_2} [inst_1 : Ring M] [inst_2 : Module M X]
      [inst_3 : FaithfulSMul M X] (P Q : { P // IsLprojection X P }), ↑(P ⊓ Q) = ↑P * ↑Q :=
  by sorry

This theorem, `IsLprojection.coe_inf`, states that for any type `X` that is a Normed Additive Commutative Group, any type `M` that is a Ring and also a Module over `X`, and given `M` and `X` satisfy the Faithful Scalar Multiplication property, for any two elements `P` and `Q` in the set of elements that satisfy the Left projection property over `X`, the meet operation (infimum, denoted by `⊓`) of `P` and `Q` is equal to the scalar multiple of `P` and `Q`. In other words, the left projection of `P` and `Q` is the same as multiplying the individual left projections of `P` and `Q`.

For any Normed Additive Commutative Group `X`, Ring `M` that is a Module over `X` with the Faithful Scalar Multiplication property, the infimum of two elements `P` and `Q` in `X` that satisfy the Left projection property is equal to the scalar multiple of their individual left projections.


theorem MeasureTheory.memℒp_of_memℒp_trim :
    ∀ {α : Type u_1} {E : Type u_2} {m m0 : MeasurableSpace α} {p : ENNReal} {μ : MeasureTheory.Measure α}
      [inst : NormedAddCommGroup E] (hm : m ≤ m0) {f : α → E},
      MeasureTheory.Memℒp f p (μ.trim hm) → MeasureTheory.Memℒp f p μ :=
  by sorry

The theorem `MeasureTheory.memℒp_of_memℒp_trim` states that for any types `α` and `E`, measurable spaces `m` and `m0` on `α`, an extended nonnegative real number `p`, and a measure `μ` on `α`, if there is an instance of `E` being a normed add commutative group, and if `m` is a subset of `m0`, then for any function `f` from `α` to `E`, if `f` meets the `L^p` space conditions (being almost everywhere strongly measurable and having its `p`-th power integral finite) with respect to the trimmed measure `μ.trim` (the restriction of `μ` to the smaller sigma-algebra `m`), then `f` also meets the `L^p` space conditions with respect to the original measure `μ`.

If `α` is a type, `E` is a normed add commutative group, `m` and `m0` are measurable spaces on `α`, `p` is an extended nonnegative real number, `μ` is a measure on `α`, and `f` is a function from `α` to `E` that is almost everywhere strongly measurable and has finite `p`-th power integral with respect to the trimmed measure `μ.trim` on the subset `m` of `m0`, then `f` also satisfies the `L^p` space conditions with respect to the original measure `μ`.


theorem abs_eq : ∀ {α : Type u_1} [inst : LinearOrderedAddCommGroup α] {a b : α}, 0 ≤ b → (|a| = b ↔ a = b ∨ a = -b) :=
  by sorry

This theorem, `abs_eq`, states that for any type `α` which is a linearly ordered additive commutative group, and any two elements `a` and `b` of this type where `b` is non-negative, the absolute value of `a` being equal to `b` is equivalent to `a` being either `b` or the negative of `b`. In other words, if the absolute value of a number equals a non-negative number, then the original number must either be that non-negative number or its negative counterpart.

For any linearly ordered additive commutative group type `α` and elements `a, b` of `α` with `b` non-negative, `|a| = b` if and only if `a = b` or `a = -b`.


theorem CategoryTheory.IsSplitMono.id_assoc :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X Y : C} (f : X ⟶ Y)
      [hf : CategoryTheory.IsSplitMono f] {Z : C} (h : X ⟶ Z),
      CategoryTheory.CategoryStruct.comp f (CategoryTheory.CategoryStruct.comp (CategoryTheory.retraction f) h) = h :=
  by sorry

This theorem states that for any category `C`, any objects `X`, `Y`, `Z` in `C`, and any morphism `f` from `X` to `Y` that is a split monomorphism, the composition of `f` with the composition of the retraction of `f` and any morphism `h` from `X` to `Z` is equal to `h`. In simple terms, it means that if you first apply a morphism and then its retraction, you can "cancel" them out in the composition, akin to the inverse function principle in mathematics. This property is a fundamental aspect of the category theory, a branch of mathematics which studies abstract structure within a mathematical context.

For any category C, if f : X -> Y is a split monomorphism in C, then for any h : X -> Z, we have f o (h o rf) = h, where rf is the retraction of f.


/-- If `F` creates limits, and `D` has all limits, then `C` has all limits.  -/
theorem CategoryTheory.hasLimits_of_hasLimits_createsLimits :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂}
      [inst_1 : CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor C D)
      [inst_2 : CategoryTheory.Limits.HasLimitsOfSize.{w, w', v₂, u₂} D]
      [inst_3 : CategoryTheory.CreatesLimitsOfSize.{w, w', v₁, v₂, u₁, u₂} F],
      CategoryTheory.Limits.HasLimitsOfSize.{w, w', v₁, u₁} C :=
  by sorry

The theorem `CategoryTheory.hasLimits_of_hasLimits_createsLimits` states that in the context of category theory, if a functor `F` from category `C` to `D` creates limits of a certain size, and the category `D` has all limits of that size, then the category `C` also has all limits of that size. This property is important in discussions about the existence of limits in categories.

If a functor preserves limits of a certain size in a category and the target category has all limits of that size, then the source category also has all limits of that size.


Nat.Primrec.id

theorem Nat.Primrec.id : Nat.Primrec id := by sorry

This theorem states that the identity function is a primitive recursive function for natural numbers. In other words, given any natural number, its identity (i.e., the number itself) can be computed using only a finite number of steps that involve basic arithmetic operations and conditionals, a characteristic of primitive recursive functions.

The Identity function is a primitive recursive function on natural numbers.


theorem RingHom.coe_rangeS :
    ∀ {R : Type u} {S : Type v} [inst : NonAssocSemiring R] [inst_1 : NonAssocSemiring S] (f : R →+* S),
      ↑(RingHom.rangeS f) = Set.range ⇑f :=
  by sorry

This theorem states that for all types `R` and `S` which are non-associative semirings, and for every ring homomorphism `f` from `R` to `S`, the co-domain of the homomorphism when considered as a subsemiring (`RingHom.rangeS f`) is precisely the set of all elements in `S` that can be obtained by applying `f` to some element of `R` (`Set.range ⇑f`). In other words, it establishes the equivalence between the range of the ring homomorphism as a subsemiring and the set of values it can take.

For every non-associative semirings `R` and `S` and ring homomorphism `f` from `R` to `S`, `RingHom.rangeS f` equals `Set.range (f : R → S)`.


theorem Set.image_update_Ico :
    ∀ {ι : Type u_1} {α : ι → Type u_2} [inst : DecidableEq ι] [inst_1 : (i : ι) → PartialOrder (α i)]
      (f : (i : ι) → α i) (i : ι) (a b : α i),
      Function.update f i '' Set.Ico a b = Set.Ico (Function.update f i a) (Function.update f i b) :=
  by sorry

This theorem states that for any function `f` from an index set `ι` to a family of partially ordered sets `α i`, where the equality in `ι` is decidable, and for any index `i` in `ι` and any two elements `a` and `b` from `α i`, the image under `f` of the left-closed right-open interval between `a` and `b` (denoted by `Set.Ico a b`) when `f` is updated at `i` is the same as the left-closed right-open interval between the updated values of `f` at `a` and `b`.

In simple terms, it's saying that when we update the function at a certain point and then calculate the image of the interval from `a` to `b`, it's the same as if we computed the interval of the updated function at `a` and `b`.

Given a function `f` from an indexed set `ι` to a family of partially ordered sets `α i` with decidable equality, for any index `i` and elements `a` and `b` in `α i`, `Set.Ico a b ↦ f  (Set.Ico a b) = Set.Ico (f a) (f b)`.


Continuous.min

theorem Continuous.min :
    ∀ {α : Type u} {β : Type v} [inst : TopologicalSpace α] [inst_1 : LinearOrder α] [inst_2 : OrderClosedTopology α]
      {f g : β → α} [inst_3 : TopologicalSpace β], Continuous f → Continuous g → Continuous fun b => min (f b) (g b) :=
  by sorry

This theorem states that for any two given continuous functions `f` and `g` mapping from type `β` to a type `α` (which is equipped with a topological space structure, linear order, and an order-closed topology), the function that takes an input `b` of type `β` and returns the minimum value between `f(b)` and `g(b)` is also a continuous function. Here, continuity is defined under the topological space structure of `α` and `β`.

Given continuous functions `f` and `g` from a topological space `β` to a topologically ordered and order-closed space `α`, the function that maps each `b` in `β` to the minimum of `f(b)` and `g(b)` is also continuous.


theorem IsLprojection.coe_compl :
    ∀ {X : Type u_1} [inst : NormedAddCommGroup X] {M : Type u_2} [inst_1 : Ring M] [inst_2 : Module M X]
      (P : { P // IsLprojection X P }), ↑Pᶜ = 1 - ↑P :=
  by sorry

The theorem `IsLprojection.coe_compl` states that for any type `X` that forms a Normed Additive Commutative Group, any type `M` that forms a Ring and a Module over `X`, and for any `P` that is a left projection in `X`, the complement of `P` is equal to `1 - P`. In simpler terms, it's saying that if we have a certain mathematical structure (the left projection `P`), then the complement of this structure is simply one minus the structure itself.

For any Normed Additive Commutative Group `X`, Ring `M`, and Module `M` over `X`, if `P` is a left projection in `X`, then `1 - P` is the complement of `P`.


theorem List.map_const' :
    ∀ {α : Type u} {β : Type v} (l : List α) (b : β), List.map (fun x => b) l = List.replicate (List.length l) b := by
  sorry

The theorem `List.map_const'` states that for any list `l` of type `α` and any element `b` of type `β`, if we map over the list `l` and replace each element with `b`, we will get a new list that is the same as replicating the element `b` for the length of the original list `l`. This means that replacing each element in a list with a constant value is equivalent to creating a new list filled with that constant, with the same length as the original list.

For any list `l` of length `n` and any element `b`, the list obtained by applying the map function with constant argument `b` to `l` is equal to the list of length `n` consisting only of `b`.


theorem Complex.normSq_ofReal : ∀ (r : ℝ), Complex.normSq ↑r = r * r := by sorry

This theorem, `Complex.normSq_ofReal`, states that for every real number `r`, the square of the complex norm (or magnitude) of the complex number `r` (obtained by considering `r` as a complex number with zero imaginary part) is equal to `r * r`. In mathematical notation, for all real numbers `r`, the square of the norm of `r` as a complex number is the square of `r` itself.

For every real number r, the complex norm of r squared equals r squared.


Set.MapsTo.mono

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

The theorem `Set.MapsTo.mono` states that for any two types `α` and `β`, given two sets `s₁` and `s₂` of type `α`, two sets `t₁` and `t₂` of type `β`, and a mapping function `f` from `α` to `β`, if `f` maps every element in `s₁` to `t₁` (i.e., `Set.MapsTo f s₁ t₁`), `s₂` is a subset of `s₁`  (i.e., `s₂ ⊆ s₁`), and `t₁` is a subset of `t₂` (i.e., `t₁ ⊆ t₂`), then `f` also maps every element in `s₂` to `t₂` (i.e., `Set.MapsTo f s₂ t₂`). In essence, this theorem gives us certain conditions under which we can be sure that mapping a subset of a given set through a given function will result in a subset of the mapped set.

If `f` maps every element in `s₁` to `t₁`, `s₂ ⊆ s₁`, and `t₁ ⊆ t₂`, then `f` maps every element in `s₂` to `t₂`.


Isometry.comp

/-- The composition of isometries is an isometry.  -/
theorem Isometry.comp :
    ∀ {α : Type u} {β : Type v} {γ : Type w} [inst : PseudoEMetricSpace α] [inst_1 : PseudoEMetricSpace β]
      [inst_2 : PseudoEMetricSpace γ] {g : β → γ} {f : α → β}, Isometry g → Isometry f → Isometry (g ∘ f) :=
  by sorry

This theorem states that the composition of two isometries is also an isometry. In a more detailed explanation, given two pseudoemetric spaces (which are types `α`, `β`, and `γ`), and two functions `f : α → β` and `g : β → γ` that are isometries (i.e., they preserve the edistance between points in their respective spaces), then their composition `g ∘ f : α → γ` is also an isometry. This means that for any two points `x1` and `x2` in space `α`, the edistance between the images of these two points under the composed map `g ∘ f` is equal to the edistance between `x1` and `x2`.

The composition of two isometries is an isometry.


theorem ExteriorAlgebra.map.proof_1 :
    ∀ {R : Type u_1} [inst : CommRing R] {M : Type u_3} [inst_1 : AddCommGroup M] [inst_2 : Module R M] {N : Type u_2}
      [inst_3 : AddCommGroup N] [inst_4 : Module R N] (f : M →ₗ[R] N) (x : M), 0 (f.toFun x) = 0 (f.toFun x) :=
  by sorry

This theorem states that for any commutative ring `R`, any types `M` and `N` that are both additive commutative groups and `R`-modules, and any linear map `f` from `M` to `N`, applying the function `f` to a value `x` from `M` and then applying the zero function results in the same output as first applying the zero function to `f(x)`. In mathematical terms, it says that for linear map `f: M → N`, we have `0(f(x)) = 0(f(x))` for all `x` in `M`.

For any linear map `f` from an additive commutative group `M` to an additive commutative group `N` and any element `x` in `M`, we have `0(f(x)) = 0(f(0))`, where `0` denotes the zero function.


theorem div_sub' : ∀ {K : Type u_3} [inst : Field K] (a b c : K), c ≠ 0 → a / c - b = (a - c * b) / c := by sorry

This theorem states that for any field `K` and any elements `a`, `b`, and `c` of `K`, such that `c` is not zero, the expression `a / c - b` is equal to `(a - c * b) / c`. This essentially gives us a formula to simplify division and subtraction in a field.

For any field `K` and elements `a`, `b`, and `c` in `K` with `c ≠ 0`, we have `(a / c - b) = (a - c * b) / c`.


theorem MeasureTheory.lintegral_map' :
    ∀ {α : Type u_1} {β : Type u_2} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} {mβ : MeasurableSpace β}
      {f : β → ENNReal} {g : α → β},
      AEMeasurable f (MeasureTheory.Measure.map g μ) →
        AEMeasurable g μ → ∫⁻ (a : β), f a ∂MeasureTheory.Measure.map g μ = ∫⁻ (a : α), f (g a) ∂μ :=
  by sorry

The theorem `MeasureTheory.lintegral_map'` states that for all types `α` and `β`, with `m` being the measurable space over `α` and `μ` being a measure on `α`, and `mβ` being the measurable space over `β`. If `f` is a function from `β` to the extended nonnegative real numbers (`ENNReal`), and `g` is a function from `α` to `β`, then if `f` is almost everywhere measurable with respect to the measure obtained by pushing forward `μ` by `g` (denoted `MeasureTheory.Measure.map g μ`), and `g` is almost everywhere measurable with respect to `μ`, the Lebesgue integral of `f` with respect to the measure `MeasureTheory.Measure.map g μ` is equal to the Lebesgue integral of `f ∘ g` with respect to the measure `μ`.

In symbolic terms, we have:
∫⁻ (a : β), f a ∂(MeasureTheory.Measure.map g μ) = ∫⁻ (a : α), f (g a) ∂μ
This essentially means that integrating the function `f` after applying the measure transformation `g` is the same as integrating the composed function `f ∘ g` under the original measure `μ`.

The Lebesgue integral of a almost everywhere measurable function `f` with respect to the pushforward measure obtained by applying a measurable function `g` is equal to the Lebesgue integral of `f` composed with `g` under the original measure.


theorem ProbabilityTheory.kernel.restrict_apply :
    ∀ {α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {s : Set β}
      (κ : ↥(ProbabilityTheory.kernel α β)) (hs : MeasurableSet s) (a : α),
      (ProbabilityTheory.kernel.restrict κ hs) a = (κ a).restrict s :=
  by sorry

The theorem `ProbabilityTheory.kernel.restrict_apply` states that for any types `α` and `β`, measurable spaces `mα` and `mβ`, a set `s` of type `β`, a probability kernel `κ` from `α` to `β`, a proof `hs` that `s` is a measurable set, and an element `a` of type `α`, the application of the restricted probability kernel `(ProbabilityTheory.kernel.restrict κ hs)` at `a` is equal to the restriction of the measure `(κ a)` to the set `s`. In essence, this theorem asserts the correctness of the `restrict` operation in the context of probability theory, ensuring that restricting a probability kernel to a measurable set behaves as expected.

For any measurable spaces `mα` and `mβ`, type `α` element `a`, measurable set `s` in `β`, probability kernel `κ` from `α` to `β`, and proof `hs` of `s` being measurable, `(ProbabilityTheory.kernel.restrict κ hs) a = κ a | s`.


/-- The first projection at a point in a product is `C^∞`.  -/
theorem contDiffAt_fst :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type uE} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {F : Type uF} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {n : ℕ∞}
      {p : E × F}, ContDiffAt 𝕜 n Prod.fst p :=
  by sorry

This theorem states that for any point `p` in the product of two normed spaces `E` and `F` over a nontrivially normed field `𝕜`, the first projection function `Prod.fst` is continuously differentiable at `p` to any order `n`. This means that all derivatives of the projection function up to order `n` exist and are continuous at point `p`. In mathematical terms, if `p : E × F`, then `Prod.fst : E × F → E` is a `C^∞` function at `p`.

The first projection function of a product of two normed spaces is continuously differentiable to any order at any point in the product space.


theorem MeasurableEmbedding.restrict_map :
    ∀ {α : Type u_2} {β : Type u_3} {m0 : MeasurableSpace α} {m1 : MeasurableSpace β} {f : α → β},
      MeasurableEmbedding f →
        ∀ (μ : MeasureTheory.Measure α) (s : Set β),
          (MeasureTheory.Measure.map f μ).restrict s = MeasureTheory.Measure.map f (μ.restrict (f ⁻¹' s)) :=
  by sorry

The theorem `MeasurableEmbedding.restrict_map` states that for any types `α` and `β`, any measurable spaces `m0` and `m1` on `α` and `β respectively`, any function `f` from `α` to `β` that is a measurable embedding, any measure `μ` on `α`, and any set `s` of `β`, the measure obtained by first applying the map `f` to the measure `μ` and then restricting to the set `s` is the same as the measure obtained by first restricting `μ` to the preimage of `s` under `f` and then applying the map `f`. In mathematical notation, this can be written as `(f_*(μ)).restrict(s) = f_* (μ.restrict(f^(-1)(s)))`. This is a property about the interaction between the pushforward of a measure and the restriction of a measure.

For any measurable spaces `m0` on `α`, `m1` on `β`, measurable embedding `f` from `α` to `β`, measure `μ` on `α`, and set `s` of `β`, `(f_* μ).restrict(s) = f_* (μ.restrict(f⁻¹(s)))`.


theorem zero_floorDiv :
    ∀ {α : Type u_2} {β : Type u_3} [inst : OrderedAddCommMonoid α] [inst_1 : OrderedAddCommMonoid β]
      [inst_2 : SMulZeroClass α β] [inst_3 : FloorDiv α β] (a : α), 0 ⌊/⌋ a = 0 :=
  by sorry

This theorem, `zero_floorDiv`, states that for any types `α` and `β` that together form an ordered additive commutative monoid, with `α` also being a scalar multiplication zero class, and an operation of floor division defined over `α` and `β`, the floor division of zero by any element `a` of type `α` equals zero. In other words, if we take any `a` in `α`, the floor division of 0 by `a` will always yield 0. This is analogous to the mathematical property that 0 divided by any number is always 0.

For any ordered additive commutative monoid types `α` and `β` with `α` being a scalar multiplication zero class, if `α` has a floor division operation defined over `β`, then 0 ∥ 0 = 0, where ∥ denotes floor division.


theorem CategoryTheory.Preadditive.nsmul_comp :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C] {P Q R : C}
      (f : P ⟶ Q) (g : Q ⟶ R) (n : ℕ),
      CategoryTheory.CategoryStruct.comp (n • f) g = n • CategoryTheory.CategoryStruct.comp f g :=
  by sorry

The theorem `CategoryTheory.Preadditive.nsmul_comp` states that for any category `C` that is preadditive (meaning it's enriched over the category of Abelian groups), for all objects `P`, `Q`, and `R` in `C`, and for all morphisms `f` from `P` to `Q` and `g` from `Q` to `R`, and for any natural number `n`, the composition of the `n`-fold scalar multiple of `f` with `g` is equal to the `n`-fold scalar multiple of the composition of `f` and `g`. In mathematical terms, this is the statement that `(n • f) ≫ g = n • (f ≫ g)`.

For any preadditive category C and objects P, Q, R with morphisms f: P → Q and g: Q → R, and natural number n, the scalar multiplication of the composition of f and g by n is equal to the composition of the scalar multiplication of f by n and g. That is, (n • f) ≫ g = n • (f ≫ g).


theorem Ideal.isCoprime_iff_sup_eq :
    ∀ {R : Type u} [inst : CommSemiring R] {I J : Ideal R}, IsCoprime I J ↔ I ⊔ J = ⊤ := by sorry

This theorem states that for any commutative semiring `R`, and any two ideals `I` and `J` in `R`, `I` and `J` are coprime if and only if the supremum (join) of `I` and `J` equals the top element (`⊤`, the whole set) of the ideal structure. In mathematical terms, two ideals are coprime if and only if their least upper bound is the whole ring. Coprimeness in this context is defined as the existence of two elements `a` and `b` such that `a * I + b * J = 1`.

Two ideals `I` and `J` in a commutative semiring `R` are coprime if and only if their join equals the top element of the ideal structure, i.e., `I ⨅ J = ⊤`.