/-- When one splits a list along a composition `c`, the lengths of the sublists thus created are
given by the block sizes in `c`.  -/
theorem List.map_length_splitWrtComposition :
    ∀ {α : Type u_1} (l : List α) (c : Composition (List.length l)),
      List.map List.length (List.splitWrtComposition l c) = c.blocks :=
  by sorry

This theorem states that for any given list `l` of type `α` and a composition `c` of the length of `l`, when the list `l` is split according to the composition `c` using the function `List.splitWrtComposition`, if we then take the lengths of the resulting sublists using `List.map List.length`, we obtain the original composition `c.blocks`. In essence, it shows that splitting a list based on a composition yields sublists whose lengths correspond to the block sizes in the composition.

Given a list `l` of type `α` and a composition `c` of length `l.size`, the lengths of the sublists obtained by splitting `l` according to `c` using `List.splitWrtComposition` equal `c.blocks`.


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

The theorem, `Mathlib.NumberTheory.LSeries.Convergence._auxLemma.2`, states that for any types `α` and `β`, a function `f` from `α` to `β`, a set `s` of type `α`, and an element `y` of type `β`, the condition "y is in the image of the set s under the function f" is equivalent to the existence of an element x in the set s such that f applied to x equals y. This theorem essentially establishes the definition of the image of a set under a function in the context of Lean 4.

For any types `α`, `β`, function `f` from `α` to `β`, set `s` of type `α`, and element `y` of type `β`, the condition `y ∈ im f s` is equivalent to the existence of `x ∈ s` such that `f x = y`.


/-- **Removable singularity** theorem: if `s` is a neighborhood of `c : ℂ`, a function `f : ℂ → E`
is complex differentiable on `s \ {c}`, and $f(z) - f(c)=o((z-c)^{-1})$, then `f` redefined to be
equal to `limUnder (𝓝[≠] c) f` at `c` is complex differentiable on `s`.  -/
theorem Complex.differentiableOn_update_limUnder_of_isLittleO :
    ∀ {E : Type u} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℂ E] [inst_2 : CompleteSpace E] {f : ℂ → E}
      {s : Set ℂ} {c : ℂ},
      s ∈ nhds c →
        DifferentiableOn ℂ f (s \ {c}) →
          ((fun z => f z - f c) =o[nhdsWithin c {c}ᶜ] fun z => (z - c)⁻¹) →
            DifferentiableOn ℂ (Function.update f c (limUnder (nhdsWithin c {c}ᶜ) f)) s :=
  by sorry

The theorem is known as the **Removable Singularity** theorem. It states that if `s` is a neighborhood of a complex number `c`, and if a function `f` mapping complex numbers to a complete normed additive group `E` is complex differentiable on `s` excluding `c`, and furthermore if the difference between `f(z)` and `f(c)` is much smaller than the reciprocal of `(z-c)` as `z` approaches `c` (formally, `(f z - f c) = o((z - c)⁻¹)` as `z` tends to `c`), then `f` can be redefined at `c` to be the limit of `f` as `z` approaches `c` but is not equal to `c` (formally, `limUnder (nhdsWithin c {c}ᶜ) f`), and this redefined function is still complex differentiable on `s`.

If a complex differentiable function `f` on a neighborhood `s` of a complex number `c`, with `f(z)` approaching `f(c)` faster than `1/(z-c)` as `z` approaches `c`, then `f` can be redefined at `c` as the limit of `f` and this new definition remains complex differentiable.


theorem WithBot.unbot'_coe : ∀ {α : Type u_5} (d x : α), WithBot.unbot' d ↑x = x := by sorry

The theorem `WithBot.unbot'_coe` states that for any type `α` and any two elements `d` and `x` of that type, when `x` is coerced into `WithBot α` type and then the `WithBot.unbot'` function is applied with `d` as default value, we get back original `x`. This essentially asserts that the `WithBot.unbot'` function is a kind of inverse operation to coercion into `WithBot α` type, at least when the original value was from `α` and not `bot`.

For any type `α` and elements `d : α` and `x : α`, `WithBot.unbot' d x = x`.


theorem mul_pos_iff :
    ∀ {α : Type u} [inst : LinearOrderedSemiring α] {a b : α} [inst_1 : ExistsAddOfLE α],
      0 < a * b ↔ 0 < a ∧ 0 < b ∨ a < 0 ∧ b < 0 :=
  by sorry

This theorem, `mul_pos_iff`, states a property for any linearly ordered semiring. Specifically, for any two elements `a` and `b` from the semiring, the product `a * b` is positive if and only if either both `a` and `b` are positive or both `a` and `b` are negative. This is a basic property of multiplication in ordered rings.

In a linearly ordered semiring, the product of two elements is positive if and only if both elements are positive or both are negative.


theorem IntervalIntegrable.mul_continuousOn :
    ∀ {A : Type u_5} [inst : NormedRing A] {a b : ℝ} {μ : MeasureTheory.Measure ℝ} {f g : ℝ → A},
      IntervalIntegrable f μ a b → ContinuousOn g (Set.uIcc a b) → IntervalIntegrable (fun x => f x * g x) μ a b :=
  by sorry

The theorem `IntervalIntegrable.mul_continuousOn` states that for any normed ring `A`, real numbers `a` and `b`, a measure `μ`, and functions `f` and `g` mapping real numbers to elements of `A`, if `f` is interval integrable with respect to `μ` on the interval `a` to `b` and `g` is continuous on the closed interval from `a` to `b` (inclusive), then the function that maps each `x` in the domain to the product of `f(x)` and `g(x)` is also interval integrable with respect to `μ` on the interval from `a` to `b`. This means that the product of an interval integrable function and a continuous function on the closed interval is also interval integrable.

If `f` is interval integrable and `g` is continuous on a closed interval, then the product function `x ↦ f(x) * g(x)` is interval integrable.


theorem Mathlib.Algebra.ModEq._auxLemma.31 :
    ∀ {α : Type u_1} [inst : AddCommGroupWithOne α] (m n : ℤ), m • ↑n = ↑(m * n) := by sorry

This theorem, known as `_auxLemma.31` from the `Mathlib.Algebra.ModEq` module, asserts that for any type `α` that has the structure of an additive commutative group along with an identity element for multiplication, and for any integers `m` and `n`, the action of scaling `n` by `m` has the same effect as multiplying `m` and `n` together and then converting the result to `α`. In mathematical notation, this is stated as `m • ↑n = ↑(m * n)`.

For any additive commutative group `α` with an identity element for multiplication, scaling an integer `n` by another integer `m` is equivalent to multiplying `m` and `n` and then converting the result to the group `α`, i.e., `m • ↑n = ↑(m * n)`.


theorem Mathlib.Algebra.ModEq._auxLemma.34 : ∀ {a b n : ℕ}, (a ≡ b [MOD n]) = (↑a ≡ ↑b [ZMOD ↑n]) := by sorry

This theorem states that for any three natural numbers `a`, `b`, and `n`, the statement "`a` is congruent to `b` modulo `n`" is equivalent to the statement "the integer representation of `a` is congruent to the integer representation of `b` modulo the integer representation of `n`". Essentially, it's saying that the modulo operation behaves the same way whether you're working with natural numbers or integers.

For natural numbers `a`, `b`, and `n`, `a` is congruent to `b` modulo `n` if and only if the integer representations of `a` and `b` are congruent modulo the integer representation of `n`.


theorem Mathlib.Algebra.ModEq._auxLemma.35 : ∀ {a b z : ℤ}, (a ≡ b [ZMOD z]) = (a ≡ b [PMOD z]) := by sorry

This theorem, `Mathlib.Algebra.ModEq._auxLemma.35`, states that for any three integers `a`, `b`, and `z`, the statement that `a` is equivalent to `b` modulo `z` is equivalent to the statement that `a` is equivalent to `b` taken modulo `z` in the positive mod context. In mathematical notation, we have `(a ≡ b mod z) ⇔ (a ≡ b mod+ z)`, where `mod+` is the operation of modulo in the positive context.

The theorem `Mathlib.Algebra.ModEq._auxLemma.35` in Lean 4 states that for integers `a`, `b`, and `z`, `a` is congruent to `b` modulo `z` if and only if `a` is congruent to `b` in the positive modulo context modulo `z`.


theorem Int.toNat_lt_toNat : ∀ {a b : ℤ}, 0 < b → (Int.toNat a < Int.toNat b ↔ a < b) := by sorry

This theorem, `Int.toNat_lt_toNat`, states that for all integers `a` and `b`, if `b` is greater than 0, then the equivalent natural number of `a` is less than the equivalent natural number of `b` if and only if `a` is less than `b`. In other words, the relationship of "less than" between `a` and `b` is preserved when both integers are converted to their natural number counterparts using the `Int.toNat` function, but this is only guaranteed when `b` is positive.

For all integers `a` and `b` with `b` positive, `Int.toNat a < Int.toNat b` if and only if `a < b`.


theorem ULift.down_bijective : ∀ {α : Type u}, Function.Bijective ULift.down := by sorry

The theorem `ULift.down_bijective` states that for all types `α`, the function `ULift.down` is bijective. In other words, `ULift.down` is both injective (no two different inputs yield the same output) and surjective (for every possible output there exists an input that produces that output). The function `ULift.down` extracts a value from a lifted type `ULift α`, and the bijectiveness of this function ensures that each value in the lifted type corresponds to exactly one value in the original type, and vice versa.

The function `ULift.down` is a bijection between the types `α` and `ULift α`.


theorem HahnSeries.single_mul_single :
    ∀ {Γ : Type u_1} {R : Type u_2} [inst : OrderedCancelAddCommMonoid Γ] [inst_1 : NonUnitalNonAssocSemiring R]
      {a b : Γ} {r s : R}, (HahnSeries.single a) r * (HahnSeries.single b) s = (HahnSeries.single (a + b)) (r * s) :=
  by sorry

The theorem `HahnSeries.single_mul_single` states that for any ordered cancel-additive commutative monoid `Γ`, non-unital non-associative semiring `R`, elements `a` and `b` from `Γ`, and elements `r` and `s` from `R`, the product of the Hahn series `HahnSeries.single a r` and `HahnSeries.single b s` is the Hahn series `HahnSeries.single (a + b) (r * s)`. In other words, it states that the multiplication of two Hahn series, each having a single nonzero coefficient, results in a new Hahn series with a single nonzero coefficient at the sum of the indices and the product of the coefficients.

For any ordered cancel-additive commutative monoid Γ, non-unital non-associative semiring R, and elements a, b from Γ, and r, s from R, the product of the Hahn series HahnSeries.single a r and HahnSeries.single b s is equal to HahnSeries.single (a + b) (r * s).


theorem StructureGroupoid.LocalInvariantProp.liftPropAt_of_mem_maximalAtlas :
    ∀ {H : Type u_1} {M : Type u_2} [inst : TopologicalSpace H] [inst_1 : TopologicalSpace M]
      [inst_2 : ChartedSpace H M] {G : StructureGroupoid H} {e : PartialHomeomorph M H} {x : M}
      {Q : (H → H) → Set H → H → Prop} [inst_3 : HasGroupoid M G],
      StructureGroupoid.LocalInvariantProp G G Q →
        (∀ (y : H), Q id Set.univ y) →
          e ∈ StructureGroupoid.maximalAtlas M G → x ∈ e.source → ChartedSpace.LiftPropAt Q (↑e) x :=
  by sorry

This theorem states that for any topological spaces `H` and `M`, with `M` having a `ChartedSpace` structure, a structure groupoid `G` over `H`, a partial homeomorphism `e` from `M` to `H`, an element `x` from `M`, and a property `Q` that applies to a function from `H` to `H`, a subset of `H`, and an element of `H`, if `M` has a `Groupoid` structure associated with `G`, and if `Q` is a local invariant property for `G`, and if `Q` holds for the identity function and all elements of `H`, and if `e` belongs to the maximal atlas of `G` for `M`, and if `x` belongs to the source of `e`, then the lift property at `Q` holds for `e` at `x`. The lift property is a condition used in the definition of a manifold in differential geometry.

If `H` is a topological space with a charted space structure, `M` is a topological space with a groupoid structure over `H`, `e` is a partial homeomorphism from `M` to `H` belonging to its maximal atlas, `x` is an element of `M` in the source of `e`, and `Q` is a local invariant property for the groupoid structure that holds for the identity function and all elements of `H`, then the lift property at `Q` holds for `e` at `x`.


theorem Complex.tan_add :
    ∀ {x y : ℂ},
      (((∀ (k : ℤ), x ≠ (2 * ↑k + 1) * ↑Real.pi / 2) ∧ ∀ (l : ℤ), y ≠ (2 * ↑l + 1) * ↑Real.pi / 2) ∨
          (∃ k, x = (2 * ↑k + 1) * ↑Real.pi / 2) ∧ ∃ l, y = (2 * ↑l + 1) * ↑Real.pi / 2) →
        Complex.tan (x + y) = (Complex.tan x + Complex.tan y) / (1 - Complex.tan x * Complex.tan y) :=
  by sorry

The theorem `Complex.tan_add` states that for any two complex numbers `x` and `y`, the tangent of the sum of `x` and `y` is equal to the sum of the tangents of `x` and `y` divided by `1` minus the product of the tangents of `x` and `y`, provided that neither `x` nor `y` is an odd multiple of half of π, or both `x` and `y` are odd multiples of half of π. In other words, if we denote by $k$ and $l$ any integers, then the condition can be written as: either for all $k$ and $l$, $x$ is not equal to $(2k+1)\pi/2$ and $y$ is not equal to $(2l+1)\pi/2$, or there exist such $k$ and $l$ that $x$ equals to $(2k+1)\pi/2$ and $y$ equals to $(2l+1)\pi/2$. The restriction is needed because the tangent function has poles at odd multiples of half of π.

The theorem `Complex.tan_add` asserts that for complex numbers `x` and `y` not equal to odd multiples of half of π, their tangents add: `tan(x + y) = (tan x + tan y) / (1 - tan x * tan y)`.


theorem MonoidHom.map_finprod_plift :
    ∀ {M : Type u_2} {N : Type u_3} {α : Sort u_4} [inst : CommMonoid M] [inst_1 : CommMonoid N] (f : M →* N)
      (g : α → M),
      Set.Finite (Function.mulSupport (g ∘ PLift.down)) → f (finprod fun x => g x) = finprod fun x => f (g x) :=
  by sorry

This theorem states that for any commutative monoids `M` and `N`, a monoid homomorphism `f` from `M` to `N`, and a function `g` from an arbitrary type `α` to `M`, if the multiplicative support of the function `g ∘ PLift.down` (i.e., the set of points `x` such that `g(PLift.down(x)) ≠ 1`) is finite, then the image of the finprod (product of `g x` as `x` ranges over the elements of the multiplicative support of `g`, or `1` if this set is infinite) under `f` is equal to the finprod of the images of `g x` under `f`. In other words, the monoid homomorphism `f` preserves the finprod over the multiplicative support of the function `g`.

For any commutative monoids M, N, monoid homomorphism f from M to N, and function g from type α to M with finite multiplicative support of g ∘ PLift.down, the image of the finite product of g x under f is equal to the finite product of the images of g x under f.


theorem FreeGroup.toWord_injective : ∀ {α : Type u} [inst : DecidableEq α], Function.Injective FreeGroup.toWord := by
  sorry

This theorem states that for any type `α` with decidable equality (i.e., given any two elements of `α`, we can decide whether they are equal or not), the function `FreeGroup.toWord` is injective. In other words, if `FreeGroup.toWord` is applied to two elements from the free group over `α` and produces the same result, then those two elements were initially the same. The `FreeGroup.toWord` function converts an element of the free group into a list of pairs, where each pair consists of an element from `α` and a boolean value, and this function performs a "maximal reduction" on the free group element. The theorem is stating that this function uniquely identifies each element of the free group.

For every type `α` with decidable equality, the injective function `FreeGroup.toWord` from the free group over `α` to the list of pairs of elements from `α` and booleans uniquely identifies each element in the free group.


theorem Ordinal.nadd_le_nadd_right :
    ∀ {b c : Ordinal.{u}}, b ≤ c → ∀ (a : Ordinal.{u}), Ordinal.nadd b a ≤ Ordinal.nadd c a := by sorry

The theorem `Ordinal.nadd_le_nadd_right` states that for any ordinals `b` and `c`, if `b` is less than or equal to `c`, then for any ordinal `a`, the natural addition of `b` and `a` (denoted by `Ordinal.nadd b a`) is less than or equal to the natural addition of `c` and `a` (denoted by `Ordinal.nadd c a`). This theorem essentially shows that the natural addition operation on ordinals respects the order relation, i.e., if one operand is smaller, the result of the operation is also smaller, when the other operand is fixed.

For all ordinals `b` and `c` and any ordinal `a`, if `b ≤ c`, then `Ordinal.nadd b a ≤ Ordinal.nadd c a`.


theorem MeasureTheory.Measure.QuasiMeasurePreserving.id :
    ∀ {α : Type u_1} {_m0 : MeasurableSpace α} (μ : MeasureTheory.Measure α),
      MeasureTheory.Measure.QuasiMeasurePreserving id μ μ :=
  by sorry

This theorem states that for any given type `α` and a measurable space `_m0` of type `α`, the identity function is a quasi measure-preserving function for any measure `μ` on that measurable space. In mathematical terms, if we have a measure space `(α, _m0, μ)`, the identity map on `α` is always quasi measure-preserving with respect to the measure `μ`.

For any measurable space `(α, μ\_m0)` and measure `μ`, the identity function on `α` is a quasi measure-preserving function with respect to `μ`.


theorem image_le_kernel :
    ∀ {V : Type u} [inst : CategoryTheory.Category.{v, u} V] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms V]
      {A B C : V} (f : A ⟶ B) [inst_2 : CategoryTheory.Limits.HasImage f] (g : B ⟶ C)
      [inst_3 : CategoryTheory.Limits.HasKernel g],
      CategoryTheory.CategoryStruct.comp f g = 0 →
        CategoryTheory.Limits.imageSubobject f ≤ CategoryTheory.Limits.kernelSubobject g :=
  by sorry

The theorem `image_le_kernel` states that for any category `V` which has zero morphisms, and any objects `A`, `B` and `C` in `V`, if a morphism `f` from `A` to `B` has an image, and a morphism `g` from `B` to `C` has a kernel, then if the composition of `f` and `g` is a zero morphism (denoted by `f ≫ g = 0`), it implies that the image subobject of `f` is less than or equal to the kernel subobject of `g`. In other words, the theorem states a general property of categories: the image of a morphism is always contained in the kernel of the following morphism when their composition is zero.

If in a zero-morphism category V, morphisms f from A to B with image and g from B to C with kernel exist such that f ≫ g = 0, then the image of f is contained in the kernel of g.


/-- Pre-composition by any function is uniformly continuous for the uniform structures of
uniform convergence.

More precisely, for any `f : γ → α`, the function `(· ∘ f) : (α →ᵤ β) → (γ →ᵤ β)` is uniformly
continuous.  -/
theorem UniformFun.precomp_uniformContinuous :
    ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : UniformSpace β] {f : γ → α},
      UniformContinuous fun g => UniformFun.ofFun (UniformFun.toFun g ∘ f) :=
  by sorry

This theorem states that pre-composition with any function is uniformly continuous for the uniform structures of uniform convergence. In more detailed terms, given any function `f` from a type `γ` to a type `α`, the function that takes a uniformly continuous function from `α` to `β` and composes it with `f` (i.e., `(· ∘ f) : (α →ᵤ β) → (γ →ᵤ β)`) is uniformly continuous. This means that if `x` and `y` are points in `γ` that are close to each other, then the function values after composition, `(g ∘ f)(x)` and `(g ∘ f)(y)`, are also close to each other for any uniformly continuous function `g : α →ᵤ β`, regardless of where `x` and `y` are located in `γ`.

Given any uniformly continuous function `f : γ → α` and any uniformly continuous function `g : α → β`, the composed function `(g ∘ f) : γ → β` is also uniformly continuous.


theorem Int.le.intro_sub : ∀ {a b : ℤ} (n : ℕ), b - a = ↑n → a ≤ b := by sorry

This theorem, named `Int.le.intro_sub`, states that for any pair of integers `a` and `b`, and a natural number `n`, if the difference `b - a` is equal to the natural number `n` (represented as an integer), then `a` is less than or equal to `b`. This is basically an introductory theorem for proving the less than or equal operation in the context of subtracting an integer from another.

If an integer `a` is less than or equal to another integer `b`, then `b` minus `a` is a natural number.


theorem NonUnitalRingHom.mem_range :
    ∀ {R : Type u} {S : Type v} [inst : NonUnitalNonAssocRing R] [inst_1 : NonUnitalNonAssocRing S] {f : R →ₙ+* S}
      {y : S}, y ∈ NonUnitalRingHom.range f ↔ ∃ x, f x = y :=
  by sorry

This theorem states that, given non-unital non-associative rings `R` and `S`, any ring homomorphism `f : R →ₙ+* S`, and any element `y` in `S`, `y` is in the range of `f` if and only if there exists an element `x` in `R` such that applying the ring homomorphism `f` to `x` produces `y`. This theorem essentially defines the range of a ring homomorphism in terms of the algebraic structures and the mapping it embodies.

A ring homomorphism maps an element in its domain to an element in its range if and only if there exists a corresponding element in the domain that maps to it under the homomorphism.


theorem Mathlib.LinearAlgebra.Prod._auxLemma.27 :
    ∀ {α : Sort u_1} {p : α → Prop} {a' : α}, (∃ a, a = a' ∧ p a) = p a' := by sorry

This theorem states that for any type `α`, any predicate `p` over this type, and any value `a'` of this type, there exists `a` such that `a` equals `a'` and `p` is true for `a` if and only if `p` is true for `a'`. In other words, the existence of an element satisfying some property is equivalent to that property being true for a specific element.

For any type `α`, predicate `p` over `α`, and value `a'` in `α`, there exists `a` in `α` such that `a = a'` if and only if `p(a) ↔ p(a')`.


theorem Set.image_mul_const_uIcc :
    ∀ {α : Type u_1} [inst : LinearOrderedField α] (a b c : α),
      (fun x => x * a) '' Set.uIcc b c = Set.uIcc (b * a) (c * a) :=
  by sorry

The theorem `Set.image_mul_const_uIcc` states that for any types `α` that are linearly ordered fields and for any three instances of `α` called `a`, `b`, `c`, the image of the set `uIcc b c` under the function that multiplies each element by `a` is equal to the set `uIcc (b * a) (c * a)`. In other words, multiplying all elements in the closed interval `[b, c]` by a constant `a` results in the closed interval `[b * a, c * a]`.

For any linearly ordered field `α` and elements `a`, `b`, `c` of `α`, the image of the interval `[b, c]` under the function that multiplies each element by `a` equals the interval `[b * a, c * a]`.


theorem Ideal.adic_basis : ∀ {R : Type u_1} [inst : CommRing R] (I : Ideal R), SubmodulesRingBasis fun n => I ^ n • ⊤ :=
  by sorry

This theorem states that for any commutative ring `R` and any ideal `I` of `R`, the set of all submodules of `R` that can be obtained by taking the `n`th power of `I` (denoted `I^n`) and scaling the entire ring `R` (denoted `⊤`) forms a basis with respect to the ring structure. This is often referred to as an 'adic basis'.

For any commutative ring `R` and ideal `I`, the set of all scaled `n`th powers of `I` (`{⊤ * I^n | n : ℕ}`) forms a basis for the submodule lattice of `R`.


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

The theorem `AddLECancellable.lt_tsub_of_add_lt_left` states that for any type `α` that has a partial order, a commutative semigroup structure under addition, a subtraction operation, and an ordered subtraction operation, if an element `a` of `α` is left-cancellable under addition (i.e., whenever adding `a` to two other elements `b` and `c` results in `b` being less than or equal to `c`, then `b` itself is less than or equal to `c`, as per the definition of `AddLECancellable`), then for any elements `b` and `c` of `α`, if the sum of `a` and `c` is less than `b`, then `c` is less than the difference of `b` and `a`. In terms of mathematical notation, this can be written as: if $a$ is AddLECancellable and $a + c < b$, then $c < b - a$.

If `α` is a type with a partial order, commutative semigroup structure under addition, subtraction, and ordered subtraction, and `a` is left-cancellable in `α`, then for all `b` and `c`, if `a + c < b`, then `c < b - a`.


theorem List.length_insertNth :
    ∀ {α : Type u} {a : α} (n : ℕ) (as : List α),
      n ≤ List.length as → List.length (List.insertNth n a as) = List.length as + 1 :=
  by sorry

The theorem `List.length_insertNth` states that for any type `α`, given an element `a` of type `α`, a natural number `n`, and a list `as` of type `α`, if `n` is less than or equal to the length of the list `as`, then the length of the list obtained by inserting `a` at the `n`-th position in `as` using the function `List.insertNth` is equal to the length of the original list plus one. This highlights that the operation of inserting an element at a certain position in a list increases the length of the list by one.

For any type `α` and list `as : α-- list`, if `n ≤ length as`, then `length (List.insertNth α a n as) = length as + 1`.


theorem Finset.smul_mem_smul_finset_iff :
    ∀ {α : Type u_2} {β : Type u_3} [inst : DecidableEq β] [inst_1 : Group α] [inst_2 : MulAction α β] {s : Finset β}
      {b : β} (a : α), a • b ∈ a • s ↔ b ∈ s :=
  by sorry

The theorem `Finset.smul_mem_smul_finset_iff` states that for any type `α` with an underlying group structure, and any type `β` with a multiplication action by `α`, given any finite set `s` of elements of type `β`, and any elements `a` of type `α` and `b` of type `β`, then `a • b` is an element of the set resulting from scaling each element of `s` by `a` if and only if `b` is an element of `s`. The equality on type `β` is assumed to be decidable. In other words, the scaling action of an element from a group `α` doesn't change the membership of an element in a finite set.

For any type `α` with a group structure, any type `β` with a left action by `α`, and a finite set `s` of elements in `β`, an element `a` in `α`, and an element `b` in `β`, `a • b` is in the scaled set `{a * x | x ∈ s}` if and only if `b` is in `s`.


theorem CategoryTheory.IsVanKampenColimit.precompose_isIso :
    ∀ {J : Type v'} [inst : CategoryTheory.Category.{u', v'} J] {C : Type u} [inst_1 : CategoryTheory.Category.{v, u} C]
      {F G : CategoryTheory.Functor J C} (α : F ⟶ G) [inst_2 : CategoryTheory.IsIso α]
      {c : CategoryTheory.Limits.Cocone G},
      CategoryTheory.IsVanKampenColimit c →
        CategoryTheory.IsVanKampenColimit ((CategoryTheory.Limits.Cocones.precompose α).obj c) :=
  by sorry

This theorem states that for any two functors `F` and `G` from a category `J` to a category `C`, if there is an isomorphism `α` from `F` to `G`, and if `c` is a colimit of `G` that satisfies Van Kampen's condition (i.e., `c` is a Van Kampen colimit), then the colimit of `F` obtained by precomposing `c` with `α` (denoted as `((CategoryTheory.Limits.Cocones.precompose α).obj c)`) also satisfies Van Kampen's condition. In other words, the property of being a Van Kampen colimit is preserved under precomposition with an isomorphism in category theory.

Given functors `F` and `G` from category `J` to category `C`, an isomorphism `α: F ≅ G`, and an object `c` in `C` that is a Van Kampen colimit of `G`, then `((CategoryTheory.Limits.Cocones.precompose α).obj c)` is also a Van Kampen colimit of `F`.


theorem Nat.findGreatest_eq_zero_iff :
    ∀ {k : ℕ} {P : ℕ → Prop} [inst : DecidablePred P], Nat.findGreatest P k = 0 ↔ ∀ ⦃n : ℕ⦄, 0 < n → n ≤ k → ¬P n := by
  sorry

The theorem `Nat.findGreatest_eq_zero_iff` states that for any natural number `k` and any predicate `P` on natural numbers, where `P` is a decidable predicate, the greatest natural number less than or equal to `k` for which `P` holds is `0` if and only if for every natural number `n` greater than `0` and less than or equal to `k`, the predicate `P` does not hold for `n`. In other words, `P` does not hold for any natural numbers in the range from `1` to `k`.

For any decidable predicate P on natural numbers, the greatest natural number less than or equal to k with property P is 0 if and only if no natural number n, with 0 < n <= k, has property P.


Bornology.IsVonNBounded.add

theorem Bornology.IsVonNBounded.add :
    ∀ {𝕜 : Type u_1} {E : Type u_3} [inst : SeminormedRing 𝕜] [inst_1 : AddZeroClass E] [inst_2 : TopologicalSpace E]
      [inst_3 : ContinuousAdd E] [inst_4 : DistribSMul 𝕜 E] {s t : Set E},
      Bornology.IsVonNBounded 𝕜 s → Bornology.IsVonNBounded 𝕜 t → Bornology.IsVonNBounded 𝕜 (s + t) :=
  by sorry

The theorem `Bornology.IsVonNBounded.add` states that for any two sets `s` and `t` in a topological space `E` over a seminormed ring `𝕜`, if both `s` and `t` are von Neumann bounded (meaning every neighbourhood of 0 absorbs them), then the sum of `s` and `t` (defined as `s + t`) is also von Neumann bounded. Here, `E` has the additional structures of an additive zero class and a continuous addition operation, and the scalar multiplication by `𝕜` is distributive over the addition in `E`.

If two sets in a topological space over a seminormed ring are von Neumann bounded, then their sum is also von Neumann bounded.


theorem Mathlib.LinearAlgebra.Prod._auxLemma.30 : ∀ {a : Prop}, (a → a) = True := by sorry

This theorem, `Mathlib.LinearAlgebra.Prod._auxLemma.30`, states that for any proposition `a`, the statement "`a` implies `a`" is always true. In other words, if any proposition is true, then it indeed implies itself. This is a fundamental law of logic known as reflexivity.

For any proposition `a`, `a` implies `a`.


theorem AlgebraicGeometry.LocallyRingedSpace.IsOpenImmersion.lift_fac :
    ∀ {X Y Z : AlgebraicGeometry.LocallyRingedSpace} (f : X ⟶ Z) (g : Y ⟶ Z)
      [H : AlgebraicGeometry.LocallyRingedSpace.IsOpenImmersion f] (H' : Set.range ⇑g.val.base ⊆ Set.range ⇑f.val.base),
      CategoryTheory.CategoryStruct.comp (AlgebraicGeometry.LocallyRingedSpace.IsOpenImmersion.lift f g H') f = g :=
  by sorry

The theorem `AlgebraicGeometry.LocallyRingedSpace.IsOpenImmersion.lift_fac` states that for any three locally ringed spaces `X`, `Y`, and `Z`, and morphisms `f` from `X` to `Z` and `g` from `Y` to `Z`, given that `f` is an open immersion and the range of `g` is a subset of the range of `f`, the composition of the lift of `g` along `f` and `f` is equal to `g`. In other words, if we 'lift' `g` along `f` (which is an open immersion), and then apply `f`, we get back `g`. This can be seen as a property of 'lifting' operations in the category of locally ringed spaces.

Given locally ringed spaces X, Y, Z and morphisms f : X -> Z and g : Y -> Z with f an open immersion and g(Y) a subset of f(X), the lift of g along f, followed by f, equals g.


theorem UniqueFactorizationMonoid.normalizedFactors_irreducible :
    ∀ {α : Type u_1} [inst : CancelCommMonoidWithZero α] [inst_1 : NormalizationMonoid α]
      [inst_2 : UniqueFactorizationMonoid α] {a : α},
      Irreducible a → UniqueFactorizationMonoid.normalizedFactors a = {normalize a} :=
  by sorry

The theorem `UniqueFactorizationMonoid.normalizedFactors_irreducible` states that for any irreducible element `a` in a unique factorization monoid `α` (a commutative monoid with zero where the only unit multiples of a given element are itself and its associates), the multiset of the normalized (obtained by multiplying by `normUnit`) prime factors of `a` is a singleton set containing only the normalized form of `a`. This essentially means that the irreducible element `a` does not have any other prime factors except for its normalized form.

In a unique factorization monoid, the normalized prime factors of an irreducible element form a singleton set.


theorem abs_le' : ∀ {α : Type u_1} [inst : Lattice α] [inst_1 : AddGroup α] {a b : α}, |a| ≤ b ↔ a ≤ b ∧ -a ≤ b := by
  sorry

The theorem `abs_le'` states that for all types `α`, where `α` is a lattice and an additive group, and for any two elements `a` and `b` of type `α`, the absolute value of `a` is less than or equal to `b` if and only if `a` is less than or equal to `b` and `-a` is less than or equal to `b`. This theorem essentially expresses the property of absolute values in the context of lattices and additive groups.

For all lattice and additive groups $\alpha$, and all $a, b \in \alpha$, $|a| \leq b$ if and only if $a \leq b$ and $-a \leq b$.


Pi.Lex.wellFounded

theorem Pi.Lex.wellFounded :
    ∀ {ι : Type u_1} {α : ι → Type u_2} (r : ι → ι → Prop) {s : (i : ι) → α i → α i → Prop}
      [inst : IsStrictTotalOrder ι r] [inst : Finite ι],
      (∀ (i : ι), WellFounded (s i)) → WellFounded (Pi.Lex r fun {i} => s i) :=
  by sorry

This theorem states that, for any types ι and α (with α depending on ι), given a relation r on ι and a family of relations s indexed by ι on α, if r is a strict total order, the type ι is finite, and each relation s(i) is well-founded, then the lexicographic relation formed by r and s on the product type, (i : ι) → α i, is also well-founded.

In simpler words, it says that if we have a well-ordered type and a family of well-ordered types indexed by the first, the lexicographic order defined over the whole family is also well-ordered.

If ι is a finite, strictly totally ordered type and each relation s(i) on α (for i : ι) is well-founded, then the lexicographic order on the product type (i : ι) → α i is well-founded.


theorem Convex.linear_preimage :
    ∀ {𝕜 : Type u_1} {E : Type u_2} {F : Type u_3} [inst : OrderedSemiring 𝕜] [inst_1 : AddCommMonoid E]
      [inst_2 : AddCommMonoid F] [inst_3 : Module 𝕜 E] [inst_4 : Module 𝕜 F] {s : Set F},
      Convex 𝕜 s → ∀ (f : E →ₗ[𝕜] F), Convex 𝕜 (⇑f ⁻¹' s) :=
  by sorry

The theorem `Convex.linear_preimage` states that for any ordered semiring `𝕜`, and any two additive commutative monoids `E` and `F` that also have a module structure over `𝕜`, if a set `s` in `F` is convex, then the preimage of `s` under any linear map `f` from `E` to `F` is also a convex set in `E`. In other words, the preimage of a convex set under a linear map is also convex.

Given an ordered semiring 𝕜, and additive commutative monoids E and F with a module structure over 𝕜, if s is a convex subset of F and f is a linear map from E to F, then the preimage of s under f is a convex subset of E.


theorem List.sum_hom :
    ∀ {M : Type u_5} {N : Type u_6} [inst : AddMonoid M] [inst_1 : AddMonoid N] (l : List M) {F : Type u_11}
      [inst_2 : FunLike F M N] [inst_3 : AddMonoidHomClass F M N] (f : F),
      List.sum (List.map (⇑f) l) = f (List.sum l) :=
  by sorry

The theorem `List.sum_hom` states that for any types `M` and `N` that form addition monoids, any list `l` of elements of type `M`, any type `F` that has an injective function-like behavior from `M` to `N` and respects the structure of an additive monoid homomorphism, and any function `f` of type `F`, the sum of the list obtained by mapping `f` over `l` is equal to the result of applying `f` to the sum of `l`. This reflects the distributivity of the sum over the function application.

For any additive monoids M and N, any injective, additive monoid homomorphism F from M to N, and any list l of elements from M, the sum of the images of l under F is equal to the image of the sum of l under F.


theorem Rat.not_irrational : ∀ (q : ℚ), ¬Irrational ↑q := by sorry

The theorem `Rat.not_irrational` states that for all rational numbers `q`, it is not the case that `q` is irrational. In other words, there are no rational numbers that are also irrational. This aligns with the mathematical definition where a number cannot be both rational and irrational at the same time.

Every rational number is non-irrational. (Equivalently, there are no rational irrational numbers.)


theorem CategoryTheory.Equalizer.FirstObj.proof_1 :
    ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] (P : CategoryTheory.Functor Cᵒᵖ (Type (max u_2 u_1)))
      {X : C} (R : CategoryTheory.Presieve X),
      CategoryTheory.Limits.HasLimit (CategoryTheory.Discrete.functor fun f => P.obj (Opposite.op f.fst)) :=
  by sorry

This theorem states that for any category `C`, functor `P` from the opposite of `C` to the type `Type (max u_2 u_1)`, object `X` in `C`, and presieve `R` on `X`, there exists a limit for the functor obtained by assigning each element `f` in the discrete category (defined by the presieve `R`) to the object in the category of the functor `P` evaluated at the domain (first projection `f.fst`) of `f`, seen as an object in the opposite category of `C` (`Opposite.op f.fst`). In essence, this theorem is about the existence of certain limits in a functor category.

For any category `C`, functor `P` from `Opposite C` to `Type`, object `X` in `C`, and presieve `R` on `X`, there exists a limit of the functor `P` along `R`.


theorem ProbabilityTheory.kernel.iIndepFun.indepFun_finset_sum_of_not_mem :
    ∀ {α : Type u_1} {Ω : Type u_2} {ι : Type u_3} {_mα : MeasurableSpace α} {_mΩ : MeasurableSpace Ω}
      {κ : ↥(ProbabilityTheory.kernel α Ω)} {μ : MeasureTheory.Measure α} {β : Type u_8} {m : MeasurableSpace β}
      [inst : AddCommMonoid β] [inst_1 : MeasurableAdd₂ β] {f : ι → Ω → β}
      [inst_2 : ProbabilityTheory.IsMarkovKernel κ],
      ProbabilityTheory.kernel.iIndepFun (fun x => m) f κ μ →
        (∀ (i : ι), Measurable (f i)) →
          ∀ {s : Finset ι} {i : ι}, i ∉ s → ProbabilityTheory.kernel.IndepFun (Finset.sum s fun j => f j) (f i) κ μ :=
  by sorry

This theorem states that for any types `α`, `Ω`, `ι`, and `β`, given measurable spaces over `α` and `Ω`, a subset of the kernel of a probability theory in `α` and `Ω`, a measure over `α`, a measurable space over `β`, a function `f` from `ι` to `Ω` to `β`, and assuming that `β` is an additive commutative monoid and that the function is measurable under addition, if `κ` is a Markov kernel, then if the function `f` is independent of the kernel `κ` under the measure `μ`, and for all indices `i` in `ι`, the function `f` at `i` is measurable, then for any finite set `s` of indices in `ι`, and for any index `i` in `ι` not in the set `s`, the function `f` at `i` is independent of the sum over `s` of the function `f` at each index in `s`, under the kernel `κ` and measure `μ`. It's part of the formalization of the concept of independence in probability theory.

Given measurable spaces `α`, `Ω`, measurable functions `f: ι -> Ω -> β` from a type `ι` to `Ω` to a commutative additive monoid `β`, a probability theory `κ` on `α × Ω`, a measure `μ` on `α`, and assuming `f` is measurable, independent of `κ` under `μ` for all indices in `ι`, and `f(i)` is measurable for all `i` in `ι`, then for any finite subset `s` of `ι` and any `i` not in `s`, `f(i)` is independent of the sum of `f` over `s` under `κ` and `μ`.


theorem List.Perm.foldl_eq' :
    ∀ {β : Type u_1} {α : Type u_2} {f : β → α → β} {l₁ l₂ : List α},
      List.Perm l₁ l₂ →
        (∀ x ∈ l₁, ∀ y ∈ l₁, ∀ (z : β), f (f z x) y = f (f z y) x) →
          ∀ (init : β), List.foldl f init l₁ = List.foldl f init l₂ :=
  by sorry

The theorem `List.Perm.foldl_eq'` states that for any types `β` and `α`, and for any function `f` of type `β → α → β`, if two lists `l₁` and `l₂` of type `α` are permutations of each other, then for any `x` and `y` in `l₁`, and for any `z` of type `β`, if the function `f` applied to `z`, `x` and `y` (in that order) is equal to `f` applied to `z`, `y` and `x` (in that order), then the result of folding `f` over `l₁` starting with some initial value `init` of type `β` is equal to the result of folding `f` over `l₂` starting with the same initial value. In terms of mathematics, the theorem is saying that the fold of a function over a list remains the same even if the order of elements in the list is changed, as long as the function satisfies a specific commutation condition.

If two lists are permutations of each other and the function used for folding satisfies the commutativity condition `f (z, x) = f (z, y) <-> f (z, y) = f (z, x)`, then folding `f` over the first list starting with an initial value is equal to folding `f` over the second list starting with the same initial value.


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

The theorem `AlgHom.id_comp` states that for any commutative semiring `R`, semirings `A` and `B`, and algebra structures over `R` on `A` and `B`, the composition of the identity algebra homomorphism on `B` and any algebra homomorphism `φ` from `A` to `B` is equivalent to `φ` itself. In other words, when an algebra homomorphism is followed by the identity operation, it doesn't change the original algebra homomorphism, which mirrors the mathematical concept that applying identity function to any function leaves the function unchanged.

For any commutative semirings R, semirings A and B, and algebra structures over R on A and B, the composition of the identity algebra homomorphism on B and any algebra homomorphism from A to B is equal to the algebra homomorphism itself.


theorem ContinuousOn.image_Icc :
    ∀ {α : Type u_2} {β : Type u_3} [inst : ConditionallyCompleteLinearOrder α] [inst_1 : TopologicalSpace α]
      [inst_2 : OrderTopology α] [inst_3 : TopologicalSpace β] [inst_4 : DenselyOrdered α]
      [inst_5 : ConditionallyCompleteLinearOrder β] [inst_6 : OrderTopology β] {f : α → β} {a b : α},
      a ≤ b →
        ContinuousOn f (Set.Icc a b) → f '' Set.Icc a b = Set.Icc (sInf (f '' Set.Icc a b)) (sSup (f '' Set.Icc a b)) :=
  by sorry

This theorem states that for any two types `α` and `β`, provided that `α` and `β` are both conditionally complete linear ordered spaces with a topological structure and `α` is densely ordered, and given a function `f` from `α` to `β` and two elements `a` and `b` in `α` such that `a` is less than or equal to `b`, if `f` is continuous on the closed interval `[a, b]`, then the image of the interval `[a, b]` under `f` is the closed interval from the greatest lower bound of the image to the least upper bound of the image, denoted as `[sInf (f '' Set.Icc a b), sSup (f '' Set.Icc a b)]`.

Given two conditionally complete, topological linear ordered spaces `α` and `β`, where `α` is densely ordered, and a continuous function `f` from `α` to `β` such that `a ≤ b` are elements of `α`, then the image of the closed interval `[a, b]` under `f` is the closed interval `[inf(f(a:α):β), sup(f(b:α):β)]`.


Sum.LiftRel.lex

theorem Sum.LiftRel.lex :
    ∀ {α : Type u_1} {β : Type u_2} {r : α → α → Prop} {s : β → β → Prop} {a b : α ⊕ β},
      Sum.LiftRel r s a b → Sum.Lex r s a b :=
  by sorry

This theorem states that for any two types `α` and `β`, and any two relations `r` on `α` and `s` on `β`, and for any two elements `a` and `b` that are either of type `α` or `β` (i.e., in the sum type `α ⊕ β`), if `a` and `b` satisfy the `Sum.LiftRel` predicate with respect to relations `r` and `s`, then `a` and `b` satisfy the `Sum.Lex` relation with respect to the same relations `r` and `s`. In other words, this theorem is about the preservation of a relational property when moving from the `LiftRel` predicate to the `Lex` relation on sum types.

If `a` and `b` satisfy the `Sum.LiftRel` relation with respect to relations `r` on `α` and `s` on `β`, then `a` and `b` satisfy the `Sum. Lex` relation with respect to `r` and `s`.


theorem Polynomial.coeff_scaleRoots_natDegree :
    ∀ {R : Type u_1} [inst : Semiring R] (p : Polynomial R) (s : R),
      Polynomial.coeff (Polynomial.scaleRoots p s) (Polynomial.natDegree p) = Polynomial.leadingCoeff p :=
  by sorry

This theorem states that for any semiring `R`, polynomial `p` of type `R`, and scalar `s` of type `R`, the coefficient of the term with the highest degree in the polynomial obtained by scaling the roots of `p` by `s` (`Polynomial.scaleRoots p s`) is equal to the leading coefficient of `p` (`Polynomial.leadingCoeff p`).

In other words, the scaling of roots does not change the leading coefficient of the polynomial. In mathematical terms, if `p` is a polynomial and `s` is a scalar, then the coefficient of the highest degree term in the polynomial `p` whose roots are multiplied by `s` will be the same as the coefficient of the highest degree term in the original polynomial `p`.

For any semiring `R`, polynomial `p` of type `R`, and scalar `s` of type `R`, the leading coefficient of the polynomial obtained by scaling the roots of `p` by `s` (`Polynomial.scaleRoots p s`) equals the leading coefficient of `p` (`Polynomial.leadingCoeff p`).


theorem List.length_dropLast : ∀ {α : Type u_1} (xs : List α), List.length (List.dropLast xs) = List.length xs - 1 := by
  sorry

This theorem states that for any list of elements of some type `α`, the length of the list obtained by removing the last element from the original list is equal to the length of the original list minus one. In other words, if `xs` is a list, then the length of `List.dropLast xs` (i.e., `xs` with its last element removed) is `List.length xs - 1`. This property holds for all lists, regardless of their length or the type of their elements.

For any list `xs` of length `n` over type `α`, the length of `List.dropLast (xs : List α)` is `n - 1`.


theorem AddUnits.inducing_embedProduct :
    ∀ {M : Type u_1} [inst : TopologicalSpace M] [inst_1 : AddMonoid M], Inducing ⇑(AddUnits.embedProduct M) := by sorry

The theorem `AddUnits.inducing_embedProduct` states that for any type `M` which has a topology and an additive monoid structure, the map `AddUnits.embedProduct M` is an inducing function. In topology, an inducing function is one that pulls back the topology from the codomain to the domain, making the topology of the domain the initial topology with respect to that function. In this case, the function `AddUnits.embedProduct M` carries the topology from the product of `M` and the opposite of `M` back to `AddUnits M`.

The `AddUnits.embedProduct` map of a topological additive monoid `M` is a topology-preserving embedding.


/-- See note [partially-applied ext lemmas].  -/
theorem Abelianization.hom_ext :
    ∀ {G : Type u} [inst : Group G] {A : Type v} [inst_1 : Monoid A] (φ ψ : Abelianization G →* A),
      MonoidHom.comp φ Abelianization.of = MonoidHom.comp ψ Abelianization.of → φ = ψ :=
  by sorry

The theorem `Abelianization.hom_ext` states that for any group `G` and any monoid `A`, if two monoid morphisms `φ` and `ψ` from the abelianization of `G` to `A` are such that their compositions with the canonical projection from `G` to its abelianization are equal, then the two morphisms `φ` and `ψ` themselves are equal. In other words, it provides a criterion for the equality of morphisms from the abelianization of a group to a monoid in terms of their compositions with the canonical projection.

If two morphisms from the abelianization of a group to a monoid have equal compositions with the canonical projection, then they are equal.


/-- **Fubini's Theorem**: For integrable functions on `α × β`,
the Bochner integral of `f` is equal to the iterated Bochner integral.
`integrable_prod_iff` can be useful to show that the function in question in integrable.
`MeasureTheory.Integrable.integral_prod_right` is useful to show that the inner integral
of the right-hand side is integrable.  -/
theorem MeasureTheory.integral_prod :
    ∀ {α : Type u_1} {β : Type u_3} {E : Type u_6} [inst : MeasurableSpace α] [inst_1 : MeasurableSpace β]
      {μ : MeasureTheory.Measure α} {ν : MeasureTheory.Measure β} [inst_2 : NormedAddCommGroup E]
      [inst_3 : MeasureTheory.SigmaFinite ν] [inst_4 : NormedSpace ℝ E] [inst_5 : MeasureTheory.SigmaFinite μ]
      (f : α × β → E),
      MeasureTheory.Integrable f (MeasureTheory.Measure.prod μ ν) →
        ∫ (z : α × β), f z ∂MeasureTheory.Measure.prod μ ν = ∫ (x : α), ∫ (y : β), f (x, y) ∂ν ∂μ :=
  by sorry

**Fubini's Theorem**: This theorem states that for a function `f` on a product space `α × β` that is integrable with respect to the product of measures `μ` and `ν`, the Bochner integral of `f` with respect to the product measure equals the iterated Bochner integral of `f` with respect to the measures `ν` and `μ`. In other words, the integral of `f` over the product space can be computed as an iteration of integrals over each individual space. The theorem assumes that both `μ` and `ν` are sigma-finite measures, and the integrable space `E` is a normed add commutative group over the reals. The functions `integrable_prod_iff` and `MeasureTheory.Integrable.integral_prod_right` can be useful to show that the function is integrable and that the inner integral of the right-hand side is integrable, respectively.

Fubini's Theorem states that for a measurable and integrable function on a product measure space, its integral with respect to the product measure equals the iterated integral with respect to the measures on the individual factor spaces.


theorem Set.image2_union_inter_subset :
    ∀ {α : Type u_1} {β : Type u_3} {f : α → α → β} {s t : Set α},
      (∀ (a b : α), f a b = f b a) → Set.image2 f (s ∪ t) (s ∩ t) ⊆ Set.image2 f s t :=
  by sorry

This theorem states that for any fixed type `α`, any type `β`, a binary function `f : α → α → β` that is symmetric (i.e., `f a b = f b a` for all `a` and `b`), and any two sets `s` and `t` of type `α`, the image under `f` of the union of `s` and `t` and the intersection of `s` and `t` is a subset of the image under `f` of `s` and `t`. Said differently, the theorem states that for all `a` in `s ∪ t` and `b` in `s ∩ t`, `f(a, b)` is also an element of the set `{f(a', b') | a' ∈ s, b' ∈ t}`.

For any symmetric binary function `f` and sets `s` and `t` of the same type `α`, `image f (s ∪ t)` is a subset of `image f s ∪ image f t`, and similarly for intersections.


theorem MeasureTheory.Measure.sum_fintype :
    ∀ {α : Type u_1} {ι : Type u_5} {m0 : MeasurableSpace α} [inst : Fintype ι] (μ : ι → MeasureTheory.Measure α),
      MeasureTheory.Measure.sum μ = Finset.sum Finset.univ fun i => μ i :=
  by sorry

This theorem, `MeasureTheory.Measure.sum_fintype`, is about the sum of measures over a finite index set. It says that for any measurable space `α`, any type `ι` that has a finite number of elements (`Fintype ι`), and a function `μ` that assigns to each element of `ι` a measure on `α`, the sum of these measures (`MeasureTheory.Measure.sum μ`) is equal to the sum of the measures for each element in the universal finite set (`Finset.univ`) of `ι` (i.e., `Finset.sum Finset.univ fun i => μ i`). In other words, we can compute the sum of an indexed family of measures by simply adding up the measures for each individual index in the family.

For any measurable space `α`, given a finite index set `ι` and a measurable function `μ : ι → α → ℝ` assigning a measure to each element-wise pair in `ι × α`, the sum of these measures equals the sum of measures for every index in `ι` over the universal set of `ι`: `MeasureTheory.Measure.sum μ = Finset.sum Finset.univ fun i => μ i`.


theorem List.count_cons_of_ne :
    ∀ {α : Type u_1} [inst : DecidableEq α] {a b : α}, a ≠ b → ∀ (l : List α), List.count a (b :: l) = List.count a l :=
  by sorry

This theorem states that for any type `α` with decidable equality (`DecidableEq α`), given two elements `a` and `b` of this type such that `a ≠ b`, and given a list `l` of elements of type `α`, the number of occurrences of `a` in the list that is obtained by prepending `b` to `l` (`b :: l`) is equal to the number of occurrences of `a` in the original list `l`. In other words, prepending an element not equal to `a` to the list does not change the count of `a` in the list.

For any type `α` with decidable equality, and any `a ≠ b` in `α`, the number of occurrences of `a` in the list `b :: l` is equal to the number of occurrences of `a` in the list `l`.


theorem Real.contDiffAt_arcsin : ∀ {x : ℝ}, x ≠ -1 → x ≠ 1 → ∀ {n : ℕ∞}, ContDiffAt ℝ n Real.arcsin x := by sorry

The theorem `Real.contDiffAt_arcsin` states that for any real number `x` which is not equal to `-1` or `1`, and for any natural number or infinity `n`, the function `Real.arcsin` is continuously differentiable at `x`. In mathematical terms, this means the arcsine function has derivatives of all orders at any point in its domain, except at the points `-1` and `1`.

For any real number `x` not equal to `-1` or `1`, the function `Real.arcsin` is continuously differentiable at `x`.


theorem Nat.sub_one : ∀ (n : ℕ), n - 1 = Nat.pred n := by sorry

This theorem states that for any natural number 'n', subtracting one from 'n' is equal to applying the predecessor function on 'n'. In other words, for all natural numbers 'n', 'n - 1' is equivalent to the result of the 'Nat.pred' function when given 'n' as an argument. The predecessor function returns 'n - 1' for any given natural number 'n', but if 'n' is zero, it returns zero.

For all natural numbers n, Nat.pred n = n - 1.


theorem PrimeSpectrum.vanishingIdeal_anti_mono_iff :
    ∀ {R : Type u} [inst : CommSemiring R] {s t : Set (PrimeSpectrum R)},
      IsClosed t → (s ⊆ t ↔ PrimeSpectrum.vanishingIdeal t ≤ PrimeSpectrum.vanishingIdeal s) :=
  by sorry

The theorem `PrimeSpectrum.vanishingIdeal_anti_mono_iff` states that for any type `R` with a commutative semiring structure and any two sets `s` and `t` of prime spectrums of `R`, if `t` is a closed set, then `s` is a subset of `t` if and only if the vanishing ideal of `t` is less than or equal to the vanishing ideal of `s`. Here, "less than or equal to" refers to the subset relation in the lattice structure of ideals in the ring, and the "prime spectrum" of a ring is the set of all prime ideals of the ring. The "vanishing ideal" of a set of prime ideals is the intersection of those ideals.

A set of prime ideals in a commutative semiring is a subset of another if and only if the vanishing ideal of the second set is less than or equal to the vanishing ideal of the first.


theorem intervalIntegral.integral_smul :
    ∀ {E : Type u_3} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {a b : ℝ} {μ : MeasureTheory.Measure ℝ}
      {𝕜 : Type u_6} [inst_2 : NontriviallyNormedField 𝕜] [inst_3 : NormedSpace 𝕜 E] [inst_4 : SMulCommClass ℝ 𝕜 E]
      (r : 𝕜) (f : ℝ → E), ∫ (x : ℝ) in a..b, r • f x ∂μ = r • ∫ (x : ℝ) in a..b, f x ∂μ :=
  by sorry

This theorem, `intervalIntegral.integral_smul`, states that for any normed add commutative group E, normed space over the reals ℝ and 𝕜, any measure μ on the reals, and any type 𝕜 with a nontrivial normed field structure, normed space structure over E, and a scalar multiplication commutative class structure, the interval integral of a function `f` multiplied by a scalar `r` over an interval `[a, b]` is equal to the scalar `r` multiplied by the integral of the function `f` over the same interval. In mathematical terms, for all real numbers a and b, scalar r, and function f, ∫ (x : ℝ) in a..b, r • f x ∂μ = r • ∫ (x : ℝ) in a..b, f x ∂μ. This is a generalization of the well-known property of definite integrals where the integral of a scalar multiple of a function is the scalar multiple of the integral of the function.

For any normed add commutative group E, normed space over the reals ℝ, measure μ on the reals, and scalar r in a normed field 𝕜, the integral of the product of r and a function f over an interval [a, b] is equal to the product of r and the integral of f over the same interval.


theorem Polynomial.opRingEquiv_symm_monomial :
    ∀ {R : Type u_1} [inst : Semiring R] (n : ℕ) (r : Rᵐᵒᵖ),
      (RingEquiv.symm (Polynomial.opRingEquiv R)) ((Polynomial.monomial n) r) =
        MulOpposite.op ((Polynomial.monomial n) (MulOpposite.unop r)) :=
  by sorry

The theorem `Polynomial.opRingEquiv_symm_monomial` states that for any semiring `R`, natural number `n` and an element `r` of the opposite ring of `R`, the inverse of the ring isomorphism (`RingEquiv.symm`) transformed by `Polynomial.opRingEquiv R` and applied to the monomial `n` of `r` (`Polynomial.monomial n r`) is equivalent to the monomial `n` applied to the unopposite of `r` (`MulOpposite.unop r`) and then made opposite (`MulOpposite.op`). In other words, switching the roles of addition and multiplication in a polynomial ring `R` and then taking a monomial doesn't change the monomial if you switch the roles of addition and multiplication back in the coefficients.

For any semiring `R`, the application of `Polynomial.opRingEquiv R` to the monomial `n` of an element `r` in the opposite ring of `R` is equivalent to the monomial `n` applied to the unopposite of `r` and made opposite.


theorem contDiffAt_inv :
    ∀ (𝕜 : Type u_1) [inst : NontriviallyNormedField 𝕜] {𝕜' : Type u_4} [inst_1 : NormedField 𝕜']
      [inst_2 : NormedAlgebra 𝕜 𝕜'] [inst_3 : CompleteSpace 𝕜'] {x : 𝕜'},
      x ≠ 0 → ∀ {n : ℕ∞}, ContDiffAt 𝕜 n Inv.inv x :=
  by sorry

The theorem `contDiffAt_inv` states that for any nontrivially normed field `𝕜`, any normed field `𝕜'` which is also a normed algebra over `𝕜` and a complete space, any non-zero element `x` of `𝕜'`, and any `n` in `ℕ∞` (the natural numbers together with positive infinity), the function `Inv.inv` (which inverts elements of a type) is `n`-times continuously differentiable at `x`.

For any nontrivially normed field `𝕜`, normed field `𝕜'` over `𝕜` that is also a complete normed algebra, and any non-zero `x` in `𝕜'`, the function `Inv.inv` is `n`-times continuously differentiable at `x`.


theorem Orientation.inner_rightAngleRotationAux₁_left :
    ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : InnerProductSpace ℝ E]
      [inst_2 : Fact (FiniteDimensional.finrank ℝ E = 2)] (o : Orientation ℝ E (Fin 2)) (x y : E),
      ⟪(Orientation.rightAngleRotationAux₁ o) x, y⟫_ℝ = ((Orientation.areaForm o) x) y :=
  by sorry

This theorem states that for any oriented real inner product space `E` of dimension 2, given an orientation `o` of `E` and any two vectors `x` and `y` in `E`, the inner product of the vector obtained by rotating `x` by 90 degrees (according to the orientation `o`) and `y` is equal to the oriented area of the parallelogram spanned by `x` and `y`. In terms of linear algebra, this can be understood as the application of an antisymmetric bilinear form, which is a geometric way of saying that we rotate one vector and then compute the "signed" area between the rotated vector and another vector.

For any oriented 2-dimensional real inner product space and orientation, the inner product of the vector obtained by rotating one vector by 90 degrees with respect to the orientation and another vector is equal to the signed area of the parallelogram spanned by the two vectors.


/-- Natural division is always less than division in the field.  -/
theorem Nat.cast_div_le : ∀ {α : Type u_1} [inst : LinearOrderedSemifield α] {m n : ℕ}, ↑(m / n) ≤ ↑m / ↑n := by sorry

This theorem states that for any linearly ordered semifield `α` and for any natural numbers `m` and `n`, the division of `m` by `n` in the natural number domain, when cast to `α`, is always less than or equal to the division of `m` by `n` in the field `α`. In other words, it asserts that casting the result of an integer division to a field is always less than or equal to performing the division within the field.

For any linearly ordered semifield `α`, and natural numbers `m` and `n`, the cast of `m / n` from the natural number domain to `α` is less than or equal to `m / n` in `α`.


theorem TopologicalSpace.Opens.iSup_def :
    ∀ {α : Type u_2} [inst : TopologicalSpace α] {ι : Sort u_5} (s : ι → TopologicalSpace.Opens α),
      ⨆ i, s i = { carrier := ⋃ i, ↑(s i), is_open' := ⋯ } :=
  by sorry

This theorem states that for any type `α` equipped with a topological space structure, and for any indexed collection of open sets `s`, indexed over an arbitrary `ι`, the supremum (i.e., the least upper bound) of this collection, denoted by `⨆ i, s i`, is defined to be the open set whose carrier (i.e., underlying set) is the union of the carriers of the elements of `s`, and whose 'is_open' status is suppressed in the theorem statement.

In the context of topology, this theorem essentially says that the supremum of a collection of open sets is the open set formed by taking the union of all the sets in the collection.

The supremum of an indexed collection of open sets in a topological space is the open set with the union of their underlying sets.


/-- When a function has a limit at infinity, and its derivative is nonnegative, then the derivative
is automatically integrable on `(a, +∞)`. Version assuming differentiability
on `(a, +∞)` and continuity at `a⁺`.  -/
theorem MeasureTheory.integrableOn_Ioi_deriv_of_nonneg :
    ∀ {g g' : ℝ → ℝ} {a l : ℝ},
      ContinuousWithinAt g (Set.Ici a) a →
        (∀ x ∈ Set.Ioi a, HasDerivAt g (g' x) x) →
          (∀ x ∈ Set.Ioi a, 0 ≤ g' x) →
            Filter.Tendsto g Filter.atTop (nhds l) → MeasureTheory.IntegrableOn g' (Set.Ioi a) MeasureTheory.volume :=
  by sorry

This theorem, `MeasureTheory.integrableOn_Ioi_deriv_of_nonneg`, states that for any real-valued functions `g` and `g'` and any real numbers `a` and `l`, if `g` is continuous at `a` within the set of all real numbers greater than or equal to `a`, and if `g` has a derivative `g'(x)` at any point `x` strictly greater than `a`, with `g'(x)` being nonnegative for such `x`, and if `g` tends to `l` as `x` tends to infinity, then `g'` is integrable on the interval `(a, +∞)` with respect to the Lebesgue measure.

If a real-valued function `g` is continuous at `a`, has nonnegative, integrable derivative on `(a, +∞)`, and tends to a limit `l` as `x` approaches infinity, then `g` is integrable on `(a, +∞)`.


theorem ENNReal.tsum_eq_zero : ∀ {α : Type u_1} {f : α → ENNReal}, ∑' (i : α), f i = 0 ↔ ∀ (i : α), f i = 0 := by sorry

This theorem states that for any type `α` and a function `f` from `α` to the extended nonnegative real numbers (usually denoted as `[0, ∞]`), the sum of the sequence `f` equals zero if and only if every element in the sequence `f` equals zero. In mathematical terms, it says that `∑' (i : α), f i = 0` if and only if `∀ (i : α), f i = 0`.

For any function `f` from type `α` to the extended nonnegative real numbers, the sum of `f` equals zero if and only if every element in `f` is zero.


Small.mk'

/-- Constructor for `Small α` from an explicit witness type and equivalence.
 -/
theorem Small.mk' : ∀ {α : Type v} {S : Type w}, α ≃ S → Small.{w, v} α := by sorry

This theorem states that for any type `α` and another type `S`, if there exists an equivalence between `α` and `S` (denoted as `α ≃ S`), then `α` can be considered "small" relative to `S` (denoted as `Small.{w, v} α`). Here, the concept of "small" is a technical notion in type theory related to the size of types.

If `α` is equivalent to type `S`, then `α` is considered "small" relative to `S` in type theory.


Summable.abs

/-- **Alias** of the reverse direction of `summable_abs_iff`. -/
theorem Summable.abs :
    ∀ {ι : Type u_1} {α : Type u_3} [inst : LinearOrderedAddCommGroup α] [inst_1 : UniformSpace α]
      [inst_2 : UniformAddGroup α] [inst_3 : CompleteSpace α] {f : ι → α}, Summable f → Summable fun x => |f x| :=
  by sorry

The theorem `Summable.abs` states that for any type `ι` and any type `α` that is a linearly ordered additive commutative group, a uniform space, a uniform additive group and a complete space, if a function `f` from `ι` to `α` is summable (i.e., it has an infinite sum), then the function that maps each `x` in `ι` to the absolute value of `f(x)` is also summable. In other words, if a function has a sum, then the function that takes the absolute values of the original function's values also has a sum.

If `f` is a summable function from a linearly ordered, additive commutative group `ι` to a uniform additive group and complete space `α`, then the function `x ↦ |f x|` is also summable.


theorem Dilation.dist_eq :
    ∀ {α : Type u_6} {β : Type u_7} {F : Type u_8} [inst : PseudoMetricSpace α] [inst_1 : PseudoMetricSpace β]
      [inst_2 : FunLike F α β] [inst_3 : DilationClass F α β] (f : F) (x y : α),
      dist (f x) (f y) = ↑(Dilation.ratio f) * dist x y :=
  by sorry

This theorem states that for any types `α`, `β`, and `F`, given that `α` and `β` are pseudometric spaces, `F` is a function-like from `α` to `β`, and `F` is a dilation class from `α` to `β`, for any function `f` of type `F` and any two points `x` and `y` in `α`, the distance between the images of `x` and `y` under `f` equals the dilation ratio of `f` times the distance between `x` and `y`. In other words, `f` scales the distances in `α` by its dilation ratio.

Given functions `F` from type `α` to type `β` between pseudometric spaces `α` and `β`, if `F` is both a function-like and a dilation class, then for all `x` and `y` in `α`, `d(F(x) F(y)) = dilation_ratio(F) * d(x, y)`.


theorem AlgHom.map_sub :
    ∀ {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 y : A), φ (x - y) = φ x - φ y :=
  by sorry

This theorem, `AlgHom.map_sub`, asserts that for all types `R`, `A`, and `B` where `R` is a commutative semiring, `A` and `B` are rings, and `A` and `B` are both `R`-algebras, if you have an algebra homomorphism `φ` from `A` to `B` and any two elements `x` and `y` of `A`, then applying `φ` to the difference `x - y` is the same as the difference of `φ(x)` and `φ(y)`. In mathematical terms, it states that algebra homomorphisms preserve subtraction.

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


theorem CategoryTheory.leftAdjointMate_id :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C] {X : C}
      [inst_2 : CategoryTheory.HasLeftDual X],
      (ᘁCategoryTheory.CategoryStruct.id X) = CategoryTheory.CategoryStruct.id ᘁX :=
  by sorry

This theorem, `CategoryTheory.leftAdjointMate_id`, states that for any type `C` that has instances of a `CategoryTheory.Category` and a `CategoryTheory.MonoidalCategory`, and for any object `X` of type `C` that has a left dual, the antipode or antidual (denoted by `ᘁ`) of the identity morphism on `X` is equal to the identity morphism on the antidual of `X`. In the language of category theory, this is expressing a property of dual objects in a monoidal category, where the dual of a morphism is related to the morphism on the dual object.

In a monoidal category with objects having left duals, the antipode of the identity morphism on an object is equal to the identity morphism on the object's left dual.


theorem MeasureTheory.IsStoppingTime.measurableSet :
    ∀ {Ω : Type u_1} {ι : Type u_3} {m : MeasurableSpace Ω} [inst : Preorder ι] {f : MeasureTheory.Filtration ι m}
      {τ : Ω → ι} (hτ : MeasureTheory.IsStoppingTime f τ) (s : Set Ω),
      MeasurableSet s ↔ ∀ (i : ι), MeasurableSet (s ∩ {ω | τ ω ≤ i}) :=
  by sorry

This theorem states that for any given types `Ω` and `ι`, and any given measurable space `m` on `Ω`, that is, a structure that allows us to treat subsets of `Ω` as "measurable" or not, and for any preorder (a relation that is reflexive and transitive) on `ι`, and any filtration `f` of `m` (a family of sigma algebras indexed by `ι`), and any function `τ` from `Ω` to `ι`, if `τ` is a stopping time with respect to `f`, and `s` is a set of `Ω`, then `s` is a measurable set if and only if the intersection of `s` with the set of all `ω` such that `τ ω` is less than or equal to `i` is a measurable set for all `i` in `ι`. In other words, a set is measurable if and only if its intersection with all sets defined by the stopping time being less than or equal to a certain time is measurable.

A set is measurable with respect to a filtration and a stopping time if and only if the intersection of the set with each level set defined by the stopping time is measurable.


theorem add_le_of_nonpos_right :
    ∀ {α : Type u_1} [inst : AddZeroClass α] [inst_1 : LE α]
      [inst_2 : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] {a b : α}, b ≤ 0 → a + b ≤ a :=
  by sorry

This theorem states that for any type `α` that has addition and zero (`AddZeroClass`), a less than or equal to relation (`LE`), and obeys a certain covariance property (`CovariantClass` with respect to addition and the less than or equal to relation), if `b` is less than or equal to zero, then `a + b` is always less than or equal to `a`. In mathematical terms, it means for any `a` and `b` in `α`, if `b ≤ 0`, then `a + b ≤ a`. This aligns with the intuitive idea that adding a non-positive number to a given number doesn't increase the original number.

For any type `α` with `AddZeroClass`, `LE`, and the covariance property `CovariantClass` for addition and `LE`, if `b ≤ 0`, then `a ≤ a + b`. (Note: This is the negation of the original statement to make it consistent with the usual mathematical convention that `a ≤ b` implies `a + c ≤ b + c` for all `c`.)


theorem Fintype.rightInverse_bijInv :
    ∀ {α : Type u_1} {β : Type u_2} [inst : Fintype α] [inst_1 : DecidableEq β] {f : α → β}
      (f_bij : Function.Bijective f), Function.RightInverse (Fintype.bijInv f_bij) f :=
  by sorry

This theorem is stating that for any types `α` and `β` where `α` is finite and `β` has decidable equality, and for any bijective function `f` from `α` to `β`, the function `Fintype.bijInv f_bij` is a right inverse to `f`. In other words, if we apply `f` and then `Fintype.bijInv f_bij`, we get the identity function on `β`. This means that for each value `b` in `β`, applying `Fintype.bijInv f_bij` and then `f` to it gives us back the original `b`. This is a characteristic property of bijective functions and their inverses.

For any finite type `α` and decidably equal type `β`, if `f` is a bijective function from `α` to `β`, then `Fintype.bijInv f` is its right inverse.


theorem Matrix.fromBlocks_smul :
    ∀ {l : Type u_1} {m : Type u_2} {n : Type u_3} {o : Type u_4} {R : Type u_10} {α : Type u_12} [inst : SMul R α]
      (x : R) (A : Matrix n l α) (B : Matrix n m α) (C : Matrix o l α) (D : Matrix o m α),
      x • Matrix.fromBlocks A B C D = Matrix.fromBlocks (x • A) (x • B) (x • C) (x • D) :=
  by sorry

This theorem states that for any type `R` with a scalar multiplication operation over a type `α`, and any four matrices `A` of type `Matrix n l α`, `B` of type `Matrix n m α`, `C` of type `Matrix o l α` and `D` of type `Matrix o m α`, scalar multiplication distributes over the operation of forming a large matrix from block matrices. That is, if you multiply a scalar `x` to the large matrix obtained from `A`, `B`, `C`, and `D`, it is the same as multiplying `x` to each of these matrices separately and then forming the large matrix.

For any scalars `x` and matrices `A` of size `n x l`, `B` of size `n x m`, `C` of size `o x l`, and `D` of size `o x m` over a type `α` with scalar multiplication, `x * (A⊕B ⊗ C ⊕ D) = x * A ⊗ Iₙ ⊕ x * B ⊗ Iₗ ⊕ x * C ⊗ Iₙ' ⊕ x * D`, where `Iₙ`, `Iₗ`, and `Iₙ'` are identity matrices of sizes `n x n`, `m x m`, and `o x o`, respectively.


theorem Set.monotone_preimage : ∀ {α : Type u_1} {β : Type u_2} {f : α → β}, Monotone (Set.preimage f) := by sorry

The theorem `Set.monotone_preimage` states that for any types `α` and `β` and any function `f` from `α` to `β`, the preimage operation of the function `f` is monotone. In other words, if we have two sets `A` and `B` such that `A` is a subset of `B`, then the preimage of `A` under `f` is also a subset of the preimage of `B` under `f`. This follows from the definition of monotonicity and preimage.

For any functions between types, the preimage of a subset under the function is monotone, meaning the preimage of a smaller set is included in the preimage of a larger set.


theorem DFinsupp.mk_add :
    ∀ {ι : Type u} {β : ι → Type v} [inst : DecidableEq ι] [inst_1 : (i : ι) → AddZeroClass (β i)] {s : Finset ι}
      {x y : (i : ↑↑s) → β ↑i}, DFinsupp.mk s (x + y) = DFinsupp.mk s x + DFinsupp.mk s y :=
  by sorry

The theorem `DFinsupp.mk_add` asserts the distributivity of the `DFinsupp.mk` function over addition. More specifically, for any given type `ι`, a type family `β` indexed by `ι`, a finite set `s` of type `ι`, and two functions `x` and `y` from the elements of `s` to the corresponding `β` values, the direct sum of the direct finitely supported functions created by `x` and `y` is the same as the direct finitely supported function created by the sum of `x` and `y`. This is under the assumptions that `ι` has decidable equality and each `β i` forms an additive monoid with zero.

For any type `ι` with decidable equality and indexed type family `β`, and finite sets `s` with functions `x` and `y` from `s` to `β` such that each `β i` forms an additive monoid with zero, the finite sum of the direct finitely supported functions `DFinsupp.mk x` and `DFinsupp.mk y` equals `DFinsupp.mk (x + y)`.


IsIntegral.mul

theorem IsIntegral.mul :
    ∀ {R : Type u_1} {A : Type u_2} [inst : CommRing R] [inst_1 : CommRing A] [inst_2 : Algebra R A] {x y : A},
      IsIntegral R x → IsIntegral R y → IsIntegral R (x * y) :=
  by sorry

The theorem `IsIntegral.mul` states that for any commutative ring `R` and for any commutative ring `A` equipped with a ring homomorphism from `R` to `A` (i.e., `A` is an `R`-algebra), if elements `x` and `y` of `A` are both integral over `R`, then their product `x * y` is also integral over `R`. In mathematical terms, this means that if `x` and `y` are roots of some monic polynomial with coefficients from `R`, then their product is also a root of some monic polynomial with coefficients from `R`.

If `R` is a commutative ring and `A` is an `R`-algebra with `x` and `y` in `A` being integral over `R`, then their product `x * y` is also integral over `R`. Alternatively, if `x` and `y` are roots of monic polynomials with coefficients from `R`, then their product is a root of a monic polynomial with coefficients from `R`.


theorem Dilation.comap_cobounded :
    ∀ {α : Type u_1} {β : Type u_2} {F : Type u_4} [inst : PseudoMetricSpace α] [inst_1 : PseudoMetricSpace β]
      [inst_2 : FunLike F α β] [inst_3 : DilationClass F α β] (f : F),
      Filter.comap (⇑f) (Bornology.cobounded β) = Bornology.cobounded α :=
  by sorry

The theorem `Dilation.comap_cobounded` states that for any types `α`, `β`, and `F`, given that `α` and `β` are both pseudo metric spaces, `F` is a function-like from `α` to `β`, and `F` is a dilation class from `α` to `β`, then for any function `f` of type `F`, the comap (preimage) of the filter of cobounded sets of `β` under `f` is equal to the filter of cobounded sets of `α`. In other words, pulling back the set of cobounded subsets of `β` via the function `f` gives us the set of cobounded subsets of `α`. This theorem provides a connection between the bornologies (a structure defining "bounded" subsets) of two pseudo metric spaces through a function that satisfies certain properties.

Given functions between pseudo metric spaces that preserve cobounded sets and are dilations, the preimages of cobounded sets under these functions form the same filter as the cobounded sets in the domain.


theorem CharTwo.neg_eq : ∀ {R : Type u_1} [inst : Ring R] [inst_1 : CharP R 2] (x : R), -x = x := by sorry

This theorem states that for any ring `R` of characteristic 2, the negation of any element `x` in `R` is equal to `x` itself. In other words, if we have a ring in which adding any element to itself results in the additive identity (zero), then negating any element in this ring gives us the original element back.

In a ring of characteristic 2, the additive inverse of any element is equal to the element itself.


theorem mul_eq_one_iff' :
    ∀ {α : Type u_1} [inst : MulOneClass α] [inst_1 : PartialOrder α]
      [inst_2 : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1]
      [inst_3 : CovariantClass α α (Function.swap fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1] {a b : α},
      1 ≤ a → 1 ≤ b → (a * b = 1 ↔ a = 1 ∧ b = 1) :=
  by sorry

The theorem `mul_eq_one_iff'` states that for any type `α` under the conditions that it has a multiplication and one (`MulOneClass α`), it has a partial order (`PartialOrder α`), and this type `α` is covariant in both the multiplication operation (`fun x x_1 => x * x_1`) and its swapped version (`Function.swap fun x x_1 => x * x_1`) with respect to the partial order (`fun x x_1 => x ≤ x_1`), then for any two elements `a` and `b` of this type, if `a` and `b` are both greater than or equal to one (`1 ≤ a` and `1 ≤ b`), the product `a * b` is equal to one (`a * b = 1`) if and only if both `a` and `b` are equal to one (`a = 1` and `b = 1`). This theorem essentially asserts a property of multiplication relative to the multiplicative identity in a partially ordered monoid that is covariant under multiplication.

Given a type `α` with multiplication `*`, one (`1`), partial order `≤`, and covariance under multiplication, if `a, b ∈ α` satisfy `1 ≤ a` and `1 ≤ b`, then `a * b = 1` if and only if `a = b = 1`.


theorem Finset.sum_multiset_map_count :
    ∀ {α : Type u_3} [inst : DecidableEq α] (s : Multiset α) {M : Type u_6} [inst_1 : AddCommMonoid M] (f : α → M),
      Multiset.sum (Multiset.map f s) = Finset.sum (Multiset.toFinset s) fun m => Multiset.count m s • f m :=
  by sorry

The theorem `Finset.sum_multiset_map_count` states that for any multiset `s` of type `α` with a decidable equality structure, and any function `f` from `α` to a type `M` equipped with a commutative additive monoid structure, the sum of the multiset obtained by mapping `f` over `s` is equal to the sum, over the finset obtained by removing duplicates from `s`, of the product of the count of each element `m` in `s` and the value of `f` at `m`. In other words, it provides a relationship between the sum of the transformed multiset and the weighted sum of the finset, where weights are the multiplicities of the elements in the original multiset.

For any decidable multiset `s` of type `α` and commutative additive monoid-valued function `f` on `α`, the sum of `f` applied to the elements of `s` equals the sum of the counts of each element in `s` multiplied by the corresponding image under `f`.


theorem FiniteDimensional.of_finrank_pos :
    ∀ {K : Type u} {V : Type v} [inst : DivisionRing K] [inst_1 : AddCommGroup V] [inst_2 : Module K V],
      0 < FiniteDimensional.finrank K V → FiniteDimensional K V :=
  by sorry

This theorem states that for any type `K` which is a Division Ring, and any type `V` that forms an Additive Commutative Group and a Module over `K`, if the rank of the Module `V` over the Ring `K` is greater than zero (i.e., it is not a zero-dimensional space), then `V` is a Finite Dimensional Vector Space over `K`. It formalizes the intuition that any non-zero dimensional space must indeed have a finite number of dimensions, in the context of vector spaces over a field.

If `K` is a division ring and `V` is an additive commutative group of type `Type` that is a module over `K` with positive rank, then `V` is a finite-dimensional vector space over `K`.


theorem Primrec.of_equiv_symm : ∀ {α : Type u_1} [inst : Primcodable α] {β : Type u_4} {e : β ≃ α}, Primrec ⇑e.symm :=
  by sorry

The theorem `Primrec.of_equiv_symm` states that for any types `α` and `β`, given that `α` is Primcodable and there exists an equivalence `e` between `β` and `α`, the inverse function of `e` (denoted as `e.symm`) is primitive recursive. Here, a function is called primitive recursive if it can be represented in a certain restricted language that only includes basic arithmetic operations and recursions.

If `α` is Primcodable and there exists an equivalence `e` between `α` and `β`, then `e.symm` is a primitive recursive function.


theorem Nat.add_mul_mod_self_right : ∀ (x y z : ℕ), (x + y * z) % z = x % z := by sorry

This theorem states that for any three natural numbers `x`, `y`, and `z`, the remainder of the division of `x + y * z` by `z` is equal to the remainder of the division of `x` by `z`. In mathematical terms, it expresses the property `(x + yz) mod z = x mod z`.

For any natural numbers x, y, and z, the remainder of (x + yz) divided by z is equal to the remainder of x divided by z.


theorem Mathlib.Data.Set.Pairwise.Basic._auxLemma.16 :
    ∀ {α : Type u} {s : Set α} {p : ↑s → Prop},
      (∀ (x : ↑s), p x) = ∀ (x : α) (h : x ∈ s), p { val := x, property := h } :=
  by sorry

This theorem states that for any type `α`, any set `s` of type `α`, and any property `p` that the elements of `s` might have, the statement that "for all elements `x` in `s`, `p` holds" is equivalent to the statement "for all elements `x` of type `α`, if `x` is in `s`, then `p` holds". The property `p` is here applied to `x` seen as an element of `s` (`{ val := x, property := h }`), where `h` is a proof that `x` is in `s`.

For any type `α`, set `s` of `α`, and property `p`, the statements "for all `x` in `s`, `p(x)` holds" and "for all `x` of type `α`, if `x` is in `s` then `p(x)` holds" are logically equivalent.


theorem Mathlib.Data.Set.Pairwise.Basic._auxLemma.17 :
    ∀ {α : Sort u_1} {p : α → Prop} {a1 a2 : { x // p x }}, (a1 = a2) = (↑a1 = ↑a2) := by sorry

This theorem states that for any type `α`, any predicate `p` on `α`, and any two elements `a1` and `a2` of the subtype of `α` consisting of elements satisfying `p`, `a1` and `a2` are equal if and only if their underlying elements in `α` are equal. In other words, two elements of a subtype are equal if and only if their representatives in the original type are equal.

For any type `α`, predicate `p` on `α`, and elements `a1` and `a2` of the subtype of `α` satisfying `p`, `a1` equals `a2` if and only if their underlying elements in `α` are equal.


theorem WittVector.coeff_truncate :
    ∀ {p : ℕ} [hp : Fact (Nat.Prime p)] {n : ℕ} {R : Type u_1} [inst : CommRing R] (x : WittVector p R) (i : Fin n),
      TruncatedWittVector.coeff i ((WittVector.truncate n) x) = x.coeff ↑i :=
  by sorry

The theorem `WittVector.coeff_truncate` states that for any natural number `p` which is a prime, any natural number `n`, any type `R` that is a commutative ring, any `x` which is a Witt vector over `R` with base `p`, and any `i` which is a finite ordinal less than `n`, the `i`th coefficient of the truncated Witt vector obtained by truncating `x` to its first `n` entries is equal to the `i`th coefficient of `x`. This essentially says that the truncation operation properly preserves the coefficients of the Witt vector up to the truncation index `n`.

For any prime number p, natural number n, commutative ring R, Witt vector x over R with base p, and finite ordinal i < n, the i-th coefficient of the truncated Witt vector of x to length n equals the i-th coefficient of x.


theorem Subgroup.map_equiv_eq_comap_symm :
    ∀ {G : Type u_1} [inst : Group G] {N : Type u_5} [inst_1 : Group N] (f : G ≃* N) (K : Subgroup G),
      Subgroup.map (↑f) K = Subgroup.comap (↑(MulEquiv.symm f)) K :=
  by sorry

This theorem states that for any given groups `G` and `N`, an isomorphism `f` from `G` to `N`, and a subgroup `K` of `G`, the image of `K` under `f` (denoted by `Subgroup.map (↑f) K`) is the same as the preimage of `K` under the inverse of `f` (denoted by `Subgroup.comap (↑(MulEquiv.symm f)) K`). In other words, mapping a subgroup through an isomorphism and taking the preimage of the same subgroup through the inverse of that isomorphism result in the same subgroup.

For any groups G, N, an isomorphism f between them, and a subgroup K of G, the image of K under f and the preimage of K under the inverse of f are equal. (Subgroup.map (↑f) K = Subgroup.comap (↑(MulEquiv.symm f)) K)


theorem add_lowerClosure :
    ∀ {α : Type u_1} [inst : OrderedAddCommGroup α] (s t : Set α), s + ↑(lowerClosure t) = ↑(lowerClosure (s + t)) := by
  sorry

This theorem, `add_lowerClosure`, states that for any type `α` that forms an ordered additive commutative group, given any two sets `s` and `t` of this type, the sum of the set `s` and the lower closure of `t` is equal to the lower closure of the sum of `s` and `t`. In mathematical terms, this theorem demonstrates the distributive property of the lower closure over the operation of addition of sets in such a group.

For any ordered additive commutative group type `α`, the lower closure of `s + t` equals the lower closure of `s` + lower closure of `t`.


SetLike.forall

theorem SetLike.forall :
    ∀ {A : Type u_1} {B : Type u_2} [i : SetLike A B] {p : A} {q : ↥p → Prop},
      (∀ (x : ↥p), q x) ↔ ∀ (x : B) (h : x ∈ p), q { val := x, property := h } :=
  by sorry

This theorem expresses a property of set-like structures. For any types `A` and `B`, and a set-like relationship `i` between `A` and `B`, the theorem says that for a particular `p` of type `A` and a property `q` that applies to elements of `p`, the statement "for all elements `x` of `p`, `q` holds for `x`" is equivalent to "for all `x` of type `B` such that `x` is in `p`, `q` holds for `x`, given the context that `x` is in `p`." This provides a way to express a universal quantification over elements of a subset in terms of a universal quantification over elements of the containing set.

For any set-like relationship between types `A` and `B` and property `q`, the statement "for all `x` in `A`, `q(x)` holds if and only if for all `y` in `B` such that `y` is in `A`, `q(y)` holds.


theorem Finset.mem_attach : ∀ {α : Type u_1} (s : Finset α) (x : { x // x ∈ s }), x ∈ Finset.attach s := by sorry

The theorem `Finset.mem_attach` states that for any type `α` and for any finite set `s` of type `α`, every element `x` of the subtype `{ x // x ∈ s }` (which consists of elements of `s` along with a proof that they belong to `s`) is also an element of the set obtained by attaching `s` using the `Finset.attach` function. In other words, every element that is proven to belong to a certain finite set remains in that set when we form a new set via `Finset.attach`.

For any finite set `s` and all `x` in `s`, `x` is an element of the set obtained by attaching `s` using `Finset.attach`.


theorem hasSum_nat_add_iff :
    ∀ {G : Type u_2} [inst : AddCommGroup G] {g : G} [inst_1 : TopologicalSpace G] [inst_2 : TopologicalAddGroup G]
      {f : ℕ → G} (k : ℕ), HasSum (fun n => f (n + k)) g ↔ HasSum f (g + Finset.sum (Finset.range k) fun i => f i) :=
  by sorry

The theorem `hasSum_nat_add_iff` states that for any type `G` which is an additive commutative group and a topological additive group, any function `f` from natural numbers to `G`, and any natural number `k`, the sum of the sequence `f(n + k)` has a limit `g` if and only if the function `f` has a limit equal to `g` plus the sum of the function `f` applied to the range from `0` to `k - 1`. In mathematical terms, this theorem asserts that $\sum_{n=0}^\infty f(n + k) = g$ if and only if $\sum_{n=0}^\infty f(n) = g + \sum_{i=0}^{k-1} f(i)$. This effectively means shifting the start of the sequence by `k` entries does not change the sum, but it does change the value to which the series converges.

For any additive commutative and topological group G, function f from natural numbers to G, and natural number k, if the sequence (f(n + k)) has a limit g, then f has a limit g + ∑(i=0 to k-1) f(i).


theorem Mathlib.GroupTheory.Perm.Cycle.Basic._auxLemma.3 :
    ∀ {α : Type u} {f : Equiv.Perm α} {x y : α}, (x = f⁻¹ y) = (f x = y) := by sorry

This theorem, under the context of group theory and permutation cycles, states that for any type `α`, a permutation `f` of type `α`, and any two elements `x` and `y` of type `α`, the condition that `x` equals the inverse of `f` applied to `y` is equivalent to the condition that `f` applied to `x` equals `y`. This theorem is fundamental to the manipulation and understanding of permutations and their inverses. In mathematical terms, the theorem says that $x = f^{-1}(y)$ if and only if $f(x) = y$, for a bijective function $f$.

For any bijective function `f` and elements `x, y` of type `α`, `x = f⁻¹(y)` if and only if `f(x) = y`.


theorem Asymptotics.isBigOWith_congr :
    ∀ {α : Type u_1} {E : Type u_3} {F : Type u_4} [inst : Norm E] [inst_1 : Norm F] {c₁ c₂ : ℝ} {l : Filter α}
      {f₁ f₂ : α → E} {g₁ g₂ : α → F},
      c₁ = c₂ → f₁ =ᶠ[l] f₂ → g₁ =ᶠ[l] g₂ → (Asymptotics.IsBigOWith c₁ l f₁ g₁ ↔ Asymptotics.IsBigOWith c₂ l f₂ g₂) :=
  by sorry

The theorem `Asymptotics.isBigOWith_congr` states that for any two types `α`, `E`, and `F` with norms, given two real numbers `c₁` and `c₂`, a filter `l` on `α`, and four functions `f₁`, `f₂` from `α` to `E` and `g₁`, `g₂` from `α` to `F`, if `c₁` equals `c₂`, `f₁` equals `f₂` almost surely with respect to the filter `l`, and `g₁` equals `g₂` almost surely with respect to the filter `l`, then `f₁` is "big O" to `g₁` with constant `c₁` if and only if `f₂` is "big O" to `g₂` with constant `c₂`. Here, being "big O" means that the norm of `f` is eventually (for `l`) bounded by `c` times the norm of `g`.

If functions `f₁` and `f₂` are almost surely equal and `g₁` is almost surely equal to `g₂`, then `f₁` is big O of `g₁` with constant `c₁` if and only if `f₂` is big O of `g₂` with constant `c₂`.


UpperSemicontinuousWithinAt.add'

/-- The sum of two upper semicontinuous functions is upper semicontinuous. Formulated with an
explicit continuity assumption on addition, for application to `EReal`. The unprimed version of
the lemma uses `[ContinuousAdd]`.  -/
theorem UpperSemicontinuousWithinAt.add' :
    ∀ {α : Type u_1} [inst : TopologicalSpace α] {x : α} {s : Set α} {γ : Type u_4}
      [inst_1 : LinearOrderedAddCommMonoid γ] [inst_2 : TopologicalSpace γ] [inst_3 : OrderTopology γ] {f g : α → γ},
      UpperSemicontinuousWithinAt f s x →
        UpperSemicontinuousWithinAt g s x →
          ContinuousAt (fun p => p.1 + p.2) (f x, g x) → UpperSemicontinuousWithinAt (fun z => f z + g z) s x :=
  by sorry

The theorem states that, given two functions `f` and `g` in a topological space `α` that are upper semicontinuous at a point `x` within a set `s`, and given that the addition of the function values `(f x, g x)` is continuous at the point `x`, then the function obtained by adding `f` and `g` pointwise, i.e., the function `z -> f z + g z`, is also upper semicontinuous at the point `x` within the set `s`. Here, `γ` is a linearly ordered additive commutative monoid equipped with a topological space structure and an order topology. The upper semicontinuity is a property indicating that for any value `y` greater than the function value at `x`, there exists a neighborhood around `x` within the set `s` where all function values are less than `y`. The requirement of continuity of addition is explicitly stated, making the theorem applicable to extended real numbers (`EReal`).

Given two upper semicontinuous functions `f` and `g` on a topological space `α` at a point `x` within a set `s`, with the addition of their values being continuous at `x`, the pointwise sum `z => f z + g z` is also upper semicontinuous at `x` within `s` in an additive commutative monoid `γ` with order topology.


theorem uniformContinuous_uniformly_extend :
    ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : UniformSpace α] [inst_1 : UniformSpace β]
      [inst_2 : UniformSpace γ] {e : β → α} (h_e : UniformInducing e) (h_dense : DenseRange e) {f : β → γ},
      UniformContinuous f → ∀ [inst_3 : CompleteSpace γ], UniformContinuous (DenseInducing.extend ⋯ f) :=
  by sorry

The theorem `uniformContinuous_uniformly_extend` states that for any three types `α`, `β`, and `γ` each equipped with a uniform space structure, and a function `e` mapping from `β` to `α` which induces a uniform structure, if the range of `e` is dense in `α`, then for any uniformly continuous function `f` from `β` to `γ`, provided `γ` is a complete space, the function `f` can be uniformly extended. This extended function is also uniformly continuous.

In other words, the theorem states that a uniformly continuous function defined on a dense subset of a space can be extended to a uniformly continuous function on the whole space, under the assumption that the codomain is a complete space.

Given uniform spaces `α`, `β`, and `γ`, a dense subset `β` of `α`, a uniformly continuous function `f : β → γ` with complete codomain `γ`, there exists a uniformly continuous extension `g : α → γ` of `f`.


/-- The `n`th coefficient of a formal power series is `0` if `n` is strictly
smaller than the order of the power series. -/
theorem PowerSeries.coeff_of_lt_order :
    ∀ {R : Type u_1} [inst : Semiring R] {φ : PowerSeries R} (n : ℕ),
      ↑n < PowerSeries.order φ → (PowerSeries.coeff R n) φ = 0 :=
  by sorry

The theorem `PowerSeries.coeff_of_lt_order` states that for any coefficient type `R` with a semiring structure, any formal power series `φ` over `R`, and any natural number `n`, if `n` is strictly smaller than the order of the power series `φ`, then the `n`th coefficient of the power series `φ` is `0`. In other words, in a formal power series, any term whose degree is less than the order of the series has a zero coefficient.

For any semiring `R`, formal power series `φ` over `R` of order `k`, and natural number `n` with `n < k`, the `n`th coefficient of `φ` is `0`.


theorem Finset.isGreatest_max' :
    ∀ {α : Type u_2} [inst : LinearOrder α] (s : Finset α) (H : s.Nonempty), IsGreatest (↑s) (Finset.max' s H) := by
  sorry

The theorem `Finset.isGreatest_max'` states that for any nonempty finite set `s` in a linear order `α`, the maximum element of `s`, denoted by `Finset.max' s H`, is the greatest element of `s`. Here, `H` is a proof of non-emptiness of the set `s`. The function `IsGreatest` ensures that this maximum element is actually part of the set `s` and that no element in `s` is greater than it. Therefore, this theorem verifies the correctness of the `Finset.max'` function in the context of linearly ordered finite sets.

For any nonempty finite subset `s` of a linearly ordered set `α`, the maximum element ` Finset.max' s H` is the greatest element of `s`.


theorem ball_or_left :
    ∀ {α : Sort u_1} {r p q : α → Prop}, (∀ (x : α), p x ∨ q x → r x) ↔ (∀ (x : α), p x → r x) ∧ ∀ (x : α), q x → r x :=
  by sorry

This theorem states that for any type `α` and predicates `p`, `q`, and `r` over `α`, the proposition that for all `x` of type `α`, `r x` is true whenever either `p x` or `q x` is true, is equivalent to the conjunction of the two propositions: for all `x` of type `α`, `r x` is true whenever `p x` is true, and for all `x` of type `α`, `r x` is true whenever `q x` is true. So in mathematical terms, this theorem proves that `(∀x, p(x) ∨ q(x) ⇒ r(x)) ↔ (∀x, p(x) ⇒ r(x)) ∧ (∀x, q(x) ⇒ r(x))`.

The theorem asserts that for any type `α` and predicates `p`, `q`, and `r` over `α`, the implication `(p(x) ∨ q(x) → r(x))` is logically equivalent to the conjunction `(∀x, p(x) → r(x)) ∧ (∀x, q(x) → r(x))`.


theorem CategoryTheory.shiftFunctorZero_hom_app_shift :
    ∀ {C : Type u} {A : Type u_1} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : AddCommMonoid A]
      [inst_2 : CategoryTheory.HasShift C A] {X : C} (n : A),
      (CategoryTheory.shiftFunctorZero C A).hom.app ((CategoryTheory.shiftFunctor C n).obj X) =
        CategoryTheory.CategoryStruct.comp ((CategoryTheory.shiftFunctorComm C n 0).hom.app X)
          ((CategoryTheory.shiftFunctor C n).map ((CategoryTheory.shiftFunctorZero C A).hom.app X)) :=
  by sorry

This theorem states that for any type `C` and `A` where `C` forms a category, `A` forms an additive commutative monoid, and `C` has a shift operation with `A`, and any object `X` in `C` and element `n` in `A`, the application of the natural transformation induced by the homeomorphism `(CategoryTheory.shiftFunctorZero C A).hom` to the object `X` shifted by `n`, is equivalent to the composition of the application of the homeomorphism `(CategoryTheory.shiftFunctorComm C n 0).hom` to `X` and the morphism map of `X` shifted by `n` under the functor `(CategoryTheory.shiftFunctor C n)`. This describes a property of the zero-shift functor and shift functor in the context of Category Theory, showing how they interact with the composition operation in the category.

For any category `C` with a shift operation and additive commutative monoid `A`, and for any object `X` in `C` and element `n` in `A`, the application of the zero-shift functor's natural transformation to `X` shifted by `n` is equivalent to composing the shift of `X` by `n` under the shift functor with the morphism of `X` shifted by `n` under the same functor.


/-- The range of a surjective `AddMonoid` hom is the whole of the codomain. -/
theorem AddMonoidHom.mrange_top_of_surjective :
    ∀ {M : Type u_1} {N : Type u_2} [inst : AddZeroClass M] [inst_1 : AddZeroClass N] {F : Type u_5}
      [inst_2 : FunLike F M N] [mc : AddMonoidHomClass F M N] (f : F),
      Function.Surjective ⇑f → AddMonoidHom.mrange f = ⊤ :=
  by sorry

The theorem `AddMonoidHom.mrange_top_of_surjective` states that for any given types `M` and `N` that have `AddZeroClass` instances, and for any type `F` that is function-like from `M` to `N` and has an `AddMonoidHomClass` instance, if a function `f` of type `F` is surjective, meaning that every element of `N` is the image of some element of `M` under `f`, then the range of the `AddMonoid` homomorphism `f` is the entire codomain, `N`. In other words, every element of `N` is the result of the additive monoid homomorphism `f` applied to some element of `M`.

If `F` is a surjective additive monoid homomorphism from the additive monoid of type `M` to the additive monoid of type `N`, then the range of `F` is the entire codomain `N`.


List.Pairwise.chain

theorem List.Pairwise.chain :
    ∀ {α : Type u_1} {R : α → α → Prop} {a : α} {l : List α}, List.Pairwise R (a :: l) → List.Chain R a l := by sorry

This theorem states that for any type `α`, any binary relation `R` on `α`, any element `a` of `α`, and any list `l` of `α`, if the list that results from prepending `a` to `l` satisfies the property of being pairwise related by `R`, then `a` and every element of `l` are related by the chain relation `R`. This theorem is a part of the List module in Lean 4, which includes a variety of useful theorems and definitions related to lists.

If a list prefixed by an element `a` is pairwise related by a binary relation `R`, then `a` is related to every element in the list via the chain relation `R`.