MeasureTheory.Measure.InnerRegular.map

theorem MeasureTheory.Measure.InnerRegular.map :
    ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] [inst_1 : TopologicalSpace α]
      {μ : MeasureTheory.Measure α} [inst_2 : BorelSpace α] [inst_3 : MeasurableSpace β] [inst_4 : TopologicalSpace β]
      [inst_5 : BorelSpace β] [inst_6 : MeasureTheory.Measure.InnerRegular μ] (f : α ≃ₜ β),
      MeasureTheory.Measure.InnerRegular (MeasureTheory.Measure.map (⇑f) μ) :=
  by sorry

This theorem states that, for any two types `α` and `β` with `α` being a measurable space and topological space, and `β` being a measurable space, topological space and Borel space, given a measure `μ` on `α` that is inner regular, and a homeomorphism `f` from `α` to `β`, the measure obtained by pushing forward `μ` with `f`, denoted as `MeasureTheory.Measure.map (⇑f) μ`, is also inner regular.

In simpler terms, it says that under certain conditions, the property of a measure being inner regular is preserved under a transformation (in this case, the homeomorphism `f`). Inner regularity of a measure is a property that links the measure theory with the topology of the space by saying that the measure of a set can be approximated from inside by compact subsets.

Given a measurable space and topological space `α`, a Borel space `β`, an inner regular measure `μ` on `α`, and a homeomorphism `f` from `α` to `β`, the pushed-forward measure `MeasureTheory.Measure.map (⇑f) μ` is also inner regular.


theorem MeasureTheory.Measure.measurable_join :
    ∀ {α : Type u_1} [inst : MeasurableSpace α], Measurable MeasureTheory.Measure.join := by sorry

This theorem states that for any type `α` that has a `MeasurableSpace` instance, the monadic join operation on `Measure` in the category of measurable spaces and measurable functions, `MeasureTheory.Measure.join`, is a measurable function. In mathematical terms, the preimage of every measurable set under `MeasureTheory.Measure.join` is also a measurable set.

For any measurable spaces `(X, Σ\_X)` and `(Y, Σ\_Y)` and measurable functions `f : X → Y` and `g : X' → X`, the compositions `g ^-1 ∘ MeasureTheory.Measure.join (f, g) ∘ Measure.universe` and `MeasureTheory.Measure.join (f, g) ∘ Measure.universe ∘ g ^-1` are measurable functions between measurable sets. (Here, `Measure.universe` is the lift of a set to a measurable set in the given measurable space.)


theorem Nat.Prime.factorization_pos_of_dvd : ∀ {n p : ℕ}, Nat.Prime p → n ≠ 0 → p ∣ n → 0 < (Nat.factorization n) p :=
  by sorry

The theorem `Nat.Prime.factorization_pos_of_dvd` states that for every two natural numbers `n` and `p`, if `p` is a prime number, `n` is not zero, and `p` divides `n` (i.e., `p` is a factor of `n`), then the multiplicity of `p` in the prime factorization of `n` is greater than zero. Here, the function `Nat.factorization n` maps each prime factor of `n` to its multiplicity in `n`.

If a prime number `p` divides a natural number `n` (`p` is a factor of `n`), then the multiplicity of `p` in the prime factorization of `n` is positive.


theorem CategoryTheory.Limits.BinaryCofan.isColimit_iff_isIso_inr :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C},
      CategoryTheory.Limits.IsInitial X →
        ∀ (c : CategoryTheory.Limits.BinaryCofan X Y),
          Nonempty (CategoryTheory.Limits.IsColimit c) ↔
            CategoryTheory.IsIso (CategoryTheory.Limits.BinaryCofan.inr c) :=
  by sorry

The theorem `CategoryTheory.Limits.BinaryCofan.isColimit_iff_isIso_inr` states that for any category `C` and any objects `X` and `Y` in `C`, if `X` is initial in the category `C`, then a binary cofan `c` on the objects `X` and `Y` is a colimit if and only if the second inclusion map (denoted by `CategoryTheory.Limits.BinaryCofan.inr c`) is an isomorphism in the category `C`. In other words, the existence of a colimit for the cofan is equivalent to the second inclusion map being an isomorphism, given that `X` is an initial object in the category.

For any category C and objects X, Y in C, if X is initial and the second inclusion map in a binary cofan on X and Y is an isomorphism, then the cofan is a colimit.


theorem SetTheory.PGame.toRightMovesNim.proof_1 :
    ∀ {o : Ordinal.{u_1}}, (Quotient.out o).α = SetTheory.PGame.RightMoves (SetTheory.PGame.nim o) := by sorry

The theorem `SetTheory.PGame.toRightMovesNim.proof_1` states that for every ordinal `o`, the cardinality of the set of elements in `o` (denoted as `(Quotient.out o).α`) is equal to the set of right moves in the Game Theory scenario where the game is "nim" with `o` piles of stones. In the game of "nim", players take turns to remove any positive number of stones from any single pile, and the player who makes the last move (i.e., removes the last stone) wins.

For every ordinal `o`, the cardinality of `Quotient.out o` equals the number of valid moves in the "nim" game with `o` piles.


theorem Order.Iio_succ_eq_insert_of_not_isMax :
    ∀ {α : Type u_1} [inst : PartialOrder α] [inst_1 : SuccOrder α] {a : α},
      ¬IsMax a → Set.Iio (Order.succ a) = insert a (Set.Iio a) :=
  by sorry

This theorem states that for any partially ordered type `α` which also has a defined successor operation, given any element `a` of `α` that is not a maximal element, the left-infinite right-open interval up to the successor of `a` is equal to the set obtained by inserting `a` into the left-infinite right-open interval up to `a`. In more informal terms, if `a` is not the largest possible element, then all elements less than the next element after `a` are the same as all elements less than `a`, plus `a` itself.

For any partially ordered type `α` with a successor operation, if `a` is an element of `α` that is not maximal, then the set of elements strictly less than the successor of `a` is equal to the set of elements strictly less than `a` union `{a}`.


theorem Stream'.Seq.coinduction2 :
    ∀ {α : Type u} {β : Type v} (s : Stream'.Seq α) (f g : Stream'.Seq α → Stream'.Seq β),
      (∀ (s : Stream'.Seq α),
          Stream'.Seq.BisimO (fun s1 s2 => ∃ s, s1 = f s ∧ s2 = g s) (Stream'.Seq.destruct (f s))
            (Stream'.Seq.destruct (g s))) →
        f s = g s :=
  by sorry

The theorem `Stream'.Seq.coinduction2` states that for any sequence `s` of type `α` and any two functions `f` and `g` from sequences of `α` to sequences of `β`, if for all sequences `s` of `α`, the `Stream'.Seq.BisimO` relation holds between the destruction of `f s` and `g s` (where this relation is defined as the existence of a sequence such that `s1 = f s` and `s2 = g s`), then `f s = g s`. In simpler terms, if two sequence transformations `f` and `g` have the same effect on the structure of all sequences, as captured by the bisimulation relation, then `f s` equals `g s` for any sequence `s`.

If for all sequences `s`, the `Stream.Seq.BisimO` relation holds between `fs` and `gs`, then `fs = gs`.


/-- The product over `univ` of a sum can be written as a sum over the product of sets,
`Fintype.piFinset`. `Finset.prod_sum` is an alternative statement when the product is not
over `univ`.  -/
theorem Finset.prod_univ_sum :
    ∀ {ι : Type u_1} {α : Type u_2} {κ : ι → Type u_3} [inst : CommSemiring α] [inst_1 : DecidableEq ι]
      [inst_2 : Fintype ι] (t : (i : ι) → Finset (κ i)) (f : (i : ι) → κ i → α),
      (Finset.prod Finset.univ fun i => Finset.sum (t i) fun j => f i j) =
        Finset.sum (Fintype.piFinset t) fun x => Finset.prod Finset.univ fun i => f i (x i) :=
  by sorry

This theorem, `Finset.prod_univ_sum`, states that for every type `ι` (represented as a set), a type `α` (which forms a commutative semiring), and a function `κ` that maps each element of `ι` to a type, given the conditions that equality in `ι` is decidable and `ι` is finite, we can define a function `t` mapping each element of `ι` to a finite set of the corresponding type `κ i`, and another function `f` that maps each element `ι` and its corresponding `κ i` to an element of `α`. The theorem then asserts that the product (using the commutative semiring operation) over all elements of `ι` of the sums (using the addition of the commutative semiring) computed by `f` over each finite set `t i` is equal to the sum over all functions `x` from `ι` to the union of the sets `t i`, of the product over all elements of `ι` of `f i` evaluated at `x i`. This theorem essentially reflects the principle of distributing a product over a sum, but in the context of finite sets and functions as described.

For every commutative semiring `α`, set `ι` (with decidable equality and finite elements), functions `κ : ι → Type`, `t : ι → Set α`, and `f : ι × κ → α`, the product of the sums of `f` over `t i` equals the sum of the products of `f` over all functions from `ι` to the union of the `t i`.


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

The theorem `List.map_const` states that for any list `l` of type `α` and any element `b` of type `β`, if you map a function that is a constant `b` over the list `l`, you get an equally long list filled solely with the element `b`. In other words, applying the constant function `b` to each element of `l` produces a list that is equivalent to replicating `b` for the length of `l`.

For any list `l` and constant `b`, the application of the function `map (λ x => b) l` equals the list `repeat b (length l)`.


theorem Mathlib.CategoryTheory.Sites.Surjective._auxLemma.3 : ∀ {a : Prop}, (a ↔ True) = a := by sorry

This theorem, `Mathlib.CategoryTheory.Sites.Surjective._auxLemma.3`, states that for any proposition `a`, the statement that `a` is equivalent to `True` is itself equivalent to `a`. This essentially means that if `a` is true, then it must be equivalent to `True`, and if `a` is equivalent to `True`, then `a` must be true. This theorem is a basic property of logical equivalence in propositional logic.

The proposition `a` is logically equivalent to `True` if and only if `a` is true.


theorem CategoryTheory.IsIso.inv_eq_of_inv_hom_id :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} {f : X ⟶ Y} [inst_1 : CategoryTheory.IsIso f]
      {g : Y ⟶ X},
      CategoryTheory.CategoryStruct.comp g f = CategoryTheory.CategoryStruct.id Y → CategoryTheory.inv f = g :=
  by sorry

The theorem `CategoryTheory.IsIso.inv_eq_of_inv_hom_id` states that for any category `C`, any two objects `X` and `Y` within this category, and a morphism `f` from `X` to `Y` that is an isomorphism, if there exists another morphism `g` from `Y` to `X` such that the composition of `g` and `f` is the identity on `Y` (denoted as `CategoryTheory.CategoryStruct.comp g f = CategoryTheory.CategoryStruct.id Y`), then `g` is the inverse of `f` (denoted as `CategoryTheory.inv f = g`). In other words, if `g` composed with `f` results in the identity morphism, then `g` is the inverse of `f` according to the category theory.

If in a category, the composition of the inverse morphism and a given isomorphism equals the identity on the domain of the isomorphism, then the inverse morphism is indeed the opposite isomorphism.


theorem LinearIsometryEquiv.toLinearEquiv_injective :
    ∀ {R : Type u_1} {R₂ : Type u_2} {E : Type u_5} {E₂ : Type u_6} [inst : Semiring R] [inst_1 : Semiring R₂]
      {σ₁₂ : R →+* R₂} {σ₂₁ : R₂ →+* R} [inst_2 : RingHomInvPair σ₁₂ σ₂₁] [inst_3 : RingHomInvPair σ₂₁ σ₁₂]
      [inst_4 : SeminormedAddCommGroup E] [inst_5 : SeminormedAddCommGroup E₂] [inst_6 : Module R E]
      [inst_7 : Module R₂ E₂], Function.Injective LinearIsometryEquiv.toLinearEquiv :=
  by sorry

The theorem `LinearIsometryEquiv.toLinearEquiv_injective` states that for any two types `R` and `R₂` with semiring structures, two types `E` and `E₂` with seminormed add commutative group structures and modules over `R` and `R₂` respectively, and given a pair of inverse ring homomorphisms `σ₁₂` from `R` to `R₂` and `σ₂₁` from `R₂` to `R`, the function that converts a linear isometry equivalence to a linear equivalence (`LinearIsometryEquiv.toLinearEquiv`) is injective. In other words, if two linear isometry equivalences convert to the same linear equivalence, they were the same linear isometry equivalence to begin with.

Given two linear isometry equivalences between seminormed add commutative groups with modules over commutative semirings, if their conversions to linear equivalences are equal, then the original isometries are equal.


theorem eq_of_mem_maximals :
    ∀ {α : Type u_1} {r : α → α → Prop} {s : Set α} {a b : α} [inst : IsAntisymm α r],
      a ∈ maximals r s → b ∈ s → r a b → a = b :=
  by sorry

This theorem states that for any type `α`, any binary relation `r` on `α`, any set `s` of type `α`, and any two elements `a` and `b` of type `α`, if the binary relation `r` is antisymmetric and `a` is a maximal element of `s` under the relation `r`, then if `b` is in `s` and `a` is related to `b` by `r`, it must be that `a` equals `b`. In other words, if `a` is a maximal element of `s` and `r` relates `a` to `b` where `b` is in `s`, there can't be any element `b` that is strictly greater than `a` under `r`, confirming the antisymmetry of `r`.

If a binary relation is antisymmetric and an element is a maximal element under the relation in a set, then it is equal to any other element related to it by the relation in the set.


theorem nndist_pi_le_iff :
    ∀ {β : Type v} {π : β → Type u_3} [inst : Fintype β] [inst_1 : (b : β) → PseudoMetricSpace (π b)]
      {f g : (b : β) → π b} {r : NNReal}, nndist f g ≤ r ↔ ∀ (b : β), nndist (f b) (g b) ≤ r :=
  by sorry

The theorem `nndist_pi_le_iff` states that for any given type `β`, a function `π` from `β` to another type, a `Fintype β` instance (which implies β is a finite type), a `PseudoMetricSpace` instance for each `b : β`, and two functions `f` and `g` from `β` to `π b`, the nonnegative real number distance `nndist` between `f` and `g` is less than or equal to a nonnegative real number `r` if and only if the nonnegative real number distance `nndist` between `f b` and `g b` is less than or equal to `r` for every `b` in `β`. This theorem provides an equivalence relation for the inequality of distances in the context of pseudometric spaces.

For any finite type β, function π from β to another type, PseudoMetricSpace instances for each element b in β, and functions f and g from β to π b, the distance nndist(f, g) ≤ r if and only if nndist(fb, gb) ≤ r for all b in β.


theorem small_max : ∀ (α : Type v), Small.{max w v, v} α := by sorry

This theorem, `small_max`, states that for any given type `α` in Lean 4, that type is "small". In the context of Lean 4's type theory, this means that `α` can be embedded in a type universe of size `max w v`. This has implications on the computational complexity and memory usage of operations involving values of type `α`. In other words, the type `α` is small with respect to the type universe `max w v`.

For any type `α` in Lean 4's type theory, it can be embedded in a type universe of size `max w v`, where `w` and `v` are given type universes.


theorem PFun.dom_of_mem_fix :
    ∀ {α : Type u_1} {β : Type u_2} {f : α →. β ⊕ α} {a : α} {b : β}, b ∈ PFun.fix f a → (f a).Dom := by sorry

This theorem states that for all types `α` and `β`, and for all function `f` that takes a value of type `α` and returns a value of type `β` or `α`, and given any elements `a` of type `α` and `b` of type `β`, if `b` is in the fixed point of `f` with respect to `a`, then `a` is in the domain of `f`. This is a property related to the concept of fixed points in function theory, where a fixed point of a function is an element that is mapped to itself by the function. Here, it is stated in the context of partial functions, which are functions that may not have a defined output for every input.

If a partial function `f` has `a` as its fixed point with respect to an argument `b`, then `a` lies in the domain of `f`.


theorem Ordinal.sub_zero : ∀ (a : Ordinal.{u_4}), a - 0 = a := by sorry

The theorem `Ordinal.sub_zero` states that for any ordinal 'a', subtracting zero from 'a' is equal to 'a' itself. In other words, this theorem is saying that if you take any well-ordered type 'a' and subtract 0 from it, you will always get 'a' back. This is a reflection of the general arithmetic property that anything minus zero equals itself, but applied specifically to the type of well-ordered types, or "ordinals", in Lean 4.


theorem Asymptotics.isBigO_snd_prod :
    ∀ {α : Type u_1} {E' : Type u_6} {F' : Type u_7} [inst : SeminormedAddCommGroup E']
      [inst_1 : SeminormedAddCommGroup F'] {f' : α → E'} {g' : α → F'} {l : Filter α}, g' =O[l] fun x => (f' x, g' x) :=
  by sorry

The theorem `Asymptotics.isBigO_snd_prod` states that for any types `α`, `E'`, and `F'`, with `E'` and `F'` being seminormed add commutative groups, and any functions `f' : α → E'` and `g' : α → F'`, as well as a filter `l` on `α`, the function `g'` is Big O of the function that maps `x` to the tuple `(f' x, g' x)` at the filter `l`. In mathematical terms, this means that `g'` grows at most as fast as the tuple function `(f' x, g' x)` near the points determined by the filter `l`.

For any types `α`, `E'`, and `F'` (with `E'` and `F'` seminormed add commutative groups), and functions `f': α -> E'` and `g': α -> F'`, if `l` is a filter on `α`, then `g'` is Big O of the function `x => (f' x, g' x)` at the filter `l`.


theorem differentiable_snd :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F],
      Differentiable 𝕜 Prod.snd :=
  by sorry

The theorem `differentiable_snd` states that for any nontrivially normed field `𝕜` and any normed additive commutative groups `E` and `F` that are also normed spaces over `𝕜`, the function `Prod.snd` is differentiable at any point. In other words, the second projection function, which takes a pair and returns its second component, is differentiable everywhere when considered as a function between these normed spaces.

The second projection function on the product of two normed spaces over a nontrivially normed field is differentiable.


theorem Finite.exists_le :
    ∀ {α : Type u_1} {β : Type u_2} [inst : Finite β] [inst : Nonempty α] [inst : Preorder α]
      [inst_1 : IsDirected α fun x x_1 => x ≤ x_1] (f : β → α), ∃ M, ∀ (i : β), f i ≤ M :=
  by sorry

This theorem states that for all types `α` and `β`, given that `β` is finite, `α` is nonempty, and `α` has a preorder structure, and there exists a function `f` from `β` to `α` such that `α` is directed with respect to the preorder (meaning, for any two elements in `α`, there exists a third element that is greater than or equal to both), then there exists an element `M` in `α` such that for all elements `i` in `β`, `f(i)` is less than or equal to `M`. In other words, there is an upper bound `M` in `α` for the image of `f`.

If `α` is a nonempty type with a preorder, `β` is finite, and there exists a function `f` from `β` to `α` such that `α` is directed with respect to the preorder, then there exists an upper bound `M` in `α` for the image of `f`.


theorem MonoidHom.mrange_top_iff_surjective :
    ∀ {M : Type u_1} {N : Type u_2} [inst : MulOneClass M] [inst_1 : MulOneClass N] {F : Type u_5}
      [inst_2 : FunLike F M N] [mc : MonoidHomClass F M N] {f : F}, MonoidHom.mrange f = ⊤ ↔ Function.Surjective ⇑f :=
  by sorry

The theorem `MonoidHom.mrange_top_iff_surjective` states that for any given types `M` and `N` - assumed to be instances of `MulOneClass` (that is, they have multiplicative identity) - and any function type `F` which is a `FunLike` from `M` to `N` and also a `MonoidHomClass` from `M` to `N`, for any function `f` of type `F`, the monoid homomorphism range of `f` is the entire codomain (`⊤`) if and only if `f` is a surjective function. In other words, a function `f` between two monoids is surjective if it maps to every element in the codomain.

A function between two monoids is a surjection if and only if its monoid homomorphism range equals the codomain.


theorem Classical.epsilon_spec : ∀ {α : Sort u} {p : α → Prop} (hex : ∃ y, p y), p (Classical.epsilon p) := by sorry

This theorem, `Classical.epsilon_spec`, states that for any type `α` and any property `p` from `α` to `Prop`, if there exists an element `y` of `α` that satisfies the property `p`, then the Hilbert epsilon function applied to the property `p` also satisfies the property `p`. In other words, if there is an `y` such that `p(y)` is true, then `p(Classical.epsilon p)` is also true. This theorem is a key property of the Hilbert epsilon function, which chooses an arbitrary element that satisfies a given property if such an element exists.

If a property `p` of type `α` has an element `y` satisfying it, then the Hilbert epsilon function `Classical.epsilon p` also satisfies `p`.


theorem HomologicalComplex.cylinder.proof_1 :
    ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} C] [inst_1 : CategoryTheory.Preadditive C]
      {ι : Type u_1} {c : ComplexShape ι} (K : HomologicalComplex C c)
      [inst_2 : ∀ (i : ι), CategoryTheory.Limits.HasBinaryBiproduct (K.X i) (K.X i)],
      CategoryTheory.Limits.HasBinaryBiproduct K K :=
  by sorry

This theorem states that for any given homological complex `K` in a preadditive category `C` with a complex shape `c`, if each object `(K.X i)` in the complex has a binary biproduct with itself, then the homological complex `K` also has a binary biproduct with itself. Here, `K.X i` represents the `i`th object in the complex. The theorem is universal for any type `C` and `ι`, where `C` has category theory structure and preadditive structure, and `ι` gives the indexing set for the complex shape.

If each object in a homological complex in a preadditive and categorically structured category has a binary biproduct with itself, then the complex itself has a binary biproduct.


theorem measurable_coe_nnreal_real : Measurable NNReal.toReal := by sorry

The theorem `measurable_coe_nnreal_real` states that the function that coerces non-negative real numbers (`ℝ≥0`, denoted `NNReal` in Lean 4) into real numbers (`ℝ`) is a measurable function. In more detail, if we take any measurable set in the space of real numbers, the preimage of this set under the function `NNReal.toReal` is a measurable set in the space of non-negative real numbers.

The function `NNReal.toReal` that maps non-negative real numbers to real numbers is measurable, meaning the preimage of any measurable real set is a measurable non-negative real set.


theorem simple_iff_isSimpleModule :
    ∀ {R : Type u_1} {M : Type u_2} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M],
      CategoryTheory.Simple (ModuleCat.of R M) ↔ IsSimpleModule R M :=
  by sorry

The theorem `simple_iff_isSimpleModule` states that, for any ring `R` and any `M` such that `M` forms a commutative addition group and is a module over `R`, a module `M` is simple in the category of `R`-modules if and only if `M` is simple as an `R`-module. Here, a module is considered simple in the category if it is simple as an object in this category, and it is considered simple as an `R`-module if it has only two submodules: the zero submodule (`⊥`) and the entire module itself (`⊤`).

A module over a ring is simple in the category of `R`-modules if and only if it is a simple `R`-module.


/-- The defining property of `OverArrows.val`.  -/
theorem CategoryTheory.OverPresheafAux.OverArrows.app_val :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {A F : CategoryTheory.Functor Cᵒᵖ (Type v)} {η : F ⟶ A}
      {X : C} {s : CategoryTheory.yoneda.obj X ⟶ A} (p : CategoryTheory.OverPresheafAux.OverArrows η s),
      η.app (Opposite.op X) (CategoryTheory.OverPresheafAux.OverArrows.val p) = CategoryTheory.yonedaEquiv s :=
  by sorry

This theorem states the defining property of the function `OverArrows.val` in the category theory context. Specifically, it says that for any object `X` in a category `C`, any functors `A` and `F` from the opposite of `C` to `Type v`, a natural transformation `η` from `F` to `A`, a natural transformation `s` from the Yoneda embedding of `X` to `A`, and an element `p` of type `OverArrows η s`, the application of `η` at `X` acting on `OverArrows.val p` is equivalent to the Yoneda equivalence of `s`. In other words, it gives a condition that the "value" of an element of the `OverArrows` construction under `η` corresponds to its representation under the Yoneda embedding.

For any object X in a category C, functors A and F from the opposite of C to Type v, natural transformations η from F to A and s from the Yoneda embedding of X to A, and an element p of type OverArrows η s, we have η (X (OverArrows.val p)) ≈ s.


theorem List.reverse_suffix : ∀ {α : Type u_1} {l₁ l₂ : List α}, List.reverse l₁ <:+ List.reverse l₂ ↔ l₁ <+: l₂ := by
  sorry

This theorem states that for all types `α` and for any two lists `l₁` and `l₂` of type `α`, the reverse of `l₁` is a suffix of the reverse of `l₂` if and only if `l₁` is a prefix of `l₂`. This is to say, if we reverse both lists, the property of `l₁` being a prefix of `l₂` transforms to its reverse being a suffix of the reverse of `l₂`, and vice versa.

For all types `α`, the reverse of list `l₁` being a suffix of the reverse of list `l₂` if and only if list `l₁` is a prefix of list `l₂`.


theorem Nat.Subtype.ofNat_surjective :
    ∀ {s : Set ℕ} [inst : Infinite ↑s] [inst_1 : DecidablePred fun x => x ∈ s],
      Function.Surjective (Nat.Subtype.ofNat s) :=
  by sorry

This theorem, `Nat.Subtype.ofNat_surjective`, states that for any set `s` of natural numbers which is infinite (`Infinite ↑s`) and has a decidable membership predicate (`DecidablePred fun x => x ∈ s`), the function `Nat.Subtype.ofNat` is surjective. In mathematical terms, this means that for every element in the co-domain (the subtype of natural numbers in `s`), there exists an element in the domain (the set of natural numbers) such that the function maps this domain element to the given co-domain element. In other words, every element in the subtype `↑s` can be attained by applying the function `Nat.Subtype.ofNat` on some natural number.

If `s` is an infinite, decidably enumerable set of natural numbers, then the function `Nat.Subtype.ofNat : Nat →* ↑s` is surjective.


theorem irreducible_iff :
    ∀ {α : Type u_1} [inst : Monoid α] {p : α},
      Irreducible p ↔ ¬IsUnit p ∧ ∀ (a b : α), p = a * b → IsUnit a ∨ IsUnit b :=
  by sorry

The theorem `irreducible_iff` states that for any type `α` that is a `Monoid`, an element `p` of `α` is irreducible if and only if it is not a unit and for any two elements `a` and `b` of `α`, if `p` is equal to the product of `a` and `b`, then either `a` or `b` is a unit. Here, a unit in a monoid is an element that has a two-sided inverse.

An element `p` of a monoid `α` is irreducible if and only if it is not a unit and there does not exist non-unit elements `a` and `b` in `α` such that `p = a * b`.


theorem FreeGroup.Red.Step.cons_not :
    ∀ {α : Type u} {L : List (α × Bool)} {x : α} {b : Bool}, FreeGroup.Red.Step ((x, b) :: (x, !b) :: L) L := by sorry

This theorem states that for any type `α`, any list `L` of pairs of `α` and `Bool`, and any `α` value `x` and boolean value `b`, a `FreeGroup.Red.Step` from a list beginning with the pair `(x, b)` followed by `(x, !b)` and then `L` to the list `L` itself always exists. Essentially, it says that in the reduction process of a free group, a pair and its inverse can be removed from the list.

For any type `α` and list `L` of pairs of `α` and booleans, there exists a `FreeGroup.Red.Step` between lists `[(x, b), (x, !b), L]` and `L`, where `x : α` and `b : Bool`.


theorem Mathlib.LinearAlgebra.Matrix.DotProduct._auxLemma.1 :
    ∀ {α : Sort u_1} {β : α → Sort u_4} {f₁ f₂ : (x : α) → β x}, (f₁ = f₂) = ∀ (a : α), f₁ a = f₂ a := by sorry

This theorem, `Mathlib.LinearAlgebra.Matrix.DotProduct._auxLemma.1`, asserts that for any two functions `f₁` and `f₂` from a type `α` to a dependent type `β`, the equality of `f₁` and `f₂` is equivalent to the statement that for every element `a` of `α`, `f₁ a` equals `f₂ a`. In other words, two functions are considered equal if they produce the same output for every input.

The theorem asserts that two functions from type `α` to a dependent type `β` are equal if and only if they map every element `a` in `α` to the same value `f₁ a = f₂ a`.


LipschitzWith.add

theorem LipschitzWith.add :
    ∀ {α : Type u_3} {E : Type u_6} [inst : SeminormedAddCommGroup E] [inst_1 : PseudoEMetricSpace α] {Kf Kg : NNReal}
      {f g : α → E}, LipschitzWith Kf f → LipschitzWith Kg g → LipschitzWith (Kf + Kg) fun x => f x + g x :=
  by sorry

The theorem `LipschitzWith.add` states that for any type `α` and a semi-normed add commutative group `E`, given two nonnegative real numbers `Kf` and `Kg`, and two functions `f` and `g` that are Lipschitz continuous with constants `Kf` and `Kg` respectively, the function that maps any element `x` of type `α` to the sum of `f x` and `g x` is also Lipschitz continuous with the constant being the sum of `Kf` and `Kg`. In other words, the addition of two Lipschitz continuous functions is also Lipschitz continuous, with the Lipschitz constant being the sum of the Lipschitz constants of the two functions.

If `f` and `g` are Lipschitz continuous functions with constants `Kf` and `Kg` respectively on a semi-normed additive commutative group `E`, then their sum `h(x) = f(x) + g(x)` is a Lipschitz continuous function with constant `Kf + Kg`.


theorem Multiset.singleton_bind :
    ∀ {α : Type u_1} {β : Type v} (a : α) (f : α → Multiset β), Multiset.bind {a} f = f a := by sorry

This theorem, `Multiset.singleton_bind`, states that for any type `α` and `β`, any element `a` of type `α`, and any function `f` from `α` to `Multiset β`, the `bind` operation on a `Multiset` containing singleton element `a` with the function `f`, is equal to the result of applying function `f` on `a`. Essentially, it means that binding over a multiset with only one element is the same as directly applying the function to that element.

For any type `α` and `β`, given a `Multiset` `ms` of type `α` with a single element `a`, `bind (ms) f = f a`.


theorem WithLp.prod_nnnorm_eq_sup :
    ∀ {α : Type u_2} {β : Type u_3} [inst : SeminormedAddCommGroup α] [inst_1 : SeminormedAddCommGroup β]
      (f : WithLp ⊤ (α × β)), ‖f‖₊ = ‖f.1‖₊ ⊔ ‖f.2‖₊ :=
  by sorry

This theorem states that for any types `α` and `β` that are both semi-normed additive commutative groups, and for any function `f` of type `WithLp ⊤ (α × β)`, the semi-norm of `f` (denoted as `‖f‖₊`) is equal to the supremum (`⊔`, the least upper bound) of the semi-norms of the first (`f.1`) and second (`f.2`) components of `f`. In simpler words, the semi-norm of a function on a product of two semi-normed additive groups is the maximum of the semi-norms of its components.

For any function `f` of type `WithLp ⊤ (α × β)`, where `α` and `β` are semi-normed additive commutative groups, the semi-norm `‖f‖₊` is equal to the supremum of the semi-norms of `f.1` and `f.2`.


theorem hasFDerivWithinAt_congr_set :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {f : E → F}
      {f' : E →L[𝕜] F} {x : E} {s t : Set E},
      s =ᶠ[nhds x] t → (HasFDerivWithinAt f f' s x ↔ HasFDerivWithinAt f f' t x) :=
  by sorry

This theorem states that for any non-trivially normed field `𝕜`, normed additive commutative groups `E` and `F`, and normed spaces over `𝕜` corresponding to `E` and `F`, given a function `f` from `E` to `F`, its Frechet derivative `f'`, a point `x` in `E`, and two sets `s` and `t` in `E`, if `s` and `t` are eventually equal in the neighborhood of `x` (i.e., they are equal when restricted to some open set around `x`), then `f` has a Frechet derivative within `s` at `x` if and only if `f` has a Frechet derivative within `t` at `x`. In other words, the existence of the Frechet derivative of a function at a point within a set is invariant under changes to the set that only affect points outside a neighborhood of the point.

Given a non-trivially normed field `𝕜`, normed spaces `E` and `F` over `𝕜`, a function `f` from `E` to `F`, and points `x` in `E` with sets `s` and `t` in `E` equivalent in a neighborhood of `x`, if `f` has a Frechet derivative at `x` in both `s` and `t`, then the Frechet derivatives are equal.


theorem singleton_add_closedBall :
    ∀ {E : Type u_1} [inst : SeminormedAddCommGroup E] (δ : ℝ) (x y : E),
      {x} + Metric.closedBall y δ = Metric.closedBall (x + y) δ :=
  by sorry

The theorem `singleton_add_closedBall` states that for any type `E` which is a seminormed additive commutative group, any real number `δ`, and any two elements `x` and `y` of `E`, the set obtained by adding the singleton set containing `x` to the closed ball centered at `y` with radius `δ` (which is the set of all points in `E` whose distance to `y` is less than or equal to `δ`) is equal to the closed ball centered at `x + y` with radius `δ`. In other words, translating the entire ball by `x` in the seminormed additive commutative group `E` gives the same set as the ball centered at `x + y`.

For any seminormed additive commutative group `E`, real number `δ`, and elements `x, y` in `E`, the closed ball centered at `x + y` with radius `δ` equals the set obtained by translating the closed ball centered at `y` with radius `δ` by adding `x`.


theorem Ordinal.principal_zero : ∀ {op : Ordinal.{u_1} → Ordinal.{u_1} → Ordinal.{u_1}}, Ordinal.Principal op 0 := by
  sorry

The theorem `Ordinal.principal_zero` states that for any binary operation on ordinals, the ordinal zero is considered principal. In other words, for any two ordinals that are less than zero, the result of the operation on these two ordinals is also less than zero. This is a somewhat unconventional definition, since typically the concept of a principal ordinal is used in the context of non-zero ordinals.

The theorem `Ordinal.principal_zero` asserts that the ordinal zero is the identity element for any binary operation on ordinals, such that for all ordinals `x` and `y` below zero, `x + y` (or `x * y` for multiplication) is less than zero.


theorem AlgebraicGeometry.targetAffineLocally_respectsIso :
    ∀ {P : AlgebraicGeometry.AffineTargetMorphismProperty},
      CategoryTheory.MorphismProperty.RespectsIso (AlgebraicGeometry.AffineTargetMorphismProperty.toProperty P) →
        CategoryTheory.MorphismProperty.RespectsIso (AlgebraicGeometry.targetAffineLocally P) :=
  by sorry

The theorem `AlgebraicGeometry.targetAffineLocally_respectsIso` states that for any property `P` which classifies morphisms from an arbitrary scheme into an affine scheme, if this property respects isomorphisms when extended to a `MorphismProperty` such that it never holds when the target is not affine, then this property will also respect isomorphisms after being extended to hold whenever `P` holds for the restriction of the morphisms on every affine open subset of the target scheme. In other words, this theorem shows that if a property of morphisms to affine targets respects the composition with isomorphisms, it will continue to respect isomorphisms when considered locally on the target.

If a property of morphisms from a scheme to an affine scheme respects isomorphisms and holds for the restriction of morphisms on every affine open subset of the target scheme, then it also respects isomorphisms on the entire target scheme.


theorem Finset.eq_empty_iff_forall_not_mem : ∀ {α : Type u_1} {s : Finset α}, s = ∅ ↔ ∀ (x : α), x ∉ s := by sorry

This theorem states that for any set `s` of arbitrary type `α`, `s` is equal to the empty set if and only if for all elements `x` of type `α`, `x` is not a member of `s`. Essentially, a set is considered empty if it does not contain any elements.

A set `s` of type `α` is empty if and only if for all `x` of type `α`, `x ∉ s`.


/-- All points lie in the circumsphere.  -/
theorem Affine.Simplex.mem_circumsphere :
    ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V]
      [inst_2 : MetricSpace P] [inst_3 : NormedAddTorsor V P] {n : ℕ} (s : Affine.Simplex ℝ P n) (i : Fin (n + 1)),
      s.points i ∈ Affine.Simplex.circumsphere s :=
  by sorry

The theorem `Affine.Simplex.mem_circumsphere` states that for any given simplex in an affine space, all of its vertices lie on the circumsphere of the simplex. Here, a simplex is defined in an affine space over the real numbers ℝ, which is equipped with a normed add commutative group structure, an inner product space structure, and a metric space structure. The simplex is indexed by a finite ordinal `n`, and each vertex of the simplex is represented by a point in the affine space. The theorem verifies that each vertex of the simplex is indeed a point on the circumsphere, which is defined to be the unique sphere that circumscribes the simplex.

For any simplex of finite dimension in an affine space over the real numbers equipped with a norm, each vertex of the simplex lies on the circumscribing sphere of the simplex.


DifferentiableWithinAt.prod

theorem DifferentiableWithinAt.prod :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F]
      {G : Type u_4} [inst_5 : NormedAddCommGroup G] [inst_6 : NormedSpace 𝕜 G] {f₁ : E → F} {x : E} {s : Set E}
      {f₂ : E → G},
      DifferentiableWithinAt 𝕜 f₁ s x →
        DifferentiableWithinAt 𝕜 f₂ s x → DifferentiableWithinAt 𝕜 (fun x => (f₁ x, f₂ x)) s x :=
  by sorry

This theorem, `DifferentiableWithinAt.prod`, states that given a type `𝕜` which is a non-trivially normed field, types `E`, `F`, and `G` that are normed add commutative groups and normed spaces over `𝕜`, and two functions `f₁` and `f₂` from `E` to `F` and `G` respectively, if both `f₁` and `f₂` are differentiable at a point `x` within a set `s` (of type `Set E`), then the function mapping `x` to the pair `(f₁ x, f₂ x)` is also differentiable at the same point `x` within the same set `s`. Essentially, it ensures the differentiability of the product of two functions when both of the functions are differentiable at a specific point within a particular set.

If `f₁: E → F` and `f₂: E → G` are differentiable at `x ∈ E` within `s ⊆ E`, then the function `(x ↦ (f₁ x, f₂ x))` from `E` to `F × G` is differentiable at `x` within `s`.


theorem mul_one_div_cancel : ∀ {G₀ : Type u_3} [inst : GroupWithZero G₀] {a : G₀}, a ≠ 0 → a * (1 / a) = 1 := by sorry

This theorem states that for any type `G₀` that has the structure of a group with zero, for any non-zero element `a` of this group, the product of `a` and the reciprocal of `a` (which is `1 / a`) equals one. In other words, for any non-zero number `a` in such a group, `a` times its reciprocal is always equal to one. This corresponds to the well-known rule in mathematics that a number times its reciprocal equals one.

For any group with zero `G₀` and non-zero element `a` in it, `a * (1 / a) = 1`.


theorem PNat.toPNat'_coe : ∀ {n : ℕ}, 0 < n → ↑(Nat.toPNat' n) = n := by sorry

This theorem states that for any natural number `n`, given the condition that `n` is greater than 0, the function `Nat.toPNat'` converts `n` to a positive natural number, and when this result is then converted back to a natural number, we get `n` back. In other words, the function `Nat.toPNat'` acts as an identity function when applied to any natural number greater than 0, preserving the initial value through the conversion processes.

For any natural number `n` greater than 0, `Nat.toPNat'` and its inverse conversion function yield `n`. In mathematical notation: `(Nat.toPNat' ∘ Nat.cast) (n : Nat) = n` where `Nat.cast` is the conversion from positive natural number to natural number.


theorem AlgebraicGeometry.PresheafedSpace.IsOpenImmersion.locallyRingedSpace_toLocallyRingedSpace :
    ∀ {X Y : AlgebraicGeometry.LocallyRingedSpace} (f : X ⟶ Y)
      [inst : AlgebraicGeometry.LocallyRingedSpace.IsOpenImmersion f],
      AlgebraicGeometry.PresheafedSpace.IsOpenImmersion.toLocallyRingedSpace Y f.val = X :=
  by sorry

The theorem `AlgebraicGeometry.PresheafedSpace.IsOpenImmersion.locallyRingedSpace_toLocallyRingedSpace` states that for any two LocallyRingedSpaces `X` and `Y`, and a morphism `f` from `X` to `Y`, if `f` is an open immersion of LocallyRingedSpaces (as defined by `AlgebraicGeometry.LocallyRingedSpace.IsOpenImmersion`), then the result of applying the function `AlgebraicGeometry.PresheafedSpace.IsOpenImmersion.toLocallyRingedSpace` to `Y` and the underlying morphism of `f` (i.e., `f.val`) yields `X`. In other words, if an open immersion from `X` to `Y` exists, then transforming `Y` via this open immersion results in `X`.

If `f: X -> Y` is an open immersion of Locally Ringed Spaces, then `AlgebraicGeometry.PresheafedSpace.IsOpenImmersion.toLocallyRingedSpace Y f.val = X`.


theorem antivary_inv_left₀ :
    ∀ {ι : Type u_1} {α : Type u_2} {β : Type u_3} [inst : LinearOrderedSemifield α] [inst_1 : LinearOrderedSemifield β]
      {f : ι → α} {g : ι → β}, StrongLT 0 f → (Antivary f⁻¹ g ↔ Monovary f g) :=
  by sorry

The theorem `antivary_inv_left₀` states that for all types `ι`, `α`, and `β` where `α` and `β` are linear ordered semifields, and for all functions `f : ι → α` and `g : ι → β`, if function `f` is strongly greater than 0 (meaning for all `i` in `ι`, `f(i)` is greater than 0), then the function `f⁻¹` (the reciprocal function of `f`) antivaries with `g` if and only if `f` monovaries with `g`. In other words, if `g i < g j` implies `f⁻¹ j ≤ f⁻¹ i`, then and only then `g i < g j` implies `f i ≤ f j`.

For functions \(f : ι \to \alpha\) and \(g : ι \to \beta\) over linear ordered semifield types \(\alpha\) and \(\beta\), if \(f\) is strictly positive and \(f⁻¹\) antivaries with \(g\), then \(f\) monovaries with \(g\), and conversely.


theorem WeierstrassCurve.Affine.natDegree_polynomial :
    ∀ {R : Type u} [inst : CommRing R] (W : WeierstrassCurve.Affine R) [inst_1 : Nontrivial R],
      Polynomial.natDegree W.polynomial = 2 :=
  by sorry

This theorem states that for any commutative ring `R` and any affine Weierstrass curve `W` over `R` (where `R` is nontrivial), the natural degree of the polynomial representing the curve is always equal to 2. The "natural degree" here refers to the degree of the polynomial in the natural numbers, which is forced to be a natural number by defining the degree of the zero polynomial as zero. The Weierstrass curve in this context is a type of elliptic curve.

For any commutative nontrivial ring `R` and affine Weierstrass curve `W` over `R`, the degree of its polynomial representation is equal to 2.


theorem Finsupp.update_self :
    ∀ {α : Type u_1} {M : Type u_5} [inst : Zero M] (f : α →₀ M) (a : α), Finsupp.update f a (f a) = f := by sorry

The theorem `Finsupp.update_self` states that for any type `α`, any type `M` with a zero element, any finitely supported function `f` from `α` to `M`, and any element `a` of type `α`, updating `f` at `a` with the value `f(a)` leaves `f` unchanged. In simpler terms, if we update the function at a specific point with the function's value at that point, then the function does not change.

For any type `α`, any type `M` with a zero element, and any finitely supported function `f:` `α` `→` `M`, `f` is equal to the function obtained by updating `f` at `a` with the value `f(a)` for all `a` in `α`.


theorem countable_iff_nonempty_embedding : ∀ {α : Sort u}, Countable α ↔ Nonempty (α ↪ ℕ) := by sorry

This theorem states that, for any arbitrary type `α`, `α` is countable if and only if there exists a nonempty embedding from `α` to the natural numbers `ℕ`. In more detail, this means that there is a one-to-one function (the embedding) from `α` to `ℕ` that covers at least one element of `α` (i.e., the embedding is nonempty), and this is equivalent to the condition of `α` being countable.

A type `α` is countable if and only if there exists a one-to-one function from `α` to the natural numbers `ℕ`.


theorem Mathlib.Analysis.Normed.Field.Basic._auxLemma.3 : ∀ {α : Type u} [inst : Preorder α] {a : α}, (a ≤ a) = True :=
  by sorry

This theorem states that for any type `α` with a preorder relation defined on it and any element `a` of type `α`, the proposition that `a` is less than or equal to itself is always true. This is a reflection of the reflexivity property of preorders in mathematics, where for any element in a set, it is always less than or equal to itself.

For any preorder `α` and its element `a`, `a ≤ a` holds true.


/-- Given a point on a sphere and a point not outside it, the inner product between the
difference of those points and the radius vector is positive unless the points are equal.  -/
theorem EuclideanGeometry.inner_pos_or_eq_of_dist_le_radius :
    ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V]
      [inst_2 : MetricSpace P] [inst_3 : NormedAddTorsor V P] {s : EuclideanGeometry.Sphere P} {p₁ p₂ : P},
      p₁ ∈ s → dist p₂ s.center ≤ s.radius → 0 < ⟪p₁ -ᵥ p₂, p₁ -ᵥ s.center⟫_ℝ ∨ p₁ = p₂ :=
  by sorry

This theorem states that given a sphere in Euclidean geometry, if we consider a point on this sphere and another point that is not outside of the sphere, then the inner product between the vector difference of these two points and the radius vector of the sphere is either positive or the two points are the same. This is true for all points and spheres in a normed add-torsor, which is a metric space equipped with a normed add commutative group structure and an inner product space over the real numbers.

Given a sphere in a normed add-torsor with an inner product, for any two points on the sphere, the inner product of the vector difference between them and the radius vector is non-negative (zero if and only if the points are identical).


theorem ZMod.coe_int_cast : ∀ {n : ℕ} (a : ℤ), ZMod.cast ↑a = a % ↑n := by sorry

This theorem, named `ZMod.coe_int_cast`, states that for any natural number `n` and any integer `a`, if we cast the integer `a` to a `ZMod n` and then cast it back to an integer, we obtain the integer `a` modulo `n`. In other words, it describes the relationship between the operations of casting from integers to integers modulo `n` and taking the remainder of division by `n`.

For any natural number `n` and integer `a`, the reduction of `a` modulo `n` is equal to the result of casting `a` to `ZMod n` and then back to an integer.


ContinuousLinearEquiv.hasFDerivWithinAt

theorem ContinuousLinearEquiv.hasFDerivWithinAt :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {x : E}
      {s : Set E} (iso : E ≃L[𝕜] F), HasFDerivWithinAt (⇑iso) (↑iso) s x :=
  by sorry

The theorem `ContinuousLinearEquiv.hasFDerivWithinAt` states that for any nontrivially normed field `𝕜`, and any normed additive commutative groups `E` and `F` which are also normed spaces over `𝕜`, for any element `x` of `E` and any set `s` of `E`, if `iso` is a continuous linear equivalence between `E` and `F`, then the function `iso` has a derivative within the set `s` at the point `x`, and that derivative is `iso` itself.

For any nontrivially normed field `𝕜`, given a continuous linear equivalence `iso` between normed additive commutative groups `E` and `F` over `𝕜`, and for any `x` in `E` and set `s` in `E`, `iso` has a derivative equal to itself at `x` within `s`.


theorem Nat.mul_lt_mul_of_pos_right : ∀ {n m k : ℕ}, n < m → k > 0 → n * k < m * k := by sorry

This theorem states that for any three natural numbers 'n', 'm', and 'k', if 'n' is less than 'm' and 'k' is greater than 0, then the product of 'n' and 'k' is less than the product of 'm' and 'k'. In other words, multiplication by a positive number preserves the order of natural numbers.

For all natural numbers n, m, and k where n < m and k > 0, n * k < m * k.


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

The theorem `toIocMod_add_zsmul` states that for any type `α` that is a linearly ordered additive commutative group and satisfies the Archimedean property, given a positive element `p`, two elements `a` and `b` of `α`, and an integer `m`, the operation `toIocMod` applied to `a` and `(b + m • p)` is equal to `toIocMod` applied to `a` and `b`. Here, `toIocMod` is a function that reduces `b` to the interval `(a, a + p)`, and `m • p` represents the multiplication of the integer `m` with the element `p`.

For any Archimedean, additively commutative group `α` with a positive element `p`, and integers `m` and `a, b` in `α`, `toIocMod a (b + m*p) = toIocMod a b`.


theorem eqRec_heq : ∀ {α : Sort u} {φ : α → Sort v} {a a' : α} (h : a = a') (p : φ a), HEq (Eq.recOn h p) p := by sorry

This theorem, `eqRec_heq`, states that for any type `α`, any type-dependent function `φ` from `α` to some other type, and any two elements `a` and `a'` of `α` with a proof `h` that `a` equals `a'`, and any element `p` of type `φ a`, the `HEq` relationship (heterogeneous equality, or equality between elements of possibly different types) holds between the element obtained by applying the `Eq.recOn` function with the equality `h` and the element `p`, and the original element `p` itself. In other words, we can "reconstruct" the original element `p` using the `Eq.recOn` function and the proof of equality `h`, and the result is heterogeneously equal to `p`.

For any type `α`, type-dependent function `φ : α → *`, elements `a` and `a'` of `α` with proof `h : a = a'`, and element `p : φ a`, `Eq.recOn h p = p` holds up to heterogeneous equality.


theorem lt_mul_of_one_lt_left :
    ∀ {α : Type u_1} {a b : α} [inst : MulOneClass α] [inst_1 : Zero α] [inst_2 : Preorder α]
      [inst_3 : MulPosStrictMono α], 0 < b → 1 < a → b < a * b :=
  by sorry

The theorem `lt_mul_of_one_lt_left` states that for any type `α` that has multiplication and a one element (`MulOneClass α`), a zero element (`Zero α`), and a preorder comparison (`Preorder α`), and also satisfies the property of strict monotonicity of multiplication by positive elements on the right (`MulPosStrictMono α`), if `b` is positive (`0 < b`) and `a` is greater than one (`1 < a`), then `b` is less than the product of `a` and `b` (`b < a * b`). In other words, if we have a strictly ordered semiring, and `b` is a positive element and `a` is an element greater than one, then the product of `a` and `b` is strictly greater than `b`.

If `α` is a strictly ordered semiring with one element `1`, and `0 < a` and `0 < b`, then `b < a * b`.


theorem MeasurableSpace.DynkinSystem.generate_le :
    ∀ {α : Type u_1} (d : MeasurableSpace.DynkinSystem α) {s : Set (Set α)},
      (∀ t ∈ s, d.Has t) → MeasurableSpace.DynkinSystem.generate s ≤ d :=
  by sorry

This theorem states that for any type `α`, any Dynkin system `d` on `α`, and any collection `s` of sets of `α`, if every element `t` in `s` is in the Dynkin system `d` (i.e., `d.Has t`), then the Dynkin system generated by `s` is a sub-Dynkin-system of `d`. In other words, any Dynkin system that contains the elements of `s` must also contain the Dynkin system generated by `s`. This represents an essential property of the generated Dynkin system: it's the smallest Dynkin system containing a given collection of sets.

If every set in a collection `s` is in a Dynkin system `d`, then the Dynkin system generated by `s` is a sub-Dynkin-system of `d`.


/-- If `M / R` and `M' / R'` are modules, `i : R' → R` is a map which sends non-zero elements to
non-zero elements, `j : M →+ M'` is an injective group homomorphism, such that the scalar
multiplications on `M` and `M'` are compatible, then the rank of `M / R` is smaller than or equal to
the rank of `M' / R'`. As a special case, taking `R = R'` it is
`LinearMap.lift_rank_le_of_injective`.  -/
theorem lift_rank_le_of_injective_injective :
    ∀ {R : Type u} {R' : Type u'} {M : Type v} {M' : Type v'} [inst : Ring R] [inst_1 : Ring R']
      [inst_2 : AddCommGroup M] [inst_3 : AddCommGroup M'] [inst_4 : Module R M] [inst_5 : Module R' M'] (i : R' → R)
      (j : M →+ M'),
      (∀ (r : R'), i r = 0 → r = 0) →
        Function.Injective ⇑j →
          (∀ (r : R') (m : M), j (i r • m) = r • j m) →
            Cardinal.lift.{v', v} (Module.rank R M) ≤ Cardinal.lift.{v, v'} (Module.rank R' M') :=
  by sorry

This theorem states that if `M / R` and `M' / R'` are modules, `i : R' → R` is a function that maps non-zero elements to non-zero elements, and `j : M →+ M'` is an injective group homomorphism such that the scalar multiplications on `M` and `M'` are compatible, then the rank of `M / R` (lifted to a higher universe) is less than or equal to the rank of `M' / R'` (lifted to a higher universe). This theorem can be specialized to the case where `R = R'` to give a result about the rank of a module under an injective linear map. The rank of a module is a cardinality measure of its basis, so this theorem is essentially asserting that the "size" of a module does not increase under an injective linear map.

If `i : R' → R` is a function mapping non-zero elements to non-zero elements, `j : M →+ M'` is an injective group homomorphism between modules `M / R` and `M' / R'` with compatible scalar multiplications, then the rank of `M / R` (in a higher universe) is less than or equal to the rank of `M' / R'` (in a higher universe).


theorem Function.Surjective.wellFounded_iff :
    ∀ {α : Type u_1} {β : Type u_2} {r : α → α → Prop} {s : β → β → Prop} {f : α → β},
      Function.Surjective f → (∀ {a b : α}, r a b ↔ s (f a) (f b)) → (WellFounded r ↔ WellFounded s) :=
  by sorry

The theorem `Function.Surjective.wellFounded_iff` states that for any types `α` and `β`, any relations `r` on `α` and `s` on `β`, and any function `f` from `α` to `β` which is surjective, if the relation `r` between any two elements `a` and `b` of `α` equates to the relation `s` between `f(a)` and `f(b)`, then `r` is well-founded if and only if `s` is well-founded. In terms of mathematics, this theorem is saying that the well-foundedness of a relation is preserved under a surjective function if the relations on the domain and codomain are equivalent under the function.

A surjective function preserves the well-foundedness of relations between related elements.


theorem Filter.EventuallyEq.isMaxFilter_iff :
    ∀ {α : Type u_1} {β : Type u_2} [inst : Preorder β] {f g : α → β} {a : α} {l : Filter α},
      f =ᶠ[l] g → f a = g a → (IsMaxFilter f l a ↔ IsMaxFilter g l a) :=
  by sorry

The theorem `Filter.EventuallyEq.isMaxFilter_iff` states that for all types `α` and `β`, where `β` is a Preorder, for any functions `f` and `g` from `α` to `β`, any element `a` of type `α`, and any filter `l` on `α`, if `f` and `g` are eventually equal at the filter `l` and `f a` equals `g a`, then `f` is a maximal filter at `a` with respect to `l` if and only if `g` is also a maximal filter at `a` with respect to `l`. In other words, if two functions are the same in a neighborhood of `a` and agree at `a`, they share the same maxima in that neighborhood.

For functions `f` and `g` from type `α` to a preordered type `β`, and for an element `a` of type `α` and a filter `l` on `α`, if `f` and `g` are eventually equal at `l` and agree at `a`, then `f` and `g` have the same maximal elements at `a` with respect to `l`.


/-- If `α` is a preorder with no maximal element, then `atTop ≤ cofinite`.  -/
theorem Filter.atTop_le_cofinite :
    ∀ {α : Type u_2} [inst : Preorder α] [inst_1 : NoMaxOrder α], Filter.atTop ≤ Filter.cofinite := by sorry

This theorem states that if `α` is a type that has a preorder structure and there is no maximal element in `α` (formally, `α` satisfies the `NoMaxOrder` property), then the `atTop` filter on `α` is less than or equal to the `cofinite` filter on `α`. In other words, any set in `α` that is eventually always true (represented by the `atTop` filter) is also a set whose complement is finite (represented by the `cofinite` filter).

If `α` is a preordered type without a maximal element, then the `atTop` filter is included in the `cofinite` filter.


theorem RingHom.coe_monoidHom_injective :
    ∀ {α : Type u_2} {β : Type u_3} {x : NonAssocSemiring α} {x_1 : NonAssocSemiring β},
      Function.Injective fun f => ↑f :=
  by sorry

The theorem `RingHom.coe_monoidHom_injective` states that for any two types `α` and `β` (where `α` and `β` are non-associative semirings), the function that transforms a ring homomorphism into a monoid homomorphism (denoted as `f => ↑f`) is injective. This means that if two ring homomorphisms are mapped to the same monoid homomorphism, then they were originally the same ring homomorphism.

If two ring homomorphisms between non-associative semirings result in the same monoid homomorphism, then they are equal as functions.


theorem Cardinal.add_eq_left : ∀ {a b : Cardinal.{u_1}}, Cardinal.aleph0 ≤ a → b ≤ a → a + b = a := by sorry

The theorem `Cardinal.add_eq_left` states that for any two cardinal numbers `a` and `b`, if the smallest infinite cardinal (`ℵ₀`) is less than or equal to `a`, and `b` is also less than or equal to `a`, then the sum of `a` and `b` is equal to `a`. In mathematical terms, this theorem asserts that for infinite cardinalities, adding a smaller cardinality to a larger one doesn't increase the larger cardinality.

For any cardinal numbers `a` and `b` with `ℵ₀ ≤ a` and `b ≤ a`, `a + b = a`.


theorem RatFunc.ofFractionRing_smul :
    ∀ {K : Type u} [inst : CommRing K] {R : Type u_1} [inst_1 : SMul R (FractionRing (Polynomial K))] (c : R)
      (p : FractionRing (Polynomial K)), { toFractionRing := c • p } = c • { toFractionRing := p } :=
  by sorry

This theorem, `RatFunc.ofFractionRing_smul`, states that for any commutative ring `K`, any type `R` that allows scalar multiplication with the fraction ring of polynomials over `K`, any scalar `c` of type `R`, and any polynomial `p` in the fraction ring of polynomials over `K`, scalar multiplication of `c` with the structure `{ toFractionRing := p }` is equal to the structure `{ toFractionRing := c • p }`. In simpler terms, it says that scaling a polynomial in the fraction ring is the same as scaling the polynomial first and then taking it to the fraction ring.

For any commutative ring K, any type R admitting scalar multiplication with the fraction ring of polynomials over K, and for any scalar c in R and polynomial p in the fraction ring of polynomials over K, the scalar multiplication of c with the polynomial p is equal to the polynomial obtained by scaling p and then taking it to the fraction ring.


theorem FractionalIdeal.spanSingleton_mul_spanSingleton :
    ∀ {R : Type u_1} [inst : CommRing R] {S : Submonoid R} {P : Type u_2} [inst_1 : CommRing P] [inst_2 : Algebra R P]
      [loc : IsLocalization S P] (x y : P),
      FractionalIdeal.spanSingleton S x * FractionalIdeal.spanSingleton S y = FractionalIdeal.spanSingleton S (x * y) :=
  by sorry

The theorem `FractionalIdeal.spanSingleton_mul_spanSingleton` states that for any commutative ring `R`, submonoid `S` of `R`, algebra `P` over `R`, and localization of `S` to `P`; the fractional ideal generated by element `x` in `P` multiplied by the fractional ideal generated by element `y` in `P` is equal to the fractional ideal generated by `x * y`. This theorem describes a property of the operation of multiplication in the context of fractional ideals, highlighting the distributive property of multiplication over the generation of fractional ideals.

For any commutative ring R, submonoid S of R, algebra P over R, and localization of S to P: the fractional ideal generated by x in P times the fractional ideal generated by y in P equals the fractional ideal generated by x * y in P.


theorem Multiset.count_filter_of_pos :
    ∀ {α : Type u_1} [inst : DecidableEq α] {p : α → Prop} [inst_1 : DecidablePred p] {a : α} {s : Multiset α},
      p a → Multiset.count a (Multiset.filter p s) = Multiset.count a s :=
  by sorry

The theorem `Multiset.count_filter_of_pos` states that for any type `α` with decidable equality, any decidable predicate `p`, any element `a` of type `α`, and any multiset `s` of elements of type `α`, if `p a` is true, then the multiplicity of `a` in the multiset obtained by filtering `s` with `p` is equal to the multiplicity of `a` in `s`. In other words, if `p a` is true, then the process of filtering does not change the count of `a` in the multiset.

For any decidable type `α`, decidable predicate `p` on `α`, element `a` of `α`, and multiset `s` of `α`, if `p a` holds, then the number of occurrences of `a` in the filtered multiset `Multiset.filter s p` is equal to the number of occurrences of `a` in `s`.


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

This theorem states that for any type `M` equipped with a topological structure and a monoid structure, the canonical homomorphism of monoids from the units of `M` (`Mˣ`) into the product of `M` and the opposite of `M` (`M × Mᵐᵒᵖ`) is an inducing function. In the context of topology, an inducing function is one that induces the topology of its range from the topology of its domain. So, the theorem is saying that the topology on the product space `M × Mᵐᵒᵖ` can be obtained from the topology on the space of units of `M` using this canonical homomorphism.

The canonical homomorphism from the units of a topological monoid into the product of the monoid and its opposite is a topology-inducing function.


theorem Cardinal.range_ofENat : Set.range Cardinal.ofENat = Set.Iic Cardinal.aleph0 := by sorry

The theorem `Cardinal.range_ofENat` states that the range of the function `Cardinal.ofENat`, which maps extended natural numbers to cardinals, is equivalent to the set of cardinals that are less than or equal to `aleph0`, where `aleph0` is the smallest infinite cardinal. In other words, the `Cardinal.ofENat` function maps all natural numbers and the extended natural number `⊤` to cardinals that are less than or equal to the smallest infinite cardinal, `ℵ₀`.

The range of `Cardinal.ofENat` consists of cardinals less than or equal to `ℵ₀`.


theorem Set.image_eq_image :
    ∀ {α : Type u_1} {β : Type u_2} {s t : Set α} {f : α → β}, Function.Injective f → (f '' s = f '' t ↔ s = t) := by
  sorry

The theorem `Set.image_eq_image` states that for all types `α` and `β`, for all sets `s` and `t` of type `α`, and for all functions `f` from `α` to `β`, if `f` is injective (meaning that `f` always produces a unique output for each unique input), then the image of `s` under `f` is equal to the image of `t` under `f` if and only if `s` is equal to `t`. In other words, an injective function `f` maps two sets `s` and `t` to the same set of images if and only if `s` and `t` are the same. This theorem establishes the preservation of set equality under the application of an injective function.

For injective functions between sets, the image of two sets is equal if and only if the sets are equal.


theorem tsum_image :
    ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : AddCommMonoid α] [inst_1 : TopologicalSpace α] {g : γ → β}
      (f : β → α) {s : Set γ}, Set.InjOn g s → ∑' (x : ↑(g '' s)), f ↑x = ∑' (x : ↑s), f (g ↑x) :=
  by sorry

The theorem `tsum_image` states that for all types `α`, `β`, and `γ` where `α` is an additive commutative monoid and a topological space, given a function `g` from `γ` to `β`, a function `f` from `β` to `α`, and a set `s` of type `γ`, if `g` is injective on `s`, then the sum over the set of the image of `g` applied to `s` (i.e., `g '' s`) of `f` applied to the image is equal to the sum over `s` of `f` composed with `g`. In mathematical notation, this is saying that
`∑_{x ∈ g(s)} f(x) = ∑_{x ∈ s} f(g(x))`
where `∑` denotes the sum over a set, the injectivity of `g` on `s` ensures that each element in `s` is mapped to a unique element in `g(s)`, and `f` is then applied to each of these unique elements.

For any additive commutative monoid and topological space α, injective function g from γ to β, function f from β to α, and set s of type γ, the sum of f applied to the images of s under g equals the sum of f composed with g over s: ∑\_{x ∈ g(s)} f(x) = ∑\_{x ∈ s} f(g(x)).


theorem ContinuousLinearEquiv.symm_image_image :
    ∀ {R₁ : Type u_1} {R₂ : Type u_2} [inst : Semiring R₁] [inst_1 : Semiring R₂] {σ₁₂ : R₁ →+* R₂} {σ₂₁ : R₂ →+* R₁}
      [inst_2 : RingHomInvPair σ₁₂ σ₂₁] [inst_3 : RingHomInvPair σ₂₁ σ₁₂] {M₁ : Type u_4} [inst_4 : TopologicalSpace M₁]
      [inst_5 : AddCommMonoid M₁] {M₂ : Type u_6} [inst_6 : TopologicalSpace M₂] [inst_7 : AddCommMonoid M₂]
      [inst_8 : Module R₁ M₁] [inst_9 : Module R₂ M₂] (e : M₁ ≃SL[σ₁₂] M₂) (s : Set M₁),
      ⇑(ContinuousLinearEquiv.symm e) '' (⇑e '' s) = s :=
  by sorry

The theorem `ContinuousLinearEquiv.symm_image_image` states that for any two types `R₁` and `R₂` equipped with semiring structures, two homomorphisms `σ₁₂` and `σ₂₁` between them forming a ring homomorphism inverse pair, types `M₁` and `M₂` equipped with topological space structures, additive commutative monoid structures, and modules over `R₁` and `R₂` respectively, along with a continuous linear equivalence `e` from `M₁` to `M₂`, and a set `s` of type `M₁`, applying `e` to `s`, and then applying the inverse of `e` to the image, gives back the original set `s`. This theorem essentially captures the idea that a continuous linear equivalence and its inverse act as a bijective map and its inverse in the context of sets.

For any continuous linear equivalence between additive commutative monoids equipped with semiring structures and module structures over two rings, with inverse pair, the preimage of an image of a set under this equivalence and its inverse is the original set.


/-- Simplification of the integral of `sin x ^ m * cos x ^ n`, case `m` is odd.  -/
theorem integral_sin_pow_odd_mul_cos_pow :
    ∀ {a b : ℝ} (m n : ℕ),
      ∫ (x : ℝ) in a..b, Real.sin x ^ (2 * m + 1) * Real.cos x ^ n =
        ∫ (u : ℝ) in Real.cos b..Real.cos a, u ^ n * (1 - u ^ 2) ^ m :=
  by sorry

This theorem is about the simplification of a definite integral involving the sine and cosine functions. Specifically, it states that for any real numbers `a` and `b`, and natural numbers `m` and `n`, the integral from `a` to `b` of `sin(x)` to the power of `(2*m + 1)` times `cos(x)` to the power of `n`, is equal to the integral from `cos(b)` to `cos(a)` of `u` to the power of `n` times `(1 - u^2)` to the power of `m`. Essentially, this theorem provides a transformation for integrals where the power of sine is odd, swapping the integration variable from sine to cosine and adjusting the integrand accordingly. This can be used to simplify the computation of such integrals.

For real numbers `a` and `b` and natural numbers `m` and `n`, the integral from `a` to `b` of `sin(x)^(2m+1) * cos(x)^n` dx equals the integral from `cos(a)` to `cos(b)` of `u^n * (1 - u^2)^m` du.


theorem AlgebraicGeometry.morphismRestrict_base_coe :
    ∀ {X Y : AlgebraicGeometry.Scheme} (f : X ⟶ Y) (U : TopologicalSpace.Opens ↑↑Y.toPresheafedSpace)
      (x : (CategoryTheory.forget TopCat).obj ↑(X ∣_ᵤ f⁻¹ᵁ U).toPresheafedSpace),
      Coe.coe ((f ∣_ U).val.base x) = f.val.base ↑x :=
  by sorry

This theorem, `AlgebraicGeometry.morphismRestrict_base_coe`, states that for any two algebraic geometry schemes `X` and `Y`, a morphism `f` from `X` to `Y`, an open subset `U` of the topological space associated with `Y`, and a point `x` in the presheafed space associated with the restriction of `X` by the preimage of `U` under `f`, the image of `x` under the base of the restricted morphism `f ∣_ U` cast to the codomain type of `f` is equal to the image of `x` cast to the codomain type of `f` under the base of `f`.

In simpler terms, it states that the restriction of the morphism `f` to the preimage of `U` under `f` behaves the same as `f` itself when acting on `x`, in the sense that the image of `x` remains the same in the codomain type of `f`.

For any morphism `f` between algebraic geometry schemes `X` and `Y`, open subset `U` of `Y`, and point `x` in the presheafed space of `X` restricted to `U` by `f`, the base of the restriction `f ∣_ U` maps `x` to the same image as `f` mapping `x` to the codomain of `f`.


theorem Sum.lex_inl_inl :
    ∀ {α : Type u_1} {r : α → α → Prop} {β : Type u_2} {s : β → β → Prop} {a₁ a₂ : α},
      Sum.Lex r s (Sum.inl a₁) (Sum.inl a₂) ↔ r a₁ a₂ :=
  by sorry

This theorem, `Sum.lex_inl_inl`, is about the properties of the lexicographic order of sums in the context of two arbitrary types `α` and `β`, which are ordered by relations `r` and `s` respectively. Specifically, it states that for all elements `a₁` and `a₂` of type `α`, the lexicographic order `Sum.Lex r s` applied to the left-injections (`Sum.inl`) of `a₁` and `a₂` is equivalent to applying the relation `r` to `a₁` and `a₂` directly. In other words, ordering the left-injected sums is the same as ordering the elements themselves according to `r`.

For types `α` ordered by relation `r` and `β` ordered by relation `s`, the lexicographic order of the left-injections of `α` applied to elements `a₁` and `a₂` is equivalent to applying `r` directly to `a₁` and `a₂`. That is, `Sum.inl a₁ <~ Sum.Lex r s Sum.inl a₂` if and only if `a₁ r a₂`.


theorem disjoint_nhds_atTop :
    ∀ {α : Type u} [inst : Preorder α] [inst_1 : NoTopOrder α] [inst_2 : TopologicalSpace α]
      [inst_3 : ClosedIciTopology α] (a : α), Disjoint (nhds a) Filter.atTop :=
  by sorry

This theorem, `disjoint_nhds_atTop`, states the following: for any type `α` which is a `Preorder` and a `TopologicalSpace`, and for which there is no top order (`NoTopOrder`) and the topology is closed on the interval from a given value to infinity (`ClosedIciTopology`), the neighborhood filter (`nhds`) at any value `a` and the filter representing the limit towards infinity (`Filter.atTop`) are disjoint. This means that their infimum is the bottom element, generalizing the concept of disjoint sets. In more mathematical terms, for any element `x` that is less than or equal to `a` and is also in the limit towards infinity, `x` is less than or equal to the bottom element.

For any Preorder and TopologicalSpace α without a top order and with a ClosedIciTopology, the neighborhood filter at any point a is disjoint from the filter representing the limit towards infinity, i.e., their infimum is the bottom element.


theorem Filter.disjoint_principal_left :
    ∀ {α : Type u_1} {f : Filter α} {s : Set α}, Disjoint (Filter.principal s) f ↔ sᶜ ∈ f := by sorry

This theorem states that for any type `α`, any filter `f` on `α`, and any set `s` of `α`, the principal filter of `s` is disjoint from `f` if and only if the complement of `s` is in `f`. In other words, the principal filter (which is the collection of all supersets of `s`) and `f` do not have any element in common iff the set of all elements not in `s` belongs to the filter `f`. Here, `Disjoint` refers to the concept in lattice theory where two elements are considered disjoint if their infimum (greatest lower bound) is the bottom element of the lattice.

For any filter `f` on type `α` and set `s` of `α`, the principal filter of `s` and `f` are disjoint if and only if the complement of `s` is in `f`.


/-- A version of `Quotient.eq'` compatible with `Setoid.Rel`, to make rewriting possible.  -/
theorem Quotient.eq_rel :
    ∀ {α : Type u_1} {r : Setoid α} {x y : α}, Quotient.mk' x = Quotient.mk' y ↔ Setoid.Rel r x y := by sorry

The theorem `Quotient.eq_rel` asserts that for any type `α` and an equivalence relation `r` on `α`, and for any two elements `x` and `y` of type `α`, the quotient elements of `x` and `y` (created by the quotient map `Quotient.mk'`) are equal if and only if `x` and `y` are related under the equivalence relation `r`. This theorem essentially provides a way to relate the equality of quotient elements to the underlying equivalence relation, thereby facilitating the process of rewriting in proofs.

For any type `α` and equivalence relation `r` on `α`, the quotient map from `α` to `α / r` preserves equality, that is, `Quotient.mk r x = Quotient.mk r y` if and only if `x r y`.


theorem OmegaCompletePartialOrder.Continuous.of_bundled :
    ∀ {α : Type u} {β : Type v} [inst : OmegaCompletePartialOrder α] [inst_1 : OmegaCompletePartialOrder β] (f : α → β)
      (hf : Monotone f),
      OmegaCompletePartialOrder.Continuous { toFun := f, monotone' := hf } → OmegaCompletePartialOrder.Continuous' f :=
  by sorry

This theorem states that for any types `α` and `β`, given that `α` and `β` are both Omega Complete Partial Orders, for any function `f` from `α` to `β` that is monotone (i.e., `a ≤ b` implies `f(a) ≤ f(b)`), if that function is continuous when bundled with its monotonicity proof, then that function is also `Continuous'` in the sense of the `OmegaCompletePartialOrder` class. Essentially, this theorem connects the bundled and unbundled definitions of a continuous function in the context of Omega Complete Partial Orders.

If `f` is a monotone function from an Omega Complete Partial Order `α` to another Omega Complete Partial Order `β` and `f` is continuous when bundled with its monotonicity proof, then `f` is continuous in the sense of the `OmegaCompletePartialOrder` class.


theorem Mathlib.Topology.MetricSpace.Infsep._auxLemma.1 :
    ∀ {α : Type u_1} {ι : Sort u_5} [inst : CompleteLattice α] {f : ι → α} {a : α}, (a ≤ iInf f) = ∀ (i : ι), a ≤ f i :=
  by sorry

This theorem, `Mathlib.Topology.MetricSpace.Infsep._auxLemma.1`, states that for any type `α` that forms a `CompleteLattice`, any function `f` from an arbitrary type `ι` to `α`, and any element `a` of type `α`, the inequality `a ≤ iInf f` holds if and only if `a` is less than or equal to `f i` for all `i` of type `ι`. Here, `iInf` is the indexed infimum function which takes a function from `ι` to `α` and returns the greatest lower bound of the set of all values of the function.

For any complete lattice α and function f from type ι to α, element a belongs to the indexed infimum iInf(f) if and only if a is less than or equal to f(i) for all i of type ι.


theorem Mathlib.Topology.MetricSpace.Infsep._auxLemma.4 :
    ∀ {α : Type u_1} {ι : Sort u_5} [inst : CompleteLinearOrder α] {a : α} {f : ι → α}, (iInf f < a) = ∃ i, f i < a :=
  by sorry

The theorem, `Mathlib.Topology.MetricSpace.Infsep._auxLemma.4`, states that for any type `α`, which is a complete linear order, and any function `f` from an arbitrary index set `ι` to `α`, and for any element `a` of type `α`, the statement that the indexed infimum of `f` is less than `a` is equivalent to the existence of an index `i` such that `f(i)` is less than `a`. In other words, the infimum of the range of `f` being less than `a` means there exists some element in the range of `f` which is less than `a`.

For any complete linear order `α` and function `f` from an index set `ι` to `α`, the infimum of `f` is less than `a` if and only if there exists an index `i` such that `f(i)` is less than `a`.


theorem Set.mk_preimage_prod :
    ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {s : Set α} {t : Set β} (f : γ → α) (g : γ → β),
      (fun x => (f x, g x)) ⁻¹' s ×ˢ t = f ⁻¹' s ∩ g ⁻¹' t :=
  by sorry

This theorem, `Set.mk_preimage_prod`, states that for any three types `α`, `β`, and `γ`, any two sets `s` of type `α` and `t` of type `β`, and any two functions `f` and `g` from `γ` to `α` and `β` respectively, the preimage of set `s` cross `t` under the function that pairs the results of `f` and `g` applied on an element is equal to the intersection of the preimages of set `s` under `f` and set `t` under `g`. This theorem relates the concept of preimage of a function with the operations of set intersection and cartesian product.

For any sets `s` of type `α`, `t` of type `β`, and functions `f: γ -> α` and `g: γ -> β`, the preimage of `s` x `t` under the function that pairs `f` and `g` is equal to the intersection of `f^(-1)(s)` and `g^(-1)(t)`.


theorem Polynomial.smul_X :
    ∀ {M : Type u_1} [inst : Monoid M] {R : Type u_2} [inst_1 : Semiring R] [inst_2 : MulSemiringAction M R] (m : M),
      m • Polynomial.X = Polynomial.X :=
  by sorry

The theorem `Polynomial.smul_X` states that for any type `M` equipped with a monoid structure, any type `R` equipped with a semiring structure, any action of `M` on `R` preserving the semiring operations (i.e., a `MulSemiringAction`), and any element `m` of `M`, the polynomial obtained by scalar multiplication of the polynomial variable (also known as the indeterminate, represented by `Polynomial.X`) by `m` is equal to the original polynomial variable `Polynomial.X`. In short, it asserts that scalar multiplication by any element of the monoid leaves the polynomial variable `Polynomial.X` unchanged.

For any monoid `M`, semiring `R`, `MulSemiringAction` `mul_action` of `M` on `R`, and `m` in `M`, `Polynomial.X * mul_action m = Polynomial.X` holds in the polynomial ring over `R`.


theorem MvPowerSeries.coeff_zero_X :
    ∀ {σ : Type u_1} {R : Type u_2} [inst : Semiring R] (s : σ), (MvPowerSeries.coeff R 0) (MvPowerSeries.X s) = 0 := by
  sorry

The theorem `MvPowerSeries.coeff_zero_X` states that for any type `σ` and any type `R` with a semiring structure, and for any variable `s` of type `σ`, the zero-th coefficient of the multivariate formal power series in the variable `s` is zero. In other words, if you look at the formal power series for a given variable and try to extract the coefficient of the term of degree zero, you will always get the zero element of the ring `R`.

For any semiring `R` and variable `s` of type `σ`, the zero-th coefficient of the multivariate formal power series in `s` over `R` is the additive identity element of `R`.


theorem OnePoint.compl_range_coe : ∀ {X : Type u_1}, (Set.range OnePoint.some)ᶜ = {OnePoint.infty} := by sorry

The theorem `OnePoint.compl_range_coe` states that for any type `X`, the complement of the range of the function `OnePoint.some` (which coerces elements of type `X` to `OnePoint X`) is the set containing only the element `OnePoint.infty`. In other words, `OnePoint.infty` is the only element of the type `OnePoint X` that is not the image of any element from `X` under the function `OnePoint.some`.

The theorem `OnePoint.compl_range_coe` asserts that the complement of the image of `X` under `OnePoint.some` in `OnePoint X` consists only of `OnePoint.infty`.


theorem QuaternionAlgebra.coe_commutes :
    ∀ {R : Type u_3} [inst : CommRing R] {c₁ c₂ : R} (r : R) (a : QuaternionAlgebra R c₁ c₂), ↑r * a = a * ↑r := by
  sorry

This theorem states that for any commutative ring `R` and any elements `c₁`, `c₂`, and `r` of `R`, and any quaternion `a` in the quaternion algebra constructed over `R` with `c₁` and `c₂`, the multiplication of `r` (coerced to the quaternion algebra) and `a` is commutative. In other words, `r` times `a` is equal to `a` times `r`.

For any commutative ring `R`, any quaternion `a` in the quaternion algebra over `R` with basis `1, i, j, k` and any element `r` in `R`, we have `r * a = a * r`.


theorem AffineSubspace.preimage_coe_affineSpan_singleton :
    ∀ (k : Type u_1) (V : Type u_2) {P : Type u_3} [inst : Ring k] [inst_1 : AddCommGroup V] [inst_2 : Module k V]
      [S : AddTorsor V P] (x : P), Subtype.val ⁻¹' {x} = Set.univ :=
  by sorry

This theorem, `AffineSubspace.preimage_coe_affineSpan_singleton`, states that for any type `k` with a ring structure, a type `V` with an additive commutative group structure and a `k`-module structure, a type `P` that forms an additive torsor over `V`, and an element `x` of type `P`, the preimage under the function `Subtype.val` of the singleton set containing `x` is equal to the universal set. In simple terms, this theorem asserts that for all elements in our space, when we map them using `Subtype.val`, every element of our space will map to a singleton set `{x}`, implying that the entire space is covered by this preimage operation.

For any additive torsor P over a k-module V with a ring K, and any x in P, the preimage under Subtype.val of the singleton {x} equals the entire space V.


theorem AlgHom.normal_bijective :
    ∀ (F : Type u_1) (K : Type u_2) [inst : Field F] [inst_1 : Field K] [inst_2 : Algebra F K] (E : Type u_3)
      [inst_3 : Field E] [inst_4 : Algebra F E] [inst_5 : Algebra K E] [inst_6 : IsScalarTower F K E] [h : Normal F E]
      (ϕ : E →ₐ[F] K), Function.Bijective ⇑ϕ :=
  by sorry

The given theorem, `AlgHom.normal_bijective`, states that for any fields `F`, `K`, and `E` with `F` and `K` being subfields of `E` (as indicated by the algebra and scalar tower structures), and given that `E` is a normal extension of `F`, every algebra homomorphism `ϕ` from `E` to `K` that respects `F` (denoted `E →ₐ[F] K`), is a bijective function. Here, a function is called bijective if it is both injective (meaning every element of its domain maps to a unique element of its codomain) and surjective (meaning every element of its codomain is the image of some element of its domain).

If `F` and `K` are subfields of a normal extension field `E`, and `ϕ: E → K` is an algebra homomorphism respecting `F`, then `ϕ` is a bijective function.


theorem List.filter_eq_nil :
    ∀ {α : Type u_1} {p : α → Bool} {l : List α}, List.filter p l = [] ↔ ∀ a ∈ l, ¬p a = true := by sorry

This theorem is named `List.filter_eq_nil` and states that for any type `α`, any Boolean-valued function `p` on `α`, and any list `l` of elements of type `α`, the function `List.filter p l` returns an empty list if and only if for every element `a` in the list `l`, the function `p(a)` is not true. In other words, the filtering operation results in an empty list precisely when no elements of the original list satisfy the condition defined by the function `p`.

For any type `α`, list `l` of `α`, and Boolean-valued function `p` on `α`, `List.filter p l` is the empty list if and only if for all `a` in `l`, `p(a)` is false.


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

This theorem states that for any type `α` that is an additive commutative semigroup, a partially ordered set, has an addition operation for elements satisfying less than or equal relation, and supports subtraction operation that respects the order, if an element `b` is less than or equal to another element `c`, and an element `a` is less than or equal to the difference of `c` and `b`, then the sum of `a` and `b` is less than or equal to `c`.

If `α` is an additive commutative semigroup, a partially ordered set with respect to `≤`, and for all `a ≤ b ≤ c`, we have `a + b ≤ c`, then `α` satisfies the subadditivity property with respect to `≤`.


theorem isPrimePow_nat_iff : ∀ (n : ℕ), IsPrimePow n ↔ ∃ p k, Nat.Prime p ∧ 0 < k ∧ p ^ k = n := by sorry

The theorem `isPrimePow_nat_iff` states that for every natural number `n`, `n` is a prime power if and only if there exist a natural number `p` and `k` such that `p` is a prime number, `k` is greater than 0, and `n` is equal to `p` raised to the power `k`. In mathematical terms, it expresses the equivalence of the two conditions "n is a prime power" and "there exist p and k such that p is a prime number, k is a positive number, and n equals p to the power of k".

A natural number `n` is a prime power if and only if there exists a prime number `p` and a positive integer `k` such that `n = p^k`.


Memℓp.add

theorem Memℓp.add :
    ∀ {α : Type u_1} {E : α → Type u_2} {p : ENNReal} [inst : (i : α) → NormedAddCommGroup (E i)] {f g : (i : α) → E i},
      Memℓp f p → Memℓp g p → Memℓp (f + g) p :=
  by sorry

The theorem `Memℓp.add` states that for any types `α` and `E` (where `E` is a function from `α` to some type), a nonnegative extended real number `p`, and any two functions `f` and `g` from `α` to `E`, if both `f` and `g` satisfy the `Memℓp` property with respect to `p`, then their sum `(f + g)` also satisfies the `Memℓp` property with respect to the same `p`. In other words, the `Memℓp` property is preserved under addition. In mathematical terms, this theorem says that if `f` and `g` are in the `ℓp` space (a space of sequences for which the `p`-th power of the absolute values is summable when `p` is between 0 and infinity, is finitely supported when `p = 0`, or admits an upper bound when `p = ∞`), then `f + g` is also in the `ℓp` space.

If `f` and `g` are functions from a type `α` to a real or complex vector space, and `f`, `g`, and their sum belong to the `ℓp` space for some nonnegative extended real number `p`, then their sum also belongs to the `ℓp` space.


theorem AddAction.zsmul_mod_period_vadd :
    ∀ {α : Type v} {G : Type u} [inst : AddGroup G] [inst_1 : AddAction G α] (j : ℤ) {g : G} {a : α},
      (j % ↑(AddAction.period g a)) • g +ᵥ a = j • g +ᵥ a :=
  by sorry

This theorem states that for any integer `j`, group `G`, element `g` from `G`, and element `a` from a set `α` acted upon by `G`, if `g` acts on `a` in an additive manner, then adding `g`, scaled by `j` modulo the period of the action of `g` on `a`, to `a` is the same as adding `g`, scaled by `j`, to `a`. In other words, the period of the action of `g` on `a` serves as a modulus for scaling `g` before it is added to `a`.

For any integer `j`, group `G` action on a set `α` with element `g` and `a ∈ α`, if `g` acts additively on `a`, then `a + (j * g) % (period g) = a + j * g`, where `%` denotes modulo the period of `g`'s action on `a`.


theorem FirstOrder.Language.ElementaryEmbedding.map_sentence :
    ∀ {L : FirstOrder.Language} {M : Type u_1} {N : Type u_2} [inst : FirstOrder.Language.Structure L M]
      [inst_1 : FirstOrder.Language.Structure L N],
      FirstOrder.Language.ElementaryEmbedding L M N → ∀ (φ : FirstOrder.Language.Sentence L), M ⊨ φ ↔ N ⊨ φ :=
  by sorry

This theorem states that for any first-order logical language `L`, and any two structures `M` and `N` for `L`, any elementary embedding from `M` to `N` preserves sentences. In other words, for each sentence `φ` in the language `L`, `M` satisfies `φ` if and only if `N` satisfies `φ`. This is a key property of elementary embeddings in model theory, as it shows they preserve the truth of sentences between structures.

For any first-order logical language L and structures M and N with an elementary embedding from M to N, they satisfy the same first-order sentences.


theorem DFinsupp.coe_sub :
    ∀ {ι : Type u} {β : ι → Type v} [inst : (i : ι) → AddGroup (β i)] (g₁ g₂ : Π₀ (i : ι), β i),
      ⇑(g₁ - g₂) = ⇑g₁ - ⇑g₂ :=
  by sorry

This theorem states that for any type `ι`, a family of types `β` indexed by `ι`, and an instance of `AddGroup` for each type in the family, if you have two direct sum representations (`g₁` and `g₂`), then the function of subtracting `g₂` from `g₁` is equal to the function of subtracting the corresponding elements of `g₁` and `g₂`. In other words, it is stating that the operation of subtraction commutes with the function application for direct sum representations in the context of additive groups.

Given types `ι`, a family of AddGroup types `β` indexed by `ι`, and instances of AddGroup for each `β`, for any `g₁`, `g₂` in the direct sum representation of `β i` for each `i ∈ ι`, the function `x ↦ g₁ x - g₂ x` is equal to the function `x ↦ (g₁ x) - (g₂ x)` from `ι` to `β`.


theorem Multiset.toFinset_map :
    ∀ {α : Type u_1} {β : Type u_2} [inst : DecidableEq α] [inst_1 : DecidableEq β] (f : α → β) (m : Multiset α),
      Multiset.toFinset (Multiset.map f m) = Finset.image f (Multiset.toFinset m) :=
  by sorry

The theorem `Multiset.toFinset_map` states that for all types `α` and `β` and for all functions `f` mapping `α` to `β`, as well as for all multisets `m` of type `α`, applying the function `f` to each element of the multiset `m` and then removing duplicates (using `Multiset.map` followed by `Multiset.toFinset`) is equivalent to first removing duplicates from the multiset `m` and then applying the function `f` to each element of the resulting finset (using `Multiset.toFinset` followed by `Finset.image`). This is under the condition that equality is decidable for both `α` and `β`. In other words, the order of removing duplicates (via `toFinset`) and applying the function `f` (via `map` or `image`) doesn't matter.

For all types `α` and `β` with decidable equality, the functions `Multiset.toFinset.image` and `Multiset.map` followed by `Finset.image` are equal for multisets `m` of type `α` and functions `f` from `α` to `β`.


theorem Set.univ_pi_update :
    ∀ {ι : Type u_1} {α : ι → Type u_2} [inst : DecidableEq ι] {β : ι → Type u_4} (i : ι) (f : (j : ι) → α j) (a : α i)
      (t : (j : ι) → α j → Set (β j)),
      (Set.pi Set.univ fun j => t j (Function.update f i a j)) = {x | x i ∈ t i a} ∩ Set.pi {i}ᶜ fun j => t j (f j) :=
  by sorry

This theorem, `Set.univ_pi_update`, states that for any types `ι` and `α : ι → Type`, given a function `f` from `ι` to `α`, an element `i` of `ι`, a value `a` of `α i`, and a family of sets `t` indexed by `ι`, the set of all functions `x` such that `x` equals the updated function at `i` and belongs to the set `t j (Function.update f i a j)` for all `j`, is equal to the intersection of the set `{x | x i ∈ t i a}` and the set of all functions that do not equal `i` and belong to the set `t j (f j)` for all such `j`. Essentially, it describes how updating the value of a function at a particular point affects the corresponding dependent product of sets.

The set of functions updating a given function at a specific index with a new value and belonging to a family of sets for all other indices is equal to the intersection of the set of functions agreeing with the updated value at the index and the set of functions agreeing with the original values at all other indices in the family.


/-- Note: the "obvious" statement `(piCongrLeft P e) f b = f (e.symm b)` doesn't typecheck: the
LHS would have type `P b` while the RHS would have type `P (e (e.symm b))`. This lemma is a way
around it in the case where `b` is of the form `e a`, so we can use `f a` instead of
`f (e.symm (e a))`.  -/
theorem Equiv.piCongrLeft_apply_apply :
    ∀ {β : Sort u_1} {α : Sort u_2} (P : β → Sort w) (e : α ≃ β) (f : (a : α) → P (e a)) (a : α),
      (Equiv.piCongrLeft P e) f (e a) = f a :=
  by sorry

The `Equiv.piCongrLeft_apply_apply` theorem states that for any types `α` and `β`, a function `P` from `β` to some `Sort w`, an equivalence `e` between `α` and `β`, and a dependent function `f` from `α` to `P (e a)`, applying the function given by the left congruence of `P` with respect to `e` to `f` and `e a`, is the same as directly applying `f` to `a`. This resolves a possible dimension mismatch issue where the left-hand side would have type `P b` while the right-hand side would have type `P (e (e.symm b))`.

For any equivalence `e` between types `α` and `β`, function `P : β → Sort w`, and dependent function `f : α → P (e (x))`, the application of `f` to `x` is equal to the application of the left congruence of `P` with respect to `e` to `f`.


theorem MeasureTheory.Measure.le_sum_apply :
    ∀ {α : Type u_1} {ι : Type u_5} {m0 : MeasurableSpace α} (f : ι → MeasureTheory.Measure α) (s : Set α),
      ∑' (i : ι), ↑↑(f i) s ≤ ↑↑(MeasureTheory.Measure.sum f) s :=
  by sorry

The theorem `MeasureTheory.Measure.le_sum_apply` establishes an inequality for the sum of measures in a measure space. Specifically, for any type `α` with the structure of a measurable space, any indexed family of measures `f : ι → MeasureTheory.Measure α`, and any set `s` in `α`, the theorem states that the infinite sum of the measures of `s` according to each measure in the family `f` is less than or equal to the measure of `s` under the sum of the entire family of measures. This is written mathematically as `∑' (i : ι), (f i) s ≤ (MeasureTheory.Measure.sum f) s`.

For any measurable space `α`, any indexed family `f : ι → MeasureTheory.Measure α`, and any set `s` in `α`, the sum of the measures of `s` according to each measure in `f` is less than or equal to the measure of `s` under the sum of the entire family of measures: `∑' (i : ι), (f i) s ≤ (MeasureTheory.Measure.sum f) s`.


theorem PartialEquiv.copy_eq :
    ∀ {α : Type u_1} {β : Type u_2} (e : PartialEquiv α β) (f : α → β) (hf : ↑e = f) (g : β → α)
      (hg : ↑(PartialEquiv.symm e) = g) (s : Set α) (hs : e.source = s) (t : Set β) (ht : e.target = t),
      PartialEquiv.copy e f hf g hg s hs t ht = e :=
  by sorry

This theorem states that for any types `α` and `β`, a partial equivalence `e` from `α` to `β`, a function `f` from `α` to `β` which is equal to the forward function of `e`, a function `g` from `β` to `α` which is equal to the inverse function of `e`, and sets `s` and `t` of `α` and `β` respectively which are equal to the source and target of `e`, creating a copy of the partial equivalence `e` using `f`, `g`, `s`, and `t` produces the same partial equivalence `e`. In other words, copying a partial equivalence in this way results in an identical partial equivalence.

For any partial equivalence `e` from `α` to `β`, its forward function `f`, inverse function `g`, source set `s`, and target set `t`, the copy of `e` created using `f`, `g`, `s`, and `t` is equal to `e`.


theorem AlgebraicGeometry.StructureSheaf.toOpen_eq_const :
    ∀ (R : Type u) [inst : CommRing R] (U : TopologicalSpace.Opens ↑(AlgebraicGeometry.PrimeSpectrum.Top R)) (f : R),
      (AlgebraicGeometry.StructureSheaf.toOpen R U) f = AlgebraicGeometry.StructureSheaf.const R f 1 U ⋯ :=
  by sorry

This theorem states that for any commutative ring `R`, for any open set `U` in the topological space of the prime spectrum of `R`, and for any element `f` of `R`, the operation of applying the structure sheaf of `R` to `f` over the open set `U` is equivalent to taking the constant sheaf associated to `R` with the section `f` and the trivial section 1, restricted to `U`. In other words, the structure sheaf and the constant sheaf give the same result when applied to the same element of `R` over the same open set in the prime spectrum of `R`.

For any commutative ring `R`, any open set `U` in the prime spectrum of `R`, and any element `f` in `R`, the application of the structure sheaf of `R` to `f` over `U` is equal to the restriction of the constant sheaf associated to `R` with section `f` and trivial section 1 to `U`.


theorem Int.isUnit_iff_natAbs_eq : ∀ {n : ℤ}, IsUnit n ↔ Int.natAbs n = 1 := by sorry

This theorem states that for any integer `n`, `n` is a unit in the monoid of integers if and only if the absolute value of `n` is `1`. In more mathematical terms, an integer `n` has a two-sided inverse (making it a unit) if and only if the absolute value of `n` (represented by `Int.natAbs n` in Lean) equals `1`. The two-sided inverse here would be the multiplicative inverse, as the integers form a monoid under multiplication.

An integer `n` is a unit in the monoid of integers if and only if |n| = 1, where |n| represents the absolute value of `n`.


theorem CategoryTheory.ShortComplex.LeftHomologyMapData.map_φH :
    ∀ {C : Type u_1} {D : Type u_2} [inst : CategoryTheory.Category.{u_3, u_1} C]
      [inst_1 : CategoryTheory.Category.{u_4, u_2} D] [inst_2 : CategoryTheory.Limits.HasZeroMorphisms C]
      [inst_3 : CategoryTheory.Limits.HasZeroMorphisms D] {S₁ S₂ : CategoryTheory.ShortComplex C} {φ : S₁ ⟶ S₂}
      {h₁ : CategoryTheory.ShortComplex.LeftHomologyData S₁} {h₂ : CategoryTheory.ShortComplex.LeftHomologyData S₂}
      (ψ : CategoryTheory.ShortComplex.LeftHomologyMapData φ h₁ h₂) (F : CategoryTheory.Functor C D)
      [inst_4 : CategoryTheory.Functor.PreservesZeroMorphisms F]
      [inst_5 : CategoryTheory.ShortComplex.LeftHomologyData.IsPreservedBy h₁ F]
      [inst_6 : CategoryTheory.ShortComplex.LeftHomologyData.IsPreservedBy h₂ F],
      (CategoryTheory.ShortComplex.LeftHomologyMapData.map ψ F).φH = F.map ψ.φH :=
  by sorry

This theorem states that for any categories `C` and `D`, S₁ and S₂ as short complexes of `C`, a morphism `φ` from S₁ to S₂, left homology data `h₁` for S₁ and `h₂` for S₂, a left homology map data `ψ` for `φ`, and a functor `F` from `C` to `D` that preserves zero morphisms and for which the left homology data is preserved by `h₁` and `h₂`, the φH component of the map of the left homology map data `ψ` under the functor `F` is equal to the functor `F` applied to the φH component of `ψ`.

For any categories `C` and `D`, functor `F:` `C` -> `D` preserving zero morphisms and left homology data, and short complexes `S₁` and `S₂` in `C` with morphism `φ:` `S₁` -> `S₂`, the induced map on left homology `F(ψφH) = F(ψ)F(φH)`, where `ψ` is a left homology map data for `φ`.


theorem Int.zpow_log_le_self :
    ∀ {R : Type u_1} [inst : LinearOrderedSemifield R] [inst_1 : FloorSemiring R] {b : ℕ} {r : R},
      1 < b → 0 < r → ↑b ^ Int.log b r ≤ r :=
  by sorry

This theorem states that for any linearly ordered semifield `R` that also forms a floor semiring, and any natural number `b` and real number `r`, if `b` is greater than 1 and `r` is positive, then the greatest power of `b` (given by the integer logarithm function `Int.log`) such that `b ^ log b r` is less than or equal to `r`. In other words, the greatest integer exponent to which `b` can be raised without exceeding `r` is given by the `Int.log` function in this context.

For any linearly ordered semifield `R` that is also a floor semiring, and for any natural number `b` greater than 1 and positive real number `r`, the greatest integer `n` such that `b^n` is less than or equal to `r` is given by `Int.log b r`.