theorem Vector.reverse.proof_1 :
    ∀ {n : ℕ} {α : Type u_1} (v : Vector α n), List.length (List.reverse (Vector.toList v)) = n := by sorry

The theorem `Vector.reverse.proof_1` states that for any natural number `n` and any type `α`, if you have a vector `v` of type `α` with length `n`, then the length of the reversed list obtained from that vector is still `n`. This means that reversing a list does not change its length, even when the list is derived from a vector.

For any natural number `n` and type `α`, the length of the reversed vector of size `n` in type `α` is equal to the original vector's length.


padicValNat.self

/-- If `p ≠ 0` and `p ≠ 1`, then `padicValNat p p` is `1`.  -/
theorem padicValNat.self : ∀ {p : ℕ}, 1 < p → padicValNat p p = 1 := by sorry

The theorem `padicValNat.self` states that for any natural number `p` greater than 1, the `p`-adic valuation of `p` itself is `1`. In other words, if `p` is a natural number that is not `0` or `1`, then the largest natural number `k` such that `p^k` divides `p` is `1`.

For any prime number `p`, the `p`-adic valuation of `p` is equal to 1.


theorem CategoryTheory.ShortComplex.SnakeInput.Hom.ext :
    ∀ {C : Type u_1} {inst : CategoryTheory.Category.{u_2, u_1} C} {inst_1 : CategoryTheory.Abelian C}
      {S₁ S₂ : CategoryTheory.ShortComplex.SnakeInput C} (x y : CategoryTheory.ShortComplex.SnakeInput.Hom S₁ S₂),
      x.f₀ = y.f₀ → x.f₁ = y.f₁ → x.f₂ = y.f₂ → x.f₃ = y.f₃ → x = y :=
  by sorry

This theorem states that in the context of a category `C` that is also Abelian, for any two morphisms `x` and `y` between two objects `S₁` and `S₂` in the `SnakeInput` structure of the `ShortComplex` in the category `C`, if the first four components of `x` and `y` (specifically `x.f₀`, `x.f₁`, `x.f₂`, `x.f₃` and `y.f₀`, `y.f₁`, `y.f₂`, `y.f₃`) are equal, then `x` and `y` are equal.

In an Abelian category `C`, if the first four components of two morphisms `x` and `y` in the `ShortComplex` of objects `S₁` and `S₂` have equal images under the `f₀`, `f₁`, `f₂`, and `f₃` functions, then `x` and `y` are equal.


theorem Real.arcsin_le_iff_le_sin :
    ∀ {x y : ℝ},
      x ∈ Set.Icc (-1) 1 → y ∈ Set.Icc (-(Real.pi / 2)) (Real.pi / 2) → (Real.arcsin x ≤ y ↔ x ≤ Real.sin y) :=
  by sorry

The theorem `Real.arcsin_le_iff_le_sin` states that for any real numbers 'x' and 'y', where 'x' is in the closed interval between -1 and 1 and 'y' is in the closed interval between -π/2 and π/2, the arcsine of 'x' is less than or equal to 'y' if and only if 'x' is less than or equal to the sine of 'y'.

For real numbers x in [-1, 1] and y in [-π/2, π/2], arcsin(x) ≤ y if and only if x ≤ sin(y).


theorem Equiv.Perm.cycleType_def :
    ∀ {α : Type u_1} [inst : Fintype α] [inst_1 : DecidableEq α] (σ : Equiv.Perm α),
      Equiv.Perm.cycleType σ = Multiset.map (Finset.card ∘ Equiv.Perm.support) (Equiv.Perm.cycleFactorsFinset σ).val :=
  by sorry

The theorem `Equiv.Perm.cycleType_def` states that for any type `α` with decidable equality and finiteness, and for any permutation `σ` on `α`, the cycle type of `σ` is defined as the multiset obtained by mapping each element of the finset of cycle factors of `σ` to its cardinality (the number of elements in the set), computed over the set of non-fixed points of the respective cycle. In simple terms, it calculates the size of each cycle in a permutation, and returns a multiset of these sizes.

Given a type `α` with decidable equality and finiteness, and a permutation `σ` on `α`, the cycle type of `σ` is the multiset of sizes of its cycles, where each cycle is considered as a subset of the non-fixed points of the cycle.


theorem Ideal.le_map_of_comap_le_of_surjective :
    ∀ {R : Type u} {S : Type v} {F : Type u_1} [inst : Semiring R] [inst_1 : Semiring S] [inst_2 : FunLike F R S]
      [rc : RingHomClass F R S] (f : F) {I : Ideal R} {K : Ideal S},
      Function.Surjective ⇑f → Ideal.comap f K ≤ I → K ≤ Ideal.map f I :=
  by sorry

The theorem `Ideal.le_map_of_comap_le_of_surjective` states that for all semirings `R` and `S`, and for any function `f` that is fun-like from `R` to `S` (i.e., it behaves like a function and is injective), if `f` is surjective (every element of `S` is the image of some element of `R` under `f`) and the preimage of an ideal `K` in `S` under `f` is a subset of some ideal `I` in `R`, then `K` is a subset of the span of the image of `I` under `f`. In other words, if you take an ideal in `S`, pull it back to `R`, and it fits inside some ideal there, then the original ideal in `S` fits inside the image of that larger ideal from `R` under the map `f`.

If `f` is a surjective, fun-like function from semiring `R` to semiring `S`, and the preimage of ideal `K` in `S` under `f` is contained in ideal `I` in `R`, then `K` is contained in the span of `I`'s image under `f`.


/-- The (open) thickening is an open set.  -/
theorem Metric.isOpen_thickening :
    ∀ {α : Type u} [inst : PseudoEMetricSpace α] {δ : ℝ} {E : Set α}, IsOpen (Metric.thickening δ E) := by sorry

The theorem `Metric.isOpen_thickening` states that for any type `α` which has an instance of a `PseudoEMetricSpace`, and any real number `δ` and set `E`, the `δ`-thickening of `E` is an open set. In mathematical terms, the `δ`-thickening of a set `E` in a pseudo emetric space, denoted as `Metric.thickening δ E`, is the set of points that are at a distance less than `δ` from any point in `E`. This theorem guarantees that such a `δ`-thickening of a set `E` is an open set in the topology induced by this pseudo emetric space.

In a pseudo metric space, the δ-thickening of a set is an open set.


List.Subset.refl

theorem List.Subset.refl : ∀ {α : Type u_1} (l : List α), l ⊆ l := by sorry

This theorem, `List.Subset.refl`, states that for every list `l` of any type `α`, the list `l` is a subset of itself. In other words, each element in list `l` belongs to the list `l`. This is a reflection property of the subset relation for lists in Lean.

For any list `l` of type `α`, `l` is a subset of `l`.


/-- The closed thickening `Metric.cthickening δ E` of a fixed subset `E` is an increasing function
of the thickening radius `δ`.  -/
theorem Metric.cthickening_mono :
    ∀ {α : Type u} [inst : PseudoEMetricSpace α] {δ₁ δ₂ : ℝ},
      δ₁ ≤ δ₂ → ∀ (E : Set α), Metric.cthickening δ₁ E ⊆ Metric.cthickening δ₂ E :=
  by sorry

The theorem `Metric.cthickening_mono` states that in any pseudo emetric space, the closed δ-thickening of a fixed subset is an increasing function of the thickening radius δ. More specifically, for any two real numbers δ₁ and δ₂ such that δ₁ ≤ δ₂, and for any subset E, the closed δ₁-thickening of E is a subset of the closed δ₂-thickening of E. This essentially means that as we increase the value of δ (the thickening radius), the set of points that are within that distance from E also increases.

In any pseudo metric space, the closed δ-thickening of a subset is an increasing function of the radius δ, that is, the closed δ₁-thickening of a subset E is a subset of the closed δ₂-thickening of E for any δ₁ ≤ δ₂.


theorem Order.Ideal.IsProper.ne_top :
    ∀ {P : Type u_1} [inst : LE P] [inst_1 : IsDirected P fun x x_1 => x ≤ x_1] [inst_2 : Nonempty P]
      {I : Order.Ideal P}, Order.Ideal.IsProper I → I ≠ ⊤ :=
  by sorry

This theorem states that for any type `P` that has a less than or equal to (`≤`) operation, is directed (meaning for any two elements `x` and `x_1` in `P`, there exists an element in `P` that is greater than or equal to both `x` and `x_1`), and is nonempty, and for any ideal `I` of `P`, if `I` is a proper ideal of `P`, then `I` cannot be the top element (`⊤`). In other words, a proper ideal in a directed and nonempty partially ordered set is not the greatest ideal.

In a nonempty, directed partially ordered set `P` with a `≤` operation, no proper ideal is the top element.


/-- **Alias** of the forward direction of `isBounded_iff_forall_norm_le'`. -/
theorem Bornology.IsBounded.exists_norm_le' :
    ∀ {E : Type u_6} [inst : SeminormedGroup E] {s : Set E}, Bornology.IsBounded s → ∃ C, ∀ x ∈ s, ‖x‖ ≤ C := by sorry

This theorem, referred to as an alias of the forward direction of `isBounded_iff_forall_norm_le'`, states that for any set `s` of elements of type `E`, where `E` is a seminormed group, if `s` is bounded relative to the ambient bornology on `E`, then there exists a real number `C` such that the norm of each element `x` in `s` is less than or equal to `C`. Here, the norm ‖x‖ is a function that gives the length or size of the vector `x`.

If a set `s` of elements in a seminormed group `E` is bounded, then there exists a real number `C` such that the norm of every element `x` in `s` satisfies `‖x‖ ≤ C`.


theorem Filter.zero_zeroAtFilter :
    ∀ {α : Type u_1} {β : Type u_2} [inst : Zero β] [inst_1 : TopologicalSpace β] (l : Filter α),
      Filter.ZeroAtFilter l 0 :=
  by sorry

This theorem states that for any filter `l` on a type `α` in the context of a topological space on type `β` that has a zero, the constant zero function is `ZeroAtFilter` along `l`. In other words, the constant function that always maps to zero tends towards zero along any filter `l`.

For any filter `l` on type `α` in a topological space with a zero, the constant zero function is the limit of any sequence in `α` along `l`.


theorem iterate_pred_toZ :
    ∀ {ι : Type u_1} [inst : LinearOrder ι] [inst_1 : SuccOrder ι] [inst_2 : IsSuccArchimedean ι] [inst_3 : PredOrder ι]
      {i0 : ι}, ∀ i < i0, Order.pred^[Int.toNat (-toZ i0 i)] i0 = i :=
  by sorry

This theorem, `iterate_pred_toZ`, states that for any type `ι` with a linear order, a successor order, a predecessor order, and satisfying the Archimedean property, given a base element `i0` of `ι`, and any other element `i` that is less than `i0`, applying the predecessor function `Order.pred` to `i0` as many times as the absolute value of the integer returned from the order function `toZ` applied to `i0` and `i`, will yield `i`. In other words, we can reach `i` from `i0` by repeatedly applying the predecessor function the number of times determined by the order between `i0` and `i`.

For any type `ι` with a linear order, successor, predecessor, and the Archimedean property, for all `i0 i` with `i < i0`, we have `i = Order.iterate_pred i0 (toZ (i0 - i))`.


theorem CategoryTheory.CartesianClosed.uncurry_eq :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {A X Y : C}
      [inst_1 : CategoryTheory.Limits.HasFiniteProducts C] [inst_2 : CategoryTheory.Exponentiable A] (g : Y ⟶ A ⟹ X),
      CategoryTheory.CartesianClosed.uncurry g =
        CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.prod.map (CategoryTheory.CategoryStruct.id A) g)
          ((CategoryTheory.exp.ev A).app X) :=
  by sorry

This theorem states that for any category `C` with finite products and any object `A` that is exponentiable, for any morphism `g` from `Y` to the exponential object of `A` and `X`, the uncurrying of `g` is equivalent to the composition of the mapping of the product of `A` and `g` with the application of the evaluation natural transformation at `X`. In other words, it expresses that uncurrying in a cartesian closed category can be seen as a process involving the composition of other morphisms in the category.

In a cartesian closed category with finite products, for any exponentiable object `A` and any morphism `g` from `Y` to `A^X`, the uncurried version of `g` is equal to the composition of `g` with the evaluation at `X` of the product of `A` and `g`.


theorem one_lt_pow' :
    ∀ {M : Type u_3} [inst : Monoid M] [inst_1 : Preorder M]
      [inst_2 : CovariantClass M M (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1] {a : M},
      1 < a → ∀ {k : ℕ}, k ≠ 0 → 1 < a ^ k :=
  by sorry

This theorem states that for any type `M` with a monoid structure and a preorder, and it is a Covariant Class with respect to multiplication and the given preorder, then for any element `a` of `M`, if `a` is greater than one, for any natural number `k` not equal to zero, `a` raised to the power of `k` is also greater than one. This is essentially a property of exponents in ordered monoids, asserting that any number greater than one remains greater than one when raised to a non-zero power.

For any covariant monoid `M` with a preorder, if `a` is an element of `M` greater than one, then `a^k` is also greater than one for any non-zero natural number `k`.


theorem ProbabilityTheory.kernel.indep_iSup_limsup :
    ∀ {α : Type u_1} {Ω : Type u_2} {ι : Type u_3} {_mα : MeasurableSpace α} {m0 : MeasurableSpace Ω}
      {κ : ↥(ProbabilityTheory.kernel α Ω)} {μα : MeasureTheory.Measure α} [inst : ProbabilityTheory.IsMarkovKernel κ]
      {s : ι → MeasurableSpace Ω} {α_1 : Type u_4} {p : Set ι → Prop} {f : Filter ι} {ns : α_1 → Set ι},
      (∀ (n : ι), s n ≤ m0) →
        ProbabilityTheory.kernel.iIndep s κ μα →
          (∀ (t : Set ι), p t → tᶜ ∈ f) →
            Directed (fun x x_1 => x ≤ x_1) ns →
              (∀ (a : α_1), p (ns a)) →
                (∀ (n : ι), ∃ a, n ∈ ns a) → ProbabilityTheory.kernel.Indep (⨆ n, s n) (Filter.limsup s f) κ μα :=
  by sorry

This theorem, `ProbabilityTheory.kernel.indep_iSup_limsup`, in the context of probability theory, states that given a measurable space `α`, a sample space `Ω`, an index set `ι`, a Markov kernel `κ` from `α` to `Ω`, a measure `μα` on `α`, a family of measurable spaces `s` indexed by `ι`, a certain property `p` on sets of `ι`, a filter `f` on `ι`, and a directed family of sets `ns` of `ι`: If for all index `n` the measurable space `s n` is a subset of some base measurable space `m0`, and the family of measurable spaces `s` is independent with respect to kernel `κ` and measure `μα`, and the complement of any set `t` satisfying property `p` belongs to the filter `f`, and all sets in `ns` satisfy property `p`, and for all index `n` there exists a set in `ns` that contains `n`, then the measurable space generated by the supremum of all `s n` and the limit superior (limsup) of `s` along the filter `f` are independent with respect to the kernel `κ` and the measure `μα`.

Given a Markov kernel, measure, independent family of sub-σ-algebras, filter, and property, if the sub-σ-algebras are contained in a base measurable space, satisfy the property, and have the given intersection and limit superior properties, then they are independent with respect to the kernel and measure.


theorem ProbabilityTheory.kernel.comapRight_apply' :
    ∀ {α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {γ : Type u_4}
      {mγ : MeasurableSpace γ} {f : γ → β} (κ : ↥(ProbabilityTheory.kernel α β)) (hf : MeasurableEmbedding f) (a : α)
      {t : Set γ}, MeasurableSet t → ↑↑((ProbabilityTheory.kernel.comapRight κ hf) a) t = ↑↑(κ a) (f '' t) :=
  by sorry

The theorem `ProbabilityTheory.kernel.comapRight_apply'` states that for any types `α`, `β`, and `γ`, given measurable spaces over these types, a function `f` from `γ` to `β`, a kernel `κ` from `α` to `β`, and a measurable embedding `hf` of `f`, for any element `a` of type `α` and any measurable set `t` of type `γ`, the measure of `t` under the measure obtained by comapping the kernel `κ` through `f` at `a` is equal to the measure of the image of `t` under `f` under the measure defined by `κ` at `a`. In mathematical terms, given $\kappa : \alpha \to \beta$, $f : \gamma \to \beta$, and $t \subset \gamma$ such that $t$ is measurable, we have $(\kappa \circ f^{-1})(t) = \kappa(f(t))$.

Given measurable spaces over types `α`, `β`, and `γ`, a measurable embedding `hf` of a function `f` from `γ` to `β`, and a kernel `κ` from `α` to `β`, for any measurable set `t` of type `γ`, the measure of `t` under the comapped kernel `κ ∘ f` at any point `a` of type `α` equals the measure of `f(t)` under `κ` at `a`.


theorem iSup_const_le : ∀ {α : Type u_1} {ι : Sort u_5} [inst : CompleteLattice α] {a : α}, ⨆ x, a ≤ a := by sorry

This theorem states that, for any type α that forms a complete lattice, and for any element a of this type, the supremum of any indexed set whose value is constantly a is less than or equal to a. In other words, for any set where each element is the same element a from a complete lattice, the supremum of that set will always be less than or equal to a.

For any complete lattice α and its element a, the supremum of any indexed set of elements equal to a is less than or equal to a.


theorem MeasureTheory.withDensity_indicator :
    ∀ {α : Type u_1} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} {s : Set α},
      MeasurableSet s → ∀ (f : α → ENNReal), μ.withDensity (Set.indicator s f) = (μ.restrict s).withDensity f :=
  by sorry

The theorem `MeasureTheory.withDensity_indicator` states that for any measurable space `α`, a measure `μ` on that space, and a set `s` in that space, if the set `s` is measurable, then for any function `f` mapping from `α` to the extended nonnegative real numbers, the measure with density defined by the set indicator function of `s` and `f` is equal to the measure restricted to `s` with density `f`. In simpler terms, considering only the measure on the set `s` and ignoring the rest of the space doesn't change the density calculation.

For any measurable space, measure, set, and function, the measure with density defined by the set indicator function of a measurable set and the given function is equal to the measure restricted to that set with the same density function.


theorem Finset.sum_Ico_add' :
    ∀ {α : Type u_1} {M : Type u_2} [inst : AddCommMonoid M] [inst_1 : OrderedCancelAddCommMonoid α]
      [inst_2 : ExistsAddOfLE α] [inst_3 : LocallyFiniteOrder α] (f : α → M) (a b c : α),
      (Finset.sum (Finset.Ico a b) fun x => f (x + c)) = Finset.sum (Finset.Ico (a + c) (b + c)) fun x => f x :=
  by sorry

This theorem states that for any type `α` which has a commutative monoid structure with cancellation, an additive structure with a total order such that addition respects the order, and is locally finite, as well as for any type `M` with a commutative monoid structure, and for any function `f` from `α` to `M`, and for any three elements `a`, `b`, and `c` of type `α`, summing the function `f` applied to each element in the interval from `a` to `b` (inclusive of `a`, exclusive of `b`), each incremented by `c`, gives the same result as summing the function `f` over the interval from `a + c` to `b + c` (inclusive of `a + c`, exclusive of `b + c`). In other words, if you shift the interval for the sum by `c`, you get the same result as if you shifted each term in the sum by `c`.

For any locally finite commutative monoid `α` with cancellation, a total order, and an additive structure where addition respects the order, and any commutative monoid `M` and function `f` from `α` to `M`, the sum of `f` over the interval `[a, b]` is equal to the sum of `f` over the interval `[a + c, b + c]`, for all `a, b, c` in `α`.


theorem IsSelfAdjoint.star_mul_self :
    ∀ {R : Type u_1} [inst : Mul R] [inst_1 : StarMul R] (x : R), IsSelfAdjoint (star x * x) := by sorry

This theorem states that for any type `R` that supports multiplication (`Mul`) and star multiplication (`StarMul`), any element `x` of `R` is self-adjoint when it's the product of its star version and itself. In mathematical terms, if we denote the star of an element `x` as `x*`, then `x* * x` is self-adjoint, that is, `(x* * x)* = x* * x`.

For any type `R` with multiplication and star multiplication, and for any element `x` in `R`, `x* * x` equals the self-adjoint version of `x* * x`, i.e., `(x* * x) = x* * x`.


theorem MeasureTheory.inter_mem_measurableCylinders :
    ∀ {ι : Type u_1} {α : ι → Type u_2} [inst : (i : ι) → MeasurableSpace (α i)] {s t : Set ((i : ι) → α i)},
      s ∈ MeasureTheory.measurableCylinders α →
        t ∈ MeasureTheory.measurableCylinders α → s ∩ t ∈ MeasureTheory.measurableCylinders α :=
  by sorry

This theorem states that for any type `ι` and a function `α` mapping `ι` to some type, given that each element of type `ι` is associated with a measurable space, if two sets `s` and `t` of functions from `ι` to `α i` are both in the set of measurable cylinders of `α`, then their intersection is also in the set of measurable cylinders of `α`. In other words, the intersection of two measurable cylinders is also a measurable cylinder.

Given types `ι` and `α`, if `s` and `t` are measurable cylinders of functions from `ι` to `α`, then their intersection is also a measurable cylinder of functions from `ι` to `α`.


theorem Multiset.le_sum_of_subadditive :
    ∀ {α : Type u_2} {β : Type u_3} [inst : AddCommMonoid α] [inst_1 : OrderedAddCommMonoid β] (f : α → β),
      f 0 = 0 →
        (∀ (a b : α), f (a + b) ≤ f a + f b) →
          ∀ (s : Multiset α), f (Multiset.sum s) ≤ Multiset.sum (Multiset.map f s) :=
  by sorry

This theorem, `Multiset.le_sum_of_subadditive`, states that for any types `α` and `β` where `α` is a commutative additive monoid and `β` is an ordered commutative additive monoid, and given a function `f` from `α` to `β` with the properties: (1) `f` of 0 is 0, and (2) for any `a` and `b` from `α`, `f` of `a + b` is less than or equal to `f` of `a` plus `f` of `b` (i.e., `f` is subadditive), then for any multiset `s` of type `α`, `f` of the sum of `s` is less than or equal to the sum of the multiset obtained by applying `f` to each element of `s`.

In mathematical terms, it says that for a function `f : α → β` that is subadditive (meaning `f(a + b) ≤ f(a) + f(b)`), the value of `f` on the sum of a multiset is less than or equal to the sum of the values of `f` on each element of the multiset.

For any subadditive function `f : α → β` where `α` is a commutative additive monoid and `β` is an ordered commutative additive monoid, the application of `f` to the sum of a multiset `s` in `α` is less than or equal to the sum of the applications of `f` to each element in `s`.


theorem CategoryTheory.Comonad.Coalgebra.Hom.h_assoc :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {G : CategoryTheory.Comonad C}
      {A B : CategoryTheory.Comonad.Coalgebra G} (self : CategoryTheory.Comonad.Coalgebra.Hom A B) {Z : C}
      (h : G.obj B.A ⟶ Z),
      CategoryTheory.CategoryStruct.comp A.a (CategoryTheory.CategoryStruct.comp (G.map self.f) h) =
        CategoryTheory.CategoryStruct.comp self.f (CategoryTheory.CategoryStruct.comp B.a h) :=
  by sorry

The theorem `CategoryTheory.Comonad.Coalgebra.Hom.h_assoc` in Lean 4 states that for any category `C` and comonad `G` on `C`, any morphism `self` from a coalgebra `A` to a coalgebra `B` of the comonad `G`, and any morphism `h` from the object of `B` under the comonad `G` to another object `Z` in `C`, the composition of morphisms in the category follows the associative law. More explicitly, composing the morphism from `A` to `B` with the composition of the morphism induced by `self` under the functor `G` and `h` is the same as composing `self` with the composition of the morphism from `B` to `Z` and `h`. This theorem is a statement about the associativity of morphism composition in a category with a comonad.

For any comonad `G` on a category `C` and coalgebras `A`, `B`, and `Z` with morphisms `self : A --> B`, `h : B --> Z`, the association isomorphism holds: `self * (G h * h) = (G (self * h)) * h`.


Filter.EventuallyEq.neg

theorem Filter.EventuallyEq.neg :
    ∀ {α : Type u} {β : Type v} [inst : Neg β] {f g : α → β} {l : Filter α},
      f =ᶠ[l] g → (fun x => -f x) =ᶠ[l] fun x => -g x :=
  by sorry

This theorem states that for any types `α` and `β` and any instances of negation on `β`, given two functions `f` and `g` from `α` to `β` and a filter `l` on `α`, if `f` is eventually equal to `g` at filter `l`, then the function that maps each element of `α` to the negative of its image under `f` is eventually equal at filter `l` to the function that maps each element of `α` to the negative of its image under `g`. In other words, if `f` and `g` are nearly the same when observed through filter `l`, then the same applies to their negations.

Given functions `f` and `g` from type `α` to negatable type `β`, and filter `l` on `α` such that `f` and `g` are eventual equal at `l`, their negations are also eventual equal at `l`.


theorem WfDvdMonoid.induction_on_irreducible :
    ∀ {α : Type u_1} [inst : CommMonoidWithZero α] [inst_1 : WfDvdMonoid α] {P : α → Prop} (a : α),
      P 0 → (∀ (u : α), IsUnit u → P u) → (∀ (a i : α), a ≠ 0 → Irreducible i → P a → P (i * a)) → P a :=
  by sorry

This theorem, `WfDvdMonoid.induction_on_irreducible`, is a principle of induction for a well-founded (meaning there are no infinite descending chains) divisibility monoid with zero. Given a type `α` which is equipped with a commutative monoid structure with zero element and is a well-founded divisibility monoid, this theorem states that for any property `P` and any element `a` of `α`, if `P` holds for 0, and if `P` holds for any unit `u` of `α`, and if for any non-zero `a` and any irreducible `i` of `α`, `P` holding for `a` implies that `P` holds for the product of `i` and `a`, then `P` holds for `a`. In other words, it allows one to prove a property about all elements of a well-founded divisibility monoid with zero by considering the cases where the element is 0, a unit, or a product of an irreducible element and another element for which the property holds.

Given a well-founded commutative monoid with zero and unit elements, if a property holds for 0 and units, and if it is preserved under multiplication by irreducible elements, then the property holds for all elements.


theorem MvPolynomial.vars_C :
    ∀ {R : Type u} {σ : Type u_1} {r : R} [inst : CommSemiring R], MvPolynomial.vars (MvPolynomial.C r) = ∅ := by sorry

The theorem `MvPolynomial.vars_C` asserts that for any type `R`, any type `σ`, and any element `r` of `R`, under the condition that `R` is a commutative semiring, the set of variables appearing in the constant multivariate polynomial with value `r` (`MvPolynomial.C r`) is the empty set. In other words, a constant polynomial doesn't contain any variables.

For any commutative semiring `R`, the constant multivariate polynomial `MvPolynomial.C r` over `R` has an empty set of variables.


theorem List.sublists'_eq_sublists :
    ∀ {α : Type u} (l : List α), List.sublists' l = List.map List.reverse (List.sublists (List.reverse l)) := by sorry

This theorem states that for any list of type `α`, the list of all non-contiguous sublists generated by `sublists'` function is equivalent to the list of all reversed non-contiguous sublists generated by the `sublists` function applied to the reversed original list. In other words, if we reverse each non-contiguous sublist of the reversed original list, and collect these sublists using the `sublists` function, we will get the same result as if we had used the `sublists'` function on the original list.

For any list `xs` of type `α`, the sets of non-contiguous sublists of `xs` and the reversed non-contiguous sublists of the reversed list `list.reverse xs` are equal.


theorem IsLocalizedModule.mk'_one :
    ∀ {R : Type u_1} [inst : CommSemiring R] (S : Submonoid R) {M : Type u_2} {M' : Type u_3} [inst_1 : AddCommMonoid M]
      [inst_2 : AddCommMonoid M'] [inst_3 : Module R M] [inst_4 : Module R M'] (f : M →ₗ[R] M')
      [inst_5 : IsLocalizedModule S f] (m : M), IsLocalizedModule.mk' f m 1 = f m :=
  by sorry

The `IsLocalizedModule.mk'_one` theorem states that for any commutative semiring `R`, a submonoid `S` of `R`, `M` and `M'` as types with `M` and `M'` being Additive Commutative Monoids and `R`-modules, and a linear map `f` from `M` to `M'` which is a localized module with respect to `S`, when the `mk'` function is applied on `f` with an element `m` from `M` and `1` from the submonoid `S`, the result is equal to applying the function `f` on the element `m`. In mathematical terms, it says that for a certain localization map `f`, `f(m) = m/1`.

For a localized module homomorphism `f` from an `R`-module `M` to an `R`-module `M'` over a commutative semiring `R`, with respect to a submonoid `S`, the localization `f(m)/1` equals `f(m)` for all `m` in `M`.


RingCon.trans

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

This theorem states that for any type `R` that has addition and multiplication operations (i.e., `R` is a ring), and any ring congruence relation `c` on `R`, if `x`, `y`, and `z` are elements of `R` such that `x` is related to `y` by `c` and `y` is related to `z` by `c`, then `x` is also related to `z` by `c`. In other words, the given ring congruence relation `c` is transitive.

If `R` is a ring, and `c` is a ring congruence relation on `R`, then for all `x`, `y`, and `z` in `R` with `x ≡ y (mod c)` and `y ≡ z (mod c)`, it follows that `x ≡ z (mod c)`.


Inducing.continuousAdd

theorem Inducing.continuousAdd :
    ∀ {M : Type u_6} {N : Type u_7} {F : Type u_8} [inst : Add M] [inst_1 : Add N] [inst_2 : FunLike F M N]
      [inst_3 : AddHomClass F M N] [inst_4 : TopologicalSpace M] [inst_5 : TopologicalSpace N]
      [inst_6 : ContinuousAdd N] (f : F), Inducing ⇑f → ContinuousAdd M :=
  by sorry

The theorem `Inducing.continuousAdd` states that for any types `M`, `N`, and `F`, given that `M` and `N` are equipped with addition operations, `F` is a function-like object from `M` to `N`, `F` is also an additive homomorphism between `M` and `N`, `M` and `N` are both topological spaces, and `N` supports continuous addition, then for any object `f` of type `F` that induces the topology of `M` from `N`, it follows that `M` also supports continuous addition. In other words, the `Inducing.continuousAdd` theorem captures the idea that if we have a function that is both a homomorphism and induces the topology of its domain from its codomain, and if addition is continuous in the codomain, then addition is also continuous in the domain.

If `F` is a continuous, additive homomorphism from a topological space `M` to another topological space `N` with continuous addition, then `M` also has continuous addition.


theorem Equiv.Perm.ext_iff : ∀ {α : Sort u} {σ τ : Equiv.Perm α}, σ = τ ↔ ∀ (x : α), σ x = τ x := by sorry

The theorem `Equiv.Perm.ext_iff` states that for any type `α` and any two permutations `σ` and `τ` of `α`, `σ` is equal to `τ` if and only if they are equal at each element of `α`. In other words, two permutations are considered identical if they map every element of the type to the same element.

Two permutations of type `α` are equal if and only if they map each element to the same image.


theorem CategoryTheory.Limits.image.preComp_ι :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} (f : X ⟶ Y) {Z : C} (g : Y ⟶ Z)
      [inst_1 : CategoryTheory.Limits.HasImage g]
      [inst_2 : CategoryTheory.Limits.HasImage (CategoryTheory.CategoryStruct.comp f g)],
      CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.image.preComp f g) (CategoryTheory.Limits.image.ι g) =
        CategoryTheory.Limits.image.ι (CategoryTheory.CategoryStruct.comp f g) :=
  by sorry

The theorem `CategoryTheory.Limits.image.preComp_ι` states that in any category `C`, for any objects `X, Y, Z` in `C` and morphisms `f : X ⟶ Y` and `g : Y ⟶ Z`, if `g` and the composition `f ≫ g` have images, then the composition of the pre-image morphism of `f` and `g` with the inclusion of the image of `g` into `Z` is equal to the inclusion of the image of the composition `f ≫ g` into `Z`. In more mathematical terms, it says that in the context of category theory, image inclusion respects the composition of morphisms.

In any category, given morphisms $f : X \to Y$, $g : Y \to Z$, and objects $I_g$ and $I_{g \circ f}$ denoting the images of $g$ and $g \circ f$ respectively, we have $I_g \circ \text{pre-img}(f) = I_{g \circ f}$.


theorem iInf_prod :
    ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_4} [inst : CompleteLattice α] {f : β × γ → α},
      ⨅ x, f x = ⨅ i, ⨅ j, f (i, j) :=
  by sorry

This theorem states that for any types `α`, `β` and `γ` where `α` is a complete lattice, and a function `f` from the product of `β` and `γ` to `α`, the infimum (greatest lower bound) of `f` over all pairs `(i, j)` is the same as the infimum of `f` over all `x` (where `x` is a pair from `β × γ`). In other words, it's saying that the process of finding the infimum does not change if we break the pair `(i, j)` into its individual components and find the infimum over each component separately.

For any complete lattice `α`, and a function `f` from the product `β × γ` to `α`, the infimum of `f` over all pairs `(i, j)` is equal to the infimum of `f` over all `x` in `β × γ`.


theorem WellFounded.wellFounded_iff_has_min :
    ∀ {α : Type u_1} {r : α → α → Prop}, WellFounded r ↔ ∀ (s : Set α), Set.Nonempty s → ∃ m ∈ s, ∀ x ∈ s, ¬r x m := by
  sorry

The theorem `WellFounded.wellFounded_iff_has_min` states that for any type `α` and relation `r`, the relation `r` is well-founded if and only if for every non-empty set `s` of type `α`, there exists an element `m` in `s` such that there is no `x` in `s` for which the relation `r` holds between `x` and `m`. In simpler terms, a relation is well-founded if every non-empty set has a minimal element under that relation, where a minimal element is one which is not related by `r` to any other element in the set.

A relation over a type is well-founded if and only if every non-empty subset has a minimal element with respect to that relation.


theorem Set.bounded_gt_Ioi :
    ∀ {α : Type u_1} [inst : Preorder α] (a : α), Set.Bounded (fun x x_1 => x > x_1) (Set.Ioi a) := by sorry

This theorem states that for any type `α` with a preorder structure and for any element `a` of type `α`, the set of all elements greater than `a` (denoted by `Set.Ioi a`) is a bounded set with respect to the relation `x > x_1`. Here, a set is said to be bounded if there exists an element such that every element in the set has this relation with the specific element, and `Set.Ioi a` is the set of elements strictly greater than `a`.

For any preorder type `α` and element `a` in `α`, the set of elements strictly greater than `a` (`Set.Ioi a`) is a bounded set with respect to the preorder relation.


theorem Filter.Tendsto.isBoundedUnder_ge :
    ∀ {ι : Type u_1} {α : Type u_2} [inst : Preorder α] [inst_1 : TopologicalSpace α] [inst_2 : BoundedGENhdsClass α]
      {f : Filter ι} {u : ι → α} {a : α},
      Filter.Tendsto u f (nhds a) → Filter.IsBoundedUnder (fun x x_1 => x ≥ x_1) f u :=
  by sorry

This theorem states that for any types `ι` and `α`, given a preorder on `α`, a topology on `α`, and a class of bounded generalized neighborhoods on `α`, if `f` is a filter on `ι` and `u` is a function from `ι` to `α` that tends to `a` under the filter `f` (i.e., `Filter.Tendsto u f (nhds a)`), then the image of the filter `f` under `u` is eventually bounded from below. In other words, there exists some `α` that is less than or equal to all elements in the image of `f` under `u` after a certain point.

Given a preorder on `α`, a topology on `α`, and a class of bounded neighborhoods, if a filter `f` on `ι` tends to a point `a` in `α` under a function `u` from `ι` to `α`, then there exists a bound `b` in `α` such that for all `i` in `ι`, `u(i)` is bounded below by `b` when `i` belongs to the filter `f`.


theorem Mathlib.Order.SupClosed._auxLemma.21 :
    ∀ {α : Type u_2} [inst : SemilatticeSup α] {s : Set α}, (supClosure s = s) = SupClosed s := by sorry

This theorem states that for any type `α` that forms a join-semilattice (denoted `SemilatticeSup α`), and any set `s` of elements of type `α`, the set `s` being equal to its sup-closure is equivalent to the set `s` being sup-closed. In other words, a set `s` is sup-closed (i.e., for any two elements `a` and `b` in `s`, their join, or supremum, `a ⊔ b` is also in `s`) if and only if `s` equals its sup-closure (the smallest sup-closed set that contains `s`).

For any join-semilattice type `α`, a set `s` of elements is sup-closed if and only if it equals its sup-closure, i.e., the smallest join-closed set containing `s`.


theorem Mathlib.Order.SupClosed._auxLemma.36 :
    ∀ {α : Type u_2} [inst : Lattice α] {s : Set α}, (latticeClosure s = s) = IsSublattice s := by sorry

This theorem states that for any type `α` which forms a lattice, and for any set `s` of elements of type `α`, the lattice closure of `s` is equal to `s` if and only if `s` is itself a sublattice. In other words, in the context of a lattice, a set is closed under the join operation (i.e., it contains the join of any of its elements) if and only if it forms a sublattice.

For any lattice `α` and subset `s` of `α`, `s` is the lattice closure of `s` if and only if `s` is a sublattice.


theorem Mathlib.Order.SupClosed._auxLemma.32 :
    ∀ {α : Type u_2} [inst : SemilatticeInf α] {s : Set α}, (infClosure s = s) = InfClosed s := by sorry

This theorem states that for any type `α` that has `SemilatticeInf` structure and any set `s` of `α`, the set `s` is closed under the `infClosure` operation if and only if it is `InfClosed`. In other words, a set `s` is equivalent to its "inf-closure" (i.e., the smallest set containing `s` that is closed under taking infimums) if and only if for every pair of elements `a` and `b` in `s`, their infimum `a ⊓ b` is also in `s`. This characterizes the closure operation in a join-semilattice by the property of being closed under infimums.

A set of a type with `SemilatticeInf` structure is equal to its inf-closure if and only if it is closed under taking infimums.


theorem List.rotate_eq_drop_append_take_mod :
    ∀ {α : Type u} {l : List α} {n : ℕ},
      List.rotate l n = List.drop (n % List.length l) l ++ List.take (n % List.length l) l :=
  by sorry

The theorem `List.rotate_eq_drop_append_take_mod` states that for any list `l` of elements of an arbitrary type `α` and any natural number `n`, rotating `l` `n` times to the left is equivalent to removing the first `n` mod `List.length l` elements from `l` and appending them to the end of `l`. In other words, rotating a list is the same as slicing it at a particular index `(n mod List.length l)`, and then swapping the two halves.

For any list `l` of length `n` and natural number `k`, rotating `l` `k` times to the left is equivalent to taking the sublist from index `(k mod n)` to the end of `l`, removing it, and then appending it to the beginning of the sublist from the start of `l` to index `(k mod n)`.


theorem MulAction.mem_orbit :
    ∀ {M : Type u} [inst : Monoid M] {α : Type v} [inst_1 : MulAction M α] (a : α) (m : M),
      m • a ∈ MulAction.orbit M a :=
  by sorry

This theorem states that for any monoid `M` and any type `α` with a `MulAction` of `M` on `α`, for any element `a` of type `α` and any element `m` of the monoid `M`, the action of `m` on `a`, denoted by `m • a`, is an element of the orbit of `a` under the action of `M`. In terms of group theory, this means that the result of the group action of any element of the group on a specific element is always within the set of elements reachable by the group action on that element.

For any monoid action on a type, the image of an element under the action of any element in the monoid lies in the orbit of that element.


theorem IsUpperSet.mul_left :
    ∀ {α : Type u_1} [inst : OrderedCommGroup α] {s t : Set α}, IsUpperSet t → IsUpperSet (s * t) := by sorry

The theorem `IsUpperSet.mul_left` states that for any ordered commutative group `α` and any two sets `s` and `t` within `α`, if `t` is an upper set, then the product of `s` and `t` (denoted as `s * t`) is also an upper set. An upper set, in this context, is a set such that if any element `b` is greater than an element `a` in the set, then `b` is also in the set. In other words, once an element is in an upper set, all elements greater than it are also in the set. So, the theorem is about the preservation of the upper set property under multiplication with any other set in an ordered commutative group.

If `α` is an ordered commutative group and `t` is an upper set in `α`, then the product `s * t` is an upper set for any set `s` in `α`.


theorem Equiv.swap_swap :
    ∀ {α : Sort u_1} [inst : DecidableEq α] (a b : α), (Equiv.swap a b).trans (Equiv.swap a b) = Equiv.refl α := by
  sorry

The theorem `Equiv.swap_swap` states that for any type `α` with decidable equality and any two elements `a` and `b` of `α`, the composition (or "trans", short for "transitive") of the permutation that swaps `a` and `b` with itself is equivalent to the identity permutation on `α`. In other words, if we swap `a` and `b` twice, we get back to the original arrangement, which is the same as doing nothing (the identity operation).

For any type `α` with decidable equality and any two elements `a` and `b` in `α`, the swap permutation of `a` and `b` is idempotent.


/-- An intermediate field of `E / F` is contained in the relative perfect closure of `F` in `E`
if and only if it is purely inseparable over `F`.  -/
theorem le_perfectClosure_iff :
    ∀ (F : Type u) (E : Type v) [inst : Field F] [inst_1 : Field E] [inst_2 : Algebra F E] (L : IntermediateField F E),
      L ≤ perfectClosure F E ↔ IsPurelyInseparable F ↥L :=
  by sorry

This theorem states that for any intermediate field `L` of a field extension `E / F`, `L` is contained in the relative perfect closure of `F` in `E` if and only if it is purely inseparable over `F`. In the field theory, the perfect closure of a field `F` in an extension `E` is the largest subfield of `E` which is perfect and contains `F`. A field extension is called purely inseparable if every element in the extension field is purely inseparable over the base field.

A field extension `L` of `F` in `E` is contained in the relative perfect closure of `F` in `E` if and only if it is purely inseparable over `F`.


theorem AdjoinRoot.liftHom_root :
    ∀ {R : Type u} {S : Type v} [inst : CommRing R] (f : Polynomial R) [inst_1 : CommRing S] {a : S}
      [inst_2 : Algebra R S] (hfx : (Polynomial.aeval a) f = 0), (AdjoinRoot.liftHom f a hfx) (AdjoinRoot.root f) = a :=
  by sorry

The theorem `AdjoinRoot.liftHom_root` states that for any commutative ring `R`, polynomial `f` over `R`, commutative ring `S`, and element `a` of `S` such that `a` is a root of `f` (i.e., `Polynomial.aeval a f = 0`), the algebra homomorphism from `AdjoinRoot f` to `S` created by `AdjoinRoot.liftHom` maps the adjoined root of `f` (i.e., `AdjoinRoot.root f`) to `a`. This essentially states that the mapped value of the adjoined root under the created homomorphism is indeed the root `a` of the polynomial in the ring `S`.

For any commutative rings R and S, polynomial f over R, and element a of S that is a root of f, the algebra homomorphism from AdjoinRoot f to S, created by AdjoinRoot.liftHom, maps the adjoined root of f to a.


/-- Symmetric statement to `Filter.map₂_map_left_comm`.  -/
theorem Filter.map_map₂_distrib_left :
    ∀ {α : Type u_1} {α' : Type u_2} {β : Type u_3} {γ : Type u_5} {δ : Type u_7} {m : α → β → γ} {f : Filter α}
      {g : Filter β} {n : γ → δ} {m' : α' → β → δ} {n' : α → α'},
      (∀ (a : α) (b : β), n (m a b) = m' (n' a) b) →
        Filter.map n (Filter.map₂ m f g) = Filter.map₂ m' (Filter.map n' f) g :=
  by sorry

This theorem, named `Filter.map_map₂_distrib_left`, states that for all types `α`, `α'`, `β`, `γ`, and `δ`, and for all binary function `m : α → β → γ`, filters `f : Filter α` and `g : Filter β`, function `n : γ → δ`, binary function `m' : α' → β → δ`, and function `n' : α → α'`, if for all `a : α` and `b : β`, the function `n` applied to the result of `m` applied to `a` and `b` is equivalent to `m'` applied to `n'` of `a` and `b`, then the map of `n` over the map₂ of `m`, `f` and `g` equals the map₂ of `m'` over the map of `n'` on `f` and `g`.

In other words, it states a certain kind of commutativity and distributivity of the map and map₂ operations over filters, under the given function transformation conditions.

If for all `a : α` and `b : β`, `n (m a b) = m' (n' a) (n' b)`, then `(Map.map n).map₂ (Map₂.map₂ m f g) = Map₂.map₂ (λ a b, m' (n' a) (n' b)) (Map.map (n') f) (Map.map (n') g)`.


theorem Subgroup.range_mem_rightTransversals :
    ∀ {G : Type u_1} [inst : Group G] {H : Subgroup G} {f : Quotient (QuotientGroup.rightRel H) → G},
      (∀ (q : Quotient (QuotientGroup.rightRel H)), Quotient.mk'' (f q) = q) →
        Set.range f ∈ Subgroup.rightTransversals ↑H :=
  by sorry

This theorem states that for any group `G` and any subgroup `H` within `G`, given a function `f` that maps from the quotient of `G` by the right coset equivalence relation of `H` to `G`, if it holds that for all quotients, the equivalence class of the function's output for the quotient under the setoid `s₁` is equal to the original quotient, then the range of the function `f` is a right transversal of `H` in `G`. In other words, it is a set that complements `H` to form `G` under group operation.

If a function from the quotient of a group by the right coset equivalence relation of a subgroup to the group satisfies the property that the equivalence class of the output for each quotient equals the original quotient under a given setoid, then the range of the function is a right transversal of the subgroup in the group.


theorem QuadraticForm.coeFn_smul :
    ∀ {S : Type u_1} {R : Type u_3} {M : Type u_4} [inst : CommSemiring R] [inst_1 : AddCommMonoid M]
      [inst_2 : Module R M] [inst_3 : Monoid S] [inst_4 : DistribMulAction S R] [inst_5 : SMulCommClass S R R] (a : S)
      (Q : QuadraticForm R M), ⇑(a • Q) = a • ⇑Q :=
  by sorry

This theorem states that for any commutative semiring `R`, additive commutative monoid `M`, and monoid `S`, given a `QuadraticForm` `Q` over `R` and `M`, and an element `a` of `S`, the action of the scalar `a` on the quadratic form (notated `a • Q`) is equivalent to the action of the scalar on the function given by the quadratic form (notated `a • ⇑Q`). Here the module structure over `M` and `R` is used along with the distributive action of `S` on `R`, and the commutative interaction between the scalar multiplication of `S` and `R` is also taken into account.

For any commutative semiring R, additive commutative monoid M, and monoid S, the scalar action on a QuadraticForm Q over R and M, and an element a of S, is equivalent to the scalar action on the function represented by Q.


theorem SetTheory.PGame.powHalf_succ_lt_powHalf :
    ∀ (n : ℕ), SetTheory.PGame.powHalf (n + 1) < SetTheory.PGame.powHalf n := by sorry

This theorem states that for every non-negative integer 'n', the 'n+1'-th power of one half is less than the 'n'-th power of one half in the context of set theory games. In other words, it's an assertion about the monotonically decreasing nature of the function f(x)=0.5^x in the domain of non-negative integers.

For all non-negative integers n, 0.5^(n+1) < 0.5^n.


theorem CategoryTheory.ShortComplex.RightHomologyMapData.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.RightHomologyData S₁} {h₂ : CategoryTheory.ShortComplex.RightHomologyData S₂}
      (ψ : CategoryTheory.ShortComplex.RightHomologyMapData φ h₁ h₂) (F : CategoryTheory.Functor C D)
      [inst_4 : CategoryTheory.Functor.PreservesZeroMorphisms F]
      [inst_5 : CategoryTheory.ShortComplex.RightHomologyData.IsPreservedBy h₁ F]
      [inst_6 : CategoryTheory.ShortComplex.RightHomologyData.IsPreservedBy h₂ F],
      (CategoryTheory.ShortComplex.RightHomologyMapData.map ψ F).φH = F.map ψ.φH :=
  by sorry

This theorem states that for any two short complexes `S₁` and `S₂` in categories `C` and `D` respectively, and a morphism `φ` from `S₁` to `S₂`, if we have right homology data `h₁` and `h₂` for `S₁` and `S₂`, and a right homology map data `ψ` that links `φ`, `h₁`, and `h₂`, then if we have a functor `F` from `C` to `D` that preserves zero morphisms and preserves the right homology data `h₁` and `h₂`, the right homology map data `ψ` produced by mapping `F` over `ψ` using `CategoryTheory.ShortComplex.RightHomologyMapData.map` has its `φH` component equal to the result of mapping `F` over the `φH` component of `ψ`.

Given any two short complexes `S₁` and `S₂`, a morphism `φ: S₁ → S₂`, right homology data `h₁`, `h₂`, and a right homology map data `ψ` connecting `φ` and `h₁`, `h₂`, if `F : C → D` is a functor preserving zero morphisms and `h₁`, `h₂`, then `F.map (ψ)`.`φH` equals `F.(ψ.φH)`.


theorem ENNReal.toReal_div : ∀ (a b : ENNReal), (a / b).toReal = a.toReal / b.toReal := by sorry

This theorem states that for all elements 'a' and 'b' of the extended nonnegative real numbers (denoted as [0, ∞]), the real number equivalent of the quotient of 'a' and 'b' (a divided by b) is equal to the quotient of the real number equivalents of 'a' and 'b'. In other words, converting the quotient of 'a' and 'b' to a real number yields the same result as first converting 'a' and 'b' to real numbers and then taking their quotient.

For all 'a' and 'b' in the extended nonnegative real numbers, [a/b] = (mêmea : ℝ) / (mêmeb : ℝ), where [a] and [b] denote the real number equivalents of 'a' and 'b' respectively.


theorem MeasureTheory.integral_dirac' :
    ∀ {α : Type u_1} {E : Type u_2} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [hE : CompleteSpace E]
      [inst_2 : MeasurableSpace α] (f : α → E) (a : α),
      MeasureTheory.StronglyMeasurable f → ∫ (x : α), f x ∂MeasureTheory.Measure.dirac a = f a :=
  by sorry

The theorem `MeasureTheory.integral_dirac'` states that for any given type `α` and `E`, where `E` is a normed additive commutative group and a normed space over the reals `ℝ`, and where `E` is a complete space, and `α` is a measurable space, if we have a function `f` from `α` to `E` that is strongly measurable (that is, it is the limit of a sequence of simple functions), then the integral of `f` with respect to the Dirac measure at any point `a` in `α` is equal to the value of `f` at `a`. In other words, the integral of a strongly measurable function over the Dirac measure centered at a point is simply the value of the function at that point.

If `α` is a measurable space, `E` is a complete, normed additive commutative group and normed space over the reals, `f: α → E` is strongly measurable, then ∫₡α(ds) f(s) = f(s) for all s in α. (The integral represents the integral of `f` with respect to the Dirac measure at point `s`.)


theorem MeasureTheory.Martingale.supermartingale :
    ∀ {Ω : Type u_1} {E : Type u_2} {ι : Type u_3} [inst : Preorder ι] {m0 : MeasurableSpace Ω}
      {μ : MeasureTheory.Measure Ω} [inst_1 : NormedAddCommGroup E] [inst_2 : NormedSpace ℝ E]
      [inst_3 : CompleteSpace E] {f : ι → Ω → E} {ℱ : MeasureTheory.Filtration ι m0} [inst_4 : Preorder E],
      MeasureTheory.Martingale f ℱ μ → MeasureTheory.Supermartingale f ℱ μ :=
  by sorry

This theorem states that for any martingale `f`, given the conditions of a set `Ω`, a normed additive commutative group `E`, a complete space `E`, a preorder on `ι`, a filtration `ℱ` on `ι`, a measure `μ` on `Ω`, and a preorder on `E`, the martingale `f` is also a supermartingale. Here, Ω is the set of possible outcomes, E is the set of real numbers (or a subset of the real numbers) representing the possible values of the martingale, and ι is an indexing type representing time in the martingale process. A martingale is a model of a fair game where knowledge of past events never helps predict the mean of the future winnings, and a supermartingale is a model where the expected value of the future values is less than or equal to the current value.

For any martingale `f` on a complete space `(Ω, ℱ, μ)` with values in a normed additive commutative group `E` and a preorder, `f` is also a supermartingale.


theorem FirstOrder.Language.Substructure.map_le_iff_le_comap :
    ∀ {L : FirstOrder.Language} {M : Type w} {N : Type u_1} [inst : FirstOrder.Language.Structure L M]
      [inst_1 : FirstOrder.Language.Structure L N] {f : FirstOrder.Language.Hom L M N}
      {S : FirstOrder.Language.Substructure L M} {T : FirstOrder.Language.Substructure L N},
      FirstOrder.Language.Substructure.map f S ≤ T ↔ S ≤ FirstOrder.Language.Substructure.comap f T :=
  by sorry

The theorem `FirstOrder.Language.Substructure.map_le_iff_le_comap` states that for any first-order languages `L`, structures `M` and `N`, a homomorphism `f` from `M` to `N`, and substructures `S` of `M` and `T` of `N`, the image of `S` under `f` is a substructure of `T` if and only if `S` is a substructure of the preimage of `T` under `f`. In other words, it establishes a correspondence between the substructures in the domain that map into a given substructure in the codomain, and the substructures in the codomain that are mapped into by a given substructure in the domain, via a given homomorphism.

For first-order languages L, structures M and N, a homomorphism f from M to N, and substructures S of M and T of N, S is a substructure of T if and only if the image of S under f is a substructure of T.


/-- If `C` is filtered, then we can give an explicit condition for a functor `F : C ⥤ D` to
be final.  -/
theorem CategoryTheory.Functor.final_iff_of_isFiltered :
    ∀ {C : Type v₁} [inst : CategoryTheory.Category.{v₁, v₁} C] {D : Type u₂}
      [inst_1 : CategoryTheory.Category.{v₁, u₂} D] (F : CategoryTheory.Functor C D)
      [inst_2 : CategoryTheory.IsFilteredOrEmpty C],
      CategoryTheory.Functor.Final F ↔
        (∀ (d : D), ∃ c, Nonempty (d ⟶ F.obj c)) ∧
          ∀ {d : D} {c : C} (s s' : d ⟶ F.obj c),
            ∃ c' t, CategoryTheory.CategoryStruct.comp s (F.map t) = CategoryTheory.CategoryStruct.comp s' (F.map t) :=
  by sorry

The theorem `CategoryTheory.Functor.final_iff_of_isFiltered` states that given a category `C` that is filtered or empty, and another category `D`, along with a functor `F` from `C` to `D`, the functor `F` is final if and only if the following conditions hold:

1. For every object `d` in `D`, there exists an object `c` in `C` such that there is at least one morphism from `d` to `F.obj c`, and
2. For any two morphisms `s` and `s'` from an object `d` in `D` to `F.obj c` for some object `c` in `C`, there exists an object `c'` in `C` and a morphism `t` from `c` to `c'` such that composing `s` with `F.map t` is equal to composing `s'` with `F.map t`.

Here, `F.obj c` denotes the object obtained by applying the functor `F` to the object `c`, and `F.map t` denotes the morphism obtained by applying the functor `F` to the morphism `t`. The term `CategoryTheory.CategoryStruct.comp` denotes the composition of morphisms in a category.

A functor from a filtered or empty category to another category is final if and only if for every object in the target category, there exists an object in the source category with at least one morphism to it and any two such morphisms can be connected by a morphism in the source category whose image under the functor equals their composition.


theorem Relation.TransGen.head'_iff :
    ∀ {α : Type u_1} {r : α → α → Prop} {a c : α}, Relation.TransGen r a c ↔ ∃ b, r a b ∧ Relation.ReflTransGen r b c :=
  by sorry

This theorem asserts that for any type `α` and a binary relation `r` on `α`, the transitive closure of `r` from `a` to `c` (denoted `Relation.TransGen r a c`) is equivalent to the existence of an intermediate element `b` such that `r a b` and the reflexive transitive closure of `r` from `b` to `c` (denoted `Relation.ReflTransGen r b c`). In other words, if there is a transitive relationship from `a` to `c`, there exists some `b` such that `a` is directly related to `b`, and `b` is either equal to `c` or leads to `c` through a series of steps via `r`.

For any type `α` and binary relation `r` on `α`, the transitive closure of `r` from `a` to `c` equals the existence of an intermediate element `b` such that `r a b` and `r`'s reflexive transitive closure from `b` to `c` holds.


theorem Order.succ_injective :
    ∀ {α : Type u_1} [inst : PartialOrder α] [inst_1 : SuccOrder α] [inst_2 : NoMaxOrder α],
      Function.Injective Order.succ :=
  by sorry

The theorem `Order.succ_injective` states that for any type `α` equipped with a partial order, a successor order, and without a maximum element (`NoMaxOrder α`), the function `Order.succ`, which assigns to each element its successor, is injective. In other words, if `Order.succ a = Order.succ b` for some `a` and `b` in `α`, then `a = b`. This essentially means that different elements in `α` have different successors in the context of the given orderings.

In a partially ordered type without a maximum element, the successor function is injective.


theorem ZNum.zneg_zneg : ∀ (n : ZNum), - -n = n := by sorry

This theorem states that for any integer number `n` (represented as `ZNum` in Lean), the double negation of `n` is equal to `n` itself. In mathematical terms, if `n` is any integer, then the expression `--n = n` is always true.

For any integer `n`, the double negation of `n` equals `n` (i.e., `--n = n`).


theorem FirstOrder.Language.Theory.CompleteType.subset :
    ∀ {L : FirstOrder.Language} {T : FirstOrder.Language.Theory L} {α : Type w}
      (p : FirstOrder.Language.Theory.CompleteType T α),
      FirstOrder.Language.LHom.onTheory (FirstOrder.Language.lhomWithConstants L α) T ⊆ ↑p :=
  by sorry

This theorem asserts that for any First-Order language `L`, any theory `T` of `L`, and any type `α`, if `p` is a complete type of the theory `T` over the type `α`, then the set of sentences in `T` after mapping its symbols via the language map that adds constants from `α` to `L` (done by `FirstOrder.Language.lhomWithConstants L α`) is a subset of `p`. In other words, any sentence in the theory `T` that's extended with constants from another type `α` can be found in the complete type `p` of the theory `T` over `α`.

For any First-Order language L, theory T of L, and type α, if p is a complete type of T over α, then the set of sentences in T after extending its constants to α is included in p.


theorem MeasureTheory.HasFiniteIntegral.mono_measure :
    ∀ {α : Type u_1} {β : Type u_2} {m : MeasurableSpace α} {μ ν : MeasureTheory.Measure α}
      [inst : NormedAddCommGroup β] {f : α → β},
      MeasureTheory.HasFiniteIntegral f ν → μ ≤ ν → MeasureTheory.HasFiniteIntegral f μ :=
  by sorry

The theorem `MeasureTheory.HasFiniteIntegral.mono_measure` asserts that for any types `α` and `β`, a measurable space `m` over `α`, measures `μ` and `ν` on `α`, a normed add commutative group over `β`, and a function `f` from `α` to `β`, if the function `f` has a finite integral with respect to the measure `ν` and `μ` is less than or equal to `ν` (i.e., every set that's measurable in `μ` is also measurable in `ν` and `μ` assigns less or equal measure to every set), then `f` also has a finite integral with respect to the measure `μ`. In other words, if the integral of the norm of `f` with respect to `ν` is finite, and the measure `μ` is dominated by `ν`, then the integral of the norm of `f` with respect to `μ` is also finite.

If `μ` is a measure dominated by `ν` on a measurable space, and `f` is a measurable function with finite integral with respect to `ν`, then `f` has a finite integral with respect to `μ`.


theorem sup_sup_distrib_right : ∀ {α : Type u} [inst : SemilatticeSup α] (a b c : α), a ⊔ b ⊔ c = a ⊔ c ⊔ (b ⊔ c) := by
  sorry

This theorem states that for any type `α` that forms a semilattice with a supremum operation (denoted by `⊔`), and for any three elements `a`, `b`, and `c` of this type, the supremum of `a`, `b` and `c` distributed in the order `(a ⊔ b) ⊔ c` is equal to the supremum distributed in the order `a ⊔ (c ⊔ (b ⊔ c))`. In terms of set theory, this is akin to stating that the union of three sets distributed in two different ways gives the same result.

For any semilattice `α` with supremum operation `⊔`, the distributivity holds: `(a ⊔ b) ⊔ c = a ⊔ (c ⊔ b)` for all `a, b, c ∈ α`.


theorem Mathlib.Analysis.Normed.Group.Basic._auxAddLemma.40 :
    ∀ {E : Type u_6} [inst : SeminormedAddGroup E] (a : E), ‖a‖ = dist a 0 := by sorry

This theorem, from the Mathlib library in the Analysis of Normed Groups section, states that for any type `E` which forms a semi-normed add group, the norm of an element `a` of type `E` is equal to the distance of `a` from 0. In mathematical terms, it says that for all `a` in `E`, the norm of `a` (`‖a‖`) is equal to the distance of `a` from the origin (`dist a 0`).

For any semi-normed add group `E`, the norm of an element `a` in `E` is equal to the distance from `a` to the origin.


theorem Mathlib.Analysis.Normed.Group.Basic._auxAddLemma.24 :
    ∀ {α : Type u} [inst : PseudoMetricSpace α] {x y : α} {ε : ℝ}, (y ∈ Metric.closedBall x ε) = (dist y x ≤ ε) := by
  sorry

This theorem, "Mathlib.Analysis.Normed.Group.Basic._auxAddLemma.24", states that for any pseudometric space `α`, and any elements `x` and `y` of that space, and any real number `ε`, the fact that `y` is in the closed ball of radius `ε` centered at `x` is equivalent to the statement that the distance from `y` to `x` is less than or equal to `ε`. This is an equivalence claim, which means that the two conditions described (being in the closed ball and having a distance less than or equal to `ε`) always hold true together or always false together.

For any pseudometric space and elements, the closed ball condition and the distance condition are equivalent: an element belongs to the closed ball of center and radius if and only if its distance to the center is less than or equal to the radius.


theorem Mathlib.Analysis.Normed.Group.Basic._auxAddLemma.22 :
    ∀ {α : Type u} {β : Type v} {f : α → β} {s : Set β} {a : α}, (a ∈ f ⁻¹' s) = (f a ∈ s) := by sorry

This theorem states that for all types `α` and `β`, for any function `f` from `α` to `β`, for any set `s` of type `β`, and any element `a` of type `α`, the statement "`a` belongs to the preimage of `s` under `f`" is equivalent to the statement "`f(a)` belongs to `s`". In mathematical terms, for any element `a` in the domain of a function, `a` is in the preimage of a set `s` under function `f` if and only if the image of `a` under `f` is in the set `s`.

For any function between types `α` and `β`, and any set `s` of type `β`, the element `a` of type `α` is in the preimage of `s` under `f` if and only if `f(a)` is in `s`.


theorem Mathlib.Analysis.Normed.Group.Basic._auxAddLemma.17 :
    ∀ {E : Type u_6} [inst : SeminormedAddGroup E] (a b : E), ‖a - b‖ = dist a b := by sorry

This theorem from the Mathlib library in Analysis/Normed Group/Basic states that for any type 'E' that has an instance of a 'SemimornedAddGroup', the norm of the difference between any two elements 'a' and 'b' of this type is equal to the distance between 'a' and 'b'. In mathematical terms, it asserts that ‖a - b‖ = dist(a, b) for any 'a' and 'b' in 'E'.

For any type 'E' with a SeminormedAddGroup structure, the norm of the difference between any two elements equals their distance: ‖a - b‖ = dist(a, b).


theorem Polynomial.natTrailingDegree_mul :
    ∀ {R : Type u} [inst : Semiring R] {p q : Polynomial R} [inst_1 : NoZeroDivisors R],
      p ≠ 0 →
        q ≠ 0 →
          Polynomial.natTrailingDegree (p * q) = Polynomial.natTrailingDegree p + Polynomial.natTrailingDegree q :=
  by sorry

The theorem `Polynomial.natTrailingDegree_mul` states that for any two non-zero polynomials `p` and `q` over a semiring `R` that has no zero divisors, the natural trailing degree of the product `p * q` is the sum of the natural trailing degrees of `p` and `q`. In other words, when you multiply two non-zero polynomials, the degree of the resulting polynomial is the sum of the degrees of the original polynomials.

The natural trailing degrees of the product of two non-zero polynomials over a semiring without zero divisors equals the sum of their natural trailing degrees.


/-- Replacing a set by its closure does not change the Hausdorff edistance.  -/
theorem EMetric.hausdorffEdist_closure₂ :
    ∀ {α : Type u} [inst : PseudoEMetricSpace α] {s t : Set α},
      EMetric.hausdorffEdist s (closure t) = EMetric.hausdorffEdist s t :=
  by sorry

This theorem states that for any given pseudoemetric space `α` and any two sets `s` and `t` of `α`, the Hausdorff extended metric or edistance between the set `s` and the closure of the set `t` is the same as that between `s` and `t` itself. In other words, closing the set `t` does not change the Hausdorff edistance to `s`. Here, the closure of a set refers to the smallest closed set that contains the set, and the Hausdorff edistance refers to the smallest non-negative real number `r` such that each point of each set is not farther than `r` from some point of the other set.

The Hausdorff extended metric between a set and its closure is equal to the Hausdorff extended metric between the set and the original set.


theorem MeasureTheory.SimpleFunc.map_setToSimpleFunc :
    ∀ {α : Type u_1} {F : Type u_3} {F' : Type u_4} {G : Type u_5} [inst : NormedAddCommGroup F]
      [inst_1 : NormedSpace ℝ F] [inst_2 : NormedAddCommGroup F'] [inst_3 : NormedSpace ℝ F']
      [inst_4 : NormedAddCommGroup G] {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} (T : Set α → F →L[ℝ] F'),
      MeasureTheory.FinMeasAdditive μ T →
        ∀ {f : MeasureTheory.SimpleFunc α G},
          MeasureTheory.Integrable (↑f) μ →
            ∀ {g : G → F},
              g 0 = 0 →
                MeasureTheory.SimpleFunc.setToSimpleFunc T (MeasureTheory.SimpleFunc.map g f) =
                  Finset.sum (MeasureTheory.SimpleFunc.range f) fun x => (T (↑f ⁻¹' {x})) (g x) :=
  by sorry

This theorem states that for all types `α`, `F`, `F'`, `G`, with `F`, `F'`, and `G` being normed additive commutative groups, and for any measurable space `m` of type `α` and a measure `μ` of this space, if we have a function `T` from the set `α` to the linear space of `F` and `F'` that is finite measure additive with respect to the measure `μ`, then for any simple function `f` from `α` to `G` that is integrable with respect to `μ`, and for any function `g` from `G` to `F` where `g 0 = 0`, the function `T` applied to the simple function obtained by mapping `g` onto `f` is equal to the sum (over the range of `f`) of `T` applied to the preimage of `x` under `f` and `g x`. In mathematical terms, this theorem is stating that the mapping and summation operations commute under certain conditions.

For measurable spaces `α`, `F`, `F'`, `G` with normed additive commutative groups `F`, `F'`, `G`, given a measure `μ` on `α`, a finite measure additive function `T` from `α` to the linear space of `F` and `F'`, and a simple, integrable function `f` from `α` to `G`, the function `T` applied to the simple function `g ∘ f` is equal to the sum of `T` applied to `f⁻¹(x)` and `g(x)` over the range of `f`.


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

This theorem, `CategoryTheory.rightAdjointMate_id`, states that for any type `C` that is a category and a monoidal category, and any object `X` in `C` that has a right dual, the identity morphism on the right dual of `X` (denoted `Xᘁ`) is equal to itself. In other words, the identity morphism on the right dual of an object is idempotent in the category theory context.

In any monoidal category `C` with objects `C` and `X` having right duals `Xᘁ`, the identity morphism on the right dual of `X`, `id Xᘁ`, is equal to itself.


theorem Nat.xgcd_zero_left : ∀ {s t : ℤ} {r' : ℕ} {s' t' : ℤ}, Nat.xgcdAux 0 s t r' s' t' = (r', s', t') := by sorry

The theorem `Nat.xgcd_zero_left` states that for all integer values of `s` and `t` and for all natural number value of `r'` and integer values of `s'` and `t'`, when the `Nat.xgcdAux` function is invoked with the first natural number argument as zero (i.e., `0`), then the result is a triple consisting of `r'`, `s'`, and `t'`. Essentially, when the first input to the extended GCD algorithm helper function is zero, the function returns the input parameters of the second part.

If `Nat.xgcdAux` is applied to natural number 0 and integers `s`, `t`, it returns a triple `(r', s', t')` where `r'` is a natural number and `s'`, `t'` are integers, such that `gcd(s,t) = s' * r'`.


theorem intervalIntegral.integral_comp_sub_mul :
    ∀ {E : Type u_3} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {a b c : ℝ} (f : ℝ → E),
      c ≠ 0 → ∀ (d : ℝ), ∫ (x : ℝ) in a..b, f (d - c * x) = c⁻¹ • ∫ (x : ℝ) in d - c * b..d - c * a, f x :=
  by sorry

This theorem states that for any normed add commutative group E, and any normed space over the real numbers with an element of E, given a real number `c` that is not equal to zero, a function `f` from the real numbers to E, and another real number `d`, the integral over the interval `[a, b]` of `f` composed with the function `x ↦ d - c * x` is equal to `c` inverse scaled by the integral over the interval `[d - c * b, d - c * a]` of `f`. This theorem basically describes the change of variables in an integral with respect to a linear substitution.

For any commutative normed additive group E, real number c ≠ 0, real numbers a ≤ b, and a real-valued function f on the real numbers, the integral of f(x) * (d - c*x) dx over [a, b] is equal to c^(-1) * integral of f(x) dx over [d - c*b, d - c*a].


AffineIsometryEquiv.continuous

theorem AffineIsometryEquiv.continuous :
    ∀ {𝕜 : Type u_1} {V : Type u_2} {V₂ : Type u_5} {P : Type u_10} {P₂ : Type u_11} [inst : NormedField 𝕜]
      [inst_1 : SeminormedAddCommGroup V] [inst_2 : NormedSpace 𝕜 V] [inst_3 : PseudoMetricSpace P]
      [inst_4 : NormedAddTorsor V P] [inst_5 : SeminormedAddCommGroup V₂] [inst_6 : NormedSpace 𝕜 V₂]
      [inst_7 : PseudoMetricSpace P₂] [inst_8 : NormedAddTorsor V₂ P₂] (e : P ≃ᵃⁱ[𝕜] P₂), Continuous ⇑e :=
  by sorry

This theorem states that for any affine isometry equivalence `e` between two points `P` and `P₂` in different types (or spaces), the function represented by `e` is continuous. The spaces `P` and `P₂` are associated with the seminormed additive commutative groups `V` and `V₂`, respectively, both of which are normed over a normed field `𝕜`. Additionally, both `P` and `P₂` are pseudometric spaces, and `V` and `V₂` are normed add-torsors over `P` and `P₂`, respectively. The theorem holds for any such setup.

For any affine isometry equivalence between points in normed additive commutative groups over a normed field, the represented function is continuous.


/-- If `f` is multilinear, then `f (Σ_{j₁ ∈ A₁} g₁ j₁, ..., Σ_{jₙ ∈ Aₙ} gₙ jₙ)` is the sum of
`f (g₁ (r 1), ..., gₙ (r n))` where `r` ranges over all functions with `r 1 ∈ A₁`, ...,
`r n ∈ Aₙ`. This follows from multilinearity by expanding successively with respect to each
coordinate.  -/
theorem MultilinearMap.map_sum_finset :
    ∀ {R : Type uR} {ι : Type uι} {M₁ : ι → Type v₁} {M₂ : Type v₂} [inst : Semiring R]
      [inst_1 : (i : ι) → AddCommMonoid (M₁ i)] [inst_2 : AddCommMonoid M₂] [inst_3 : (i : ι) → Module R (M₁ i)]
      [inst_4 : Module R M₂] (f : MultilinearMap R M₁ M₂) {α : ι → Type u_1} (g : (i : ι) → α i → M₁ i)
      (A : (i : ι) → Finset (α i)) [inst_5 : DecidableEq ι] [inst_6 : Fintype ι],
      (f fun i => Finset.sum (A i) fun j => g i j) = Finset.sum (Fintype.piFinset A) fun r => f fun i => g i (r i) :=
  by sorry

The theorem `MultilinearMap.map_sum_finset` states that for a multilinear map `f`, the application of `f` on a tuple, where each entry of the tuple is the sum of a set of elements from a corresponding finite set `A`, is equal to the sum of `f` applied on each possible tuple that can be formed by picking one element from each of these finite sets. Here, the function `g` is used to map elements from the finite sets to the domain of `f`. The sum over a finite set `A` is denoted by `Σ_{j ∈ A} g j`. The tuple is represented by a function `r` such that `r i` is an element of `A i` for each `i`. The sum over all possible tuples is represented by `Σ_{r} f r` where `r` ranges over all functions that pick one element from each finite set `A i`. This theorem is a consequence of the multilinearity of `f`, which allows us to expand `f` successively with respect to each coordinate.

For a multilinear map `f` and finite sets `A_i` with elements mapped to `f`'s domain via functions `g_i`, the application of `f` to the sum of elements from each `A_i` is equal to the sum of applications of `f` to tuples, where each entry is an element from a corresponding `A_i` chosen via functions `g_i`.


theorem Polynomial.coeff_mul_X_pow' :
    ∀ {R : Type u} [inst : Semiring R] (p : Polynomial R) (n d : ℕ),
      Polynomial.coeff (p * Polynomial.X ^ n) d = if n ≤ d then Polynomial.coeff p (d - n) else 0 :=
  by sorry

This theorem, named `Polynomial.coeff_mul_X_pow'`, states that for any semiring `R`, any polynomial `p` of type `Polynomial R` and any natural numbers `n` and `d`, the coefficient of `X^d` in the product of `p` and `X^n` is equal to the coefficient of `X^(d-n)` in `p` if `n` is less than or equal to `d`, and is zero otherwise. Essentially, this theorem describes the effect on the coefficients of a polynomial when it is multiplied by a power of the polynomial variable `X`.

For any polynomial `p` and natural numbers `n` and `d`, the coefficient of `X^d` in the product `p * X^n` is equal to the coefficient of `X^(d-n)` in `p`, if `n` is less than or equal to `d`, and is zero otherwise.


theorem LinearIndependent.units_smul :
    ∀ {ι : Type u'} {R : Type u_2} {M : Type u_4} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M]
      {v : ι → M}, LinearIndependent R v → ∀ (w : ι → Rˣ), LinearIndependent R (w • v) :=
  by sorry

The theorem `LinearIndependent.units_smul` states that for any type `ι`, ring `R`, and additively commutative group `M` with `M` being a module over `R`, if a family of vectors `v` over `M` indexed by `ι` is linearly independent over `R`, then for any function `w` from `ι` to the multiplicative group of units in `R`, the family of vectors obtained by scaling each vector in `v` by the corresponding unit in `w` is also linearly independent over `R`. This theorem essentially means that scaling a set of linearly independent vectors by non-zero scalars does not affect their linear independence.

If `{v i : M | i : ι}` is a linearly independent family of vectors over a ring `R` in an additively commutative group `M` that is an `R`-module, then scaling each vector `v i` by the corresponding unit `w i` in `R` results in a linearly independent family.


/-- The orthogonal complement of any submodule `K` is closed.  -/
theorem Submodule.isClosed_orthogonal :
    ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
      (K : Submodule 𝕜 E), IsClosed ↑Kᗮ :=
  by sorry

This theorem states that for any given submodule `K` within an Inner Product Space over a field `𝕜` and a Normed Additive Commutative Group `E`, the orthogonal complement of `K` is closed. In other words, given any submodule in the context of inner product spaces, the set of all vectors orthogonal to `K` (denoted as `Kᗮ`) forms a closed set.

The orthogonal complement of a submodule in an inner product space is a closed set.


theorem IntermediateField.normal_iff_normalClosure_le :
    ∀ {F : Type u_1} {L : Type u_3} [inst : Field F] [inst_1 : Field L] [inst_2 : Algebra F L] [inst_3 : Normal F L]
      {K : IntermediateField F L}, Normal F ↥K ↔ normalClosure F (↥K) L ≤ K :=
  by sorry

This theorem states that for any Field F, Field L, and an Intermediate Field K between F and L, with F and L being algebraically related and L being a Normal field extension of F, the Intermediate Field K is a Normal field extension of F if and only if the normal closure of K in L is a subfield (or equal to) K. The normal closure here refers to the smallest normal extension of F in L that contains K. In other words, K is normal over F if and only if all elements of K that are algebraic over F are also elements of K.

A field K between fields F and L, with F and L algebraically related and L a normal extension of F, is a normal extension of F if and only if the normal closure of K in L is contained in K.


theorem Ring.inverse_mul_cancel :
    ∀ {M₀ : Type u_2} [inst : MonoidWithZero M₀] (x : M₀), IsUnit x → Ring.inverse x * x = 1 := by sorry

The theorem `Ring.inverse_mul_cancel` states that for any type `M₀` which is a `MonoidWithZero`, for every element `x` of `M₀` that is a unit (i.e., it has a two-sided inverse), the product of the `Ring.inverse` of `x` and `x` itself equals `1`. In other words, if `x` in a monoid with zero is invertible, its "inverse" as defined in the `Ring` namespace, when multiplied by `x`, yields the multiplicative identity of the monoid.

For any monoid with zero `M₀` and unit `x` in `M₀`, `x * (M₀.inverse x) = 1`.


theorem Submodule.Quotient.mk_surjective :
    ∀ {R : Type u_1} {M : Type u_2} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] (p : Submodule R M),
      Function.Surjective Submodule.Quotient.mk :=
  by sorry

The theorem `Submodule.Quotient.mk_surjective` states that for any ring `R`, any additive commutative group `M` which is also a `R`-module, and any submodule `p` of `M`, the function `Submodule.Quotient.mk` is surjective. In other words, every element in the quotient space `M/p` is the image of some element from `M` under the function `Submodule.Quotient.mk`. This maps an element of `M` to its corresponding element in the quotient space `M/p`.

For any ring `R`, `R-module` `M`, and submodule `p` of `M`, the natural quotient map `M → M/p` is surjective.


theorem Multiset.mem_disjSum :
    ∀ {α : Type u_1} {β : Type u_2} {s : Multiset α} {t : Multiset β} {x : α ⊕ β},
      x ∈ Multiset.disjSum s t ↔ (∃ a ∈ s, Sum.inl a = x) ∨ ∃ b ∈ t, Sum.inr b = x :=
  by sorry

The theorem `Multiset.mem_disjSum` states that for any types `α` and `β`, multisets `s` of type `α` and `t` of type `β`, and element `x` of the disjoint sum type `α ⊕ β`, `x` is in the disjoint sum of `s` and `t` if and only if `x` is the left injection `Sum.inl a` of some element `a` in `s` or the right injection `Sum.inr b` of some element `b` in `t`. In other words, an element is in the disjoint sum of two multisets if it comes from one of the two multisets, being tagged accordingly to differentiate between the two original sets.

For any multisets $s$ of type $\alpha$ and $t$ of type $\beta$, and any $x$ in the disjoint sum $\alpha \oplus \beta$, $x$ is in the multiset union of $s$ and $t$ if and only if $x$ is the injection of some element in $s$ or the injection of some element in $t$.


theorem AffineEquiv.pointReflection_midpoint_left :
    ∀ {R : Type u_1} {V : Type u_2} {P : Type u_4} [inst : Ring R] [inst_1 : Invertible 2] [inst_2 : AddCommGroup V]
      [inst_3 : Module R V] [inst_4 : AddTorsor V P] (x y : P),
      (AffineEquiv.pointReflection R (midpoint R x y)) x = y :=
  by sorry

This theorem states that for any ring `R`, additive commutative group `V`, and affine torsor `P` with `V` acting on `P`, and for any points `x` and `y` in `P`, the point reflection in the midpoint of `x` and `y` maps `x` to `y`. In other words, if you imagine a line segment with endpoints `x` and `y`, and reflect point `x` across the midpoint of this segment, you will end up at `y`.

For any additive commutative group `V`, ring `R`, and affine torsor `P` over `R` with `V` acting on `P`, the reflection of a point `x` in the midpoint of the line segment between `x` and any other point `y` in `P` equals `y`.


theorem Set.piecewise_eqOn_compl :
    ∀ {α : Type u_1} {β : Type u_2} (s : Set α) [inst : (j : α) → Decidable (j ∈ s)] (f g : α → β),
      Set.EqOn (Set.piecewise s f g) g sᶜ :=
  by sorry

This theorem states that for any type `α` and `β`, and for any set `s` of type `α`, a decidable property that a particular `α` is in `s`, and any two functions `f` and `g` from `α` to `β`, the function produced by the `Set.piecewise` function, which is `f` on the set `s` and `g` on its complement, is equal to `g` on the complement of `s`. In simple terms, it says that for any element not in `s`, the `Set.piecewise` function acts the same as the function `g`.

For any type `α`, set `s` of `α`, decidable `P : α → Prop`, and functions `f : α → β` and `g : α → β`, the function `Set.piecewise s P f g` equals `g` on the complement of `s`.


theorem Int.mul_ediv_self_le : ∀ {x k : ℤ}, k ≠ 0 → k * (x / k) ≤ x := by sorry

This theorem states that for any integers `x` and `k`, with `k` not equal to 0, the product of `k` and the integer division of `x` by `k` is less than or equal to `x`. In other words, k times the floor division of x by k never exceeds x itself. This is a property of how integer (floor) division works, where the quotient is always less than or equal to the original value when multiplied by the divisor.

For all integers x and k (with k != 0), k * ⌊x / k⌋ ≤ x.


theorem Set.subset_iInter₂_iff :
    ∀ {α : Type u_1} {ι : Sort u_4} {κ : ι → Sort u_7} {s : Set α} {t : (i : ι) → κ i → Set α},
      s ⊆ ⋂ i, ⋂ j, t i j ↔ ∀ (i : ι) (j : κ i), s ⊆ t i j :=
  by sorry

The theorem `Set.subset_iInter₂_iff` states that for any type `α`, an indexing type `ι`, a set `s` of type `α`, and a function `t` that for every index `i` of type `ι` returns a set of type `α` indexed by `κ i`, the set `s` is a subset of the intersection of all these sets (often denoted by `⋂ i, ⋂ j, t i j`) if and only if for every `i` of type `ι` and `j` of type `κ i`, `s` is a subset of `t i j`. In mathematical terms, this theorem is stating that a set `s` is a subset of the intersection of all sets in a family of sets (indexed by two indices) if and only if `s` is a subset of each individual set in the family.

A set is a subset of the intersection of indexed sets if and only if it is a subset of each indexed set.


theorem HasFDerivAtFilter.add_const :
    ∀ {𝕜 : 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} {L : Filter E},
      HasFDerivAtFilter f f' x L → ∀ (c : F), HasFDerivAtFilter (fun y => f y + c) f' x L :=
  by sorry

The theorem `HasFDerivAtFilter.add_const` states that for a given function `f` from a normed additive commutative group `E` to another normed additive commutative group `F` over a non-trivial normed field `𝕜`, if the function `f` has a Fréchet derivative `f'` at a point `x` with respect to a filter `L`, then for any constant `c` from `F`, the function `g` defined as `g(y) = f(y) + c` also has the same Fréchet derivative `f'` at the same point `x` with respect to the same filter `L`. This theorem essentially says that adding a constant to a function does not change its derivative.

If a function `f : E → F` from a normed additive commutative group `E` to another normed additive commutative group `F` over a non-trivial normed field `𝕜` has a Fréchet derivative `f'` at `x ∈ E` with respect to filter `L`, then the function `g(y) = f(y) + c` also has the same Fréchet derivative `f'` at `x` with respect to `L`, for any constant `c ∈ F`.


theorem Filter.Tendsto.sub_const :
    ∀ {G : Type w} {α : Type u} [inst : TopologicalSpace G] [inst_1 : Sub G] [inst_2 : ContinuousSub G] {c : G}
      {f : α → G} {l : Filter α},
      Filter.Tendsto f l (nhds c) → ∀ (b : G), Filter.Tendsto (fun x => f x - b) l (nhds (c - b)) :=
  by sorry

In natural language, the theorem `Filter.Tendsto.sub_const` states that for any given type `G` which has a topological structure, a subtraction operation, and satisfies the property of continuous subtraction, and for a given constant `c` of type `G`, a function `f` from type `α` to `G`, and a filter `l` on `α`. If `f` tends to the neighborhood filter of `c` as `l` tends to infinity (expressed as `Filter.Tendsto f l (nhds c)`), then for any constant `b` of type `G`, the function `f x - b` also tends to the neighborhood filter of `c - b` as `l` tends to infinity (expressed as `Filter.Tendsto (fun x => f x - b) l (nhds (c - b))`). This theorem is essentially stating a property of limits in a topological space where the limit of a function minus a constant is equal to the limit of the function minus the same constant.

If `f` tends to `c` as `l` approaches infinity, then `f(x) - c` tends to `0` as `l` approaches infinity for all `x`, i.e., `Filter.Tendsto f l (nhds c)` implies `Filter.Tendsto (fun x => f x - c) l (nhds 0)` in a topological space with continuous subtraction.


theorem MeasureTheory.measurePreserving_sumPiEquivProdPi_symm :
    ∀ {ι : Type u_1} {ι' : Type u_2} [inst : Fintype ι] [inst_1 : Fintype ι'] {π : ι ⊕ ι' → Type u_4}
      {m : (i : ι ⊕ ι') → MeasurableSpace (π i)} (μ : (i : ι ⊕ ι') → MeasureTheory.Measure (π i))
      [inst_2 : ∀ (i : ι ⊕ ι'), MeasureTheory.SigmaFinite (μ i)],
      MeasureTheory.MeasurePreserving (⇑(MeasurableEquiv.sumPiEquivProdPi π).symm)
        (MeasureTheory.Measure.prod (MeasureTheory.Measure.pi fun i => μ (Sum.inl i))
          (MeasureTheory.Measure.pi fun i => μ (Sum.inr i)))
        (MeasureTheory.Measure.pi μ) :=
  by sorry

This theorem states that for any two types `ι` and `ι'`, along with a measurable space `π` indexed over the disjoint union of `ι` and `ι'`, and a collection of sigma-finite measures `μ` indexed over the disjoint union of `ι` and `ι'`, the measure preserving property holds for the inverse of the measurable equivalence given by `MeasurableEquiv.sumPiEquivProdPi π`. This means that the product measure of the pi-measure over `ι` and the pi-measure over `ι'` under this inverse equivalence is the same as the pi-measure over the disjoint union of `ι` and `ι'`.

Given measurable spaces `π` over disjoint unions of types `ι` and `ι'`, and sigma-finite measures `μ` indexed over them, the product measure of `μ` under the inverse of `MeasurableEquiv.sumPiEquivProdPi π` is equal to the measure `μ` on the disjoint union.


theorem eq_top_or_lt_top : ∀ {α : Type u} [inst : PartialOrder α] [inst_1 : OrderTop α] (a : α), a = ⊤ ∨ a < ⊤ := by
  sorry

This theorem, `eq_top_or_lt_top`, states that for any given type `α` which has a partial order and a greatest element denoted by `⊤`, any element `a` of type `α` either equals `⊤` or is less than `⊤`. In other words, for any element in a partially ordered set with a greatest element, that element is either the greatest element itself or some element lesser than the greatest one.

For any element `a` in a partially ordered set `α` with a greatest element `⊤`, we have `a = ⊤` or `a < ⊤`.


theorem abs_inf_sub_inf_le_abs :
    ∀ {α : Type u_1} [inst : Lattice α] [inst_1 : AddCommGroup α]
      [inst_2 : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] (a b c : α),
      |a ⊓ c - b ⊓ c| ≤ |a - b| :=
  by sorry

This theorem, `abs_inf_sub_inf_le_abs`, states that for all types `α` that form a Lattice, and also form an Additive Commutative Group, with the additional property specified by the `CovariantClass` (the operation of adding two elements of the type preserves the order), the absolute value of the difference between the infimum of `a` and `c` and the infimum of `b` and `c` is less than or equal to the absolute value of the difference between `a` and `b`. In mathematical notation, we can say: for all `a`, `b`, and `c` in some type `α`, |∧(a, c) - ∧(b, c)| ≤ |a - b|. Here, ∧ denotes the infimum (greatest lower bound) of two elements.

For all types `α` that are Lattices, Additive Commutative Groups with the Covariance property, the absolute value of the infimum difference between two elements `a` and `c`, and `b` and `c` is less than or equal to the absolute value of the difference between `a` and `b`. In mathematical notation: |∧(a, c) - ∧(b, c)| ≤ |a - b|.


theorem Order.Ici_succ_of_not_isMax :
    ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : SuccOrder α] {a : α},
      ¬IsMax a → Set.Ici (Order.succ a) = Set.Ioi a :=
  by sorry

The theorem `Order.Ici_succ_of_not_isMax` states that for any type `α` with a preorder and successor order, and any element `a` of `α`, if `a` is not a maximal element, then the left-closed right-infinite interval starting at the successor of `a` (`Set.Ici (Order.succ a)`) is equal to the left-open right-infinite interval starting just after `a` (`Set.Ioi a`).

In other words, if `a` is not the greatest element, the set of all elements greater than or equal to the next element after `a` is the same as the set of all elements strictly greater than `a`.

If `α` is a type with a preorder and successor order, and `a` is not the greatest element of `α`, then `Set.Ici (Order.succ a)` equals `Set.Ioi a`.


theorem Submonoid.map_sup :
    ∀ {M : Type u_1} {N : Type u_2} [inst : MulOneClass M] [inst_1 : MulOneClass N] {F : Type u_4}
      [inst_2 : FunLike F M N] [mc : MonoidHomClass F M N] (S T : Submonoid M) (f : F),
      Submonoid.map f (S ⊔ T) = Submonoid.map f S ⊔ Submonoid.map f T :=
  by sorry

The theorem `Submonoid.map_sup` states that for any two submonoids `S` and `T` of a MulOneClass `M`, and a monoid homomorphism `f` from `M` to another MulOneClass `N`, the image of the join (supremum) of `S` and `T` under `f` is the same as the join (supremum) of the images of `S` and `T` under `f`. Essentially, this says that the mapping `f` preserves the join operation in the submonoid structure, which is an important property for morphisms in algebra.

For any submonoids S and T of a MulOneClass M and any monoid homomorphism f from M to another MulOneClass N, the image of the supremum of S and T under f is equal to the supremum of the images of S and T under f.


theorem ProbabilityTheory.integrable_compProd_iff :
    ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {E : Type u_4} {mα : MeasurableSpace α} {mβ : MeasurableSpace β}
      {mγ : MeasurableSpace γ} [inst : NormedAddCommGroup E] {κ : ↥(ProbabilityTheory.kernel α β)}
      [inst_1 : ProbabilityTheory.IsSFiniteKernel κ] {η : ↥(ProbabilityTheory.kernel (α × β) γ)}
      [inst_2 : ProbabilityTheory.IsSFiniteKernel η] {a : α} ⦃f : β × γ → E⦄,
      MeasureTheory.AEStronglyMeasurable f ((ProbabilityTheory.kernel.compProd κ η) a) →
        (MeasureTheory.Integrable f ((ProbabilityTheory.kernel.compProd κ η) a) ↔
          (∀ᵐ (x : β) ∂κ a, MeasureTheory.Integrable (fun y => f (x, y)) (η (a, x))) ∧
            MeasureTheory.Integrable (fun x => ∫ (y : γ), ‖f (x, y)‖ ∂η (a, x)) (κ a)) :=
  by sorry

The theorem `ProbabilityTheory.integrable_compProd_iff` states that for any types `α`, `β`, `γ`, and `E`, measurable spaces `mα`, `mβ`, and `mγ`, a normed add commutative group `E`, a kernel `κ` from `α` to `β`, a kernel `η` from the product `α × β` to `γ`, and a function `f` from `β × γ` to `E` that is almost everywhere strongly measurable with respect to the measure derived from the product of kernels `κ` and `η` at a point `a` in `α`, the function `f` is integrable with respect to this measure if and only if two conditions hold:

1. The function `f`, when its first argument is fixed almost everywhere to a value `x` from `β` under the measure of `κ` at `a`, is integrable with respect to the measure of `η` at the pair `(a, x)`.

2. The function that takes a point `x` in `β` and maps it to the integral over `γ` of the norm of `f` at `(x, y)`, with respect to the measure of `η` at `(a, x)`, is integrable with respect to the measure of `κ` at `a`.

The theorem therefore provides a condition for integrability of a function in terms of the integrability of certain related functions.

A function `f` from `β × γ` to a normed add commutative group `E`, almost everywhere strongly measurable with respect to the product of kernels `κ` from `α` to `β` and `η` from `α × β` to `γ`, is integrable with respect to the measure derived from `κ` and `η` if and only if, for almost every `x` in `β` under the measure of `κ` at a point `a` in `α`, `f(x, .)` is integrable with respect to `η` at `(a, x)`, and the function that maps `x` to the integral of the norm of `f(x, .)` with respect to `η` is integrable with respect to `κ` at `a`.


theorem FirstOrder.Language.Theory.models_sentence_iff :
    ∀ {L : FirstOrder.Language} {T : FirstOrder.Language.Theory L} {φ : FirstOrder.Language.Sentence L},
      T ⊨ᵇ φ ↔ ∀ (M : FirstOrder.Language.Theory.ModelType T), ↑M ⊨ φ :=
  by sorry

This theorem states that for any first-order language `L`, any theory `T` of `L`, and any sentence `φ` of `L`, that theory `T` semantically entails sentence `φ` if and only if for every model `M` of the theory `T`, `M` also semantically entails `φ`. In other words, if `φ` is entailed by a theory, then `φ` must be true in every model of the theory. On the other hand, if `φ` is true in every model of the theory, then it must also be entailed by the theory.

For any first-order language L, theory T, and sentence φ in L, T semantically entails φ if and only if every model M of T satisfies φ.


theorem zorn_nonempty_partialOrder₀ :
    ∀ {α : Type u_1} [inst : PartialOrder α] (s : Set α),
      (∀ c ⊆ s, IsChain (fun x x_1 => x ≤ x_1) c → ∀ y ∈ c, ∃ ub ∈ s, ∀ z ∈ c, z ≤ ub) →
        ∀ x ∈ s, ∃ m ∈ s, x ≤ m ∧ ∀ z ∈ s, m ≤ z → z = m :=
  by sorry

This theorem, known as Zorn's Lemma, states that for any type `α` equipped with a partial order, given a set `s` of elements of this type, if every chain in `s` (a chain being defined as a set where for all `x` and `y` in it, either `x` is less than or equal to `y` or `y` is less than or equal to `x`) has an upper bound in `s`, then for every element `x` in `s`, there exists a maximal element `m` in `s`. This maximal element `m` has two properties: `x` is less than or equal to `m`, and if there exists any `z` in `s` such that `m` is less than or equal to `z`, then `z` must equal `m`. In other words, there is no element in `s` strictly greater than `m`.

If every chain in a partially ordered set has an upper bound, then the set has a maximal element.


theorem WithLp.equiv_symm_sub :
    ∀ (p : ENNReal) {V : Type uV} [inst : AddCommGroup V] (x' y' : V),
      (WithLp.equiv p V).symm (x' - y') = (WithLp.equiv p V).symm x' - (WithLp.equiv p V).symm y' :=
  by sorry

This theorem states that for any extended nonnegative real number `p`, for any type `V` that is an additive commutative group, and for any two elements `x'` and `y'` of type `V`, the difference `x' - y'` under the inverse of the canonical equivalence `WithLp.equiv` between `WithLp p V` and `V` is equal to the difference between `x'` under the inverse equivalence and `y'` under the inverse equivalence. In other words, the inverse equivalence preserves the subtraction operation.

For any extended nonnegative real number `p`, any additive commutative group `V`, and any `x, y` in `V`, the inverse of the canonical equivalence between `WithLp p V` and `V` preserves the subtraction operation, that is, `WithLp.equiv.symm (x' - y') = x' - WithLp.equiv.symm y'` in `V`.


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

This theorem, `CategoryTheory.ShortComplex.f'_cyclesMap'`, states that for any category `C` that has zero morphisms and any two short complexes `S₁` and `S₂` in this category, if we have a morphism `φ` from `S₁` to `S₂`, and `h₁` and `h₂` are the left homology data of `S₁` and `S₂` respectively, then the composition of the mapping `f'` of `h₁` and the `cyclesMap'` from `φ`, `h₁`, and `h₂` is equal to the composition of the morphism `τ₁` of `φ` and the mapping `f'` of `h₂`. In other words, `(f' of h₁) composed with (cyclesMap' from φ, h₁, h₂)` is equal to `φ.τ₁ composed with (f' of h₂)`.

For any category with zero morphisms, given two short complexes and a morphism between them, the mapping of their left homology data composed with the cycles map from the morphism equals the composition of the morphism with the mapping of the right homology data.


theorem IsLocalization.mk'_one :
    ∀ {R : Type u_1} [inst : CommSemiring R] {M : Submonoid R} (S : Type u_2) [inst_1 : CommSemiring S]
      [inst_2 : Algebra R S] [inst_3 : IsLocalization M S] (x : R), IsLocalization.mk' S x 1 = (algebraMap R S) x :=
  by sorry

The theorem `IsLocalization.mk'_one` states that for any commutative semiring `R`, submonoid `M` of `R`, and `S` being a localization of `R` at `M`, and any element `x` in `R`, the image of the pair `(x, 1)` under the surjective function `IsLocalization.mk' S` (which sends a pair `(x, y)` in `R × M` to `f x * (f y)⁻¹`) is equal to the image of `x` under the algebra map from `R` to `S`. In mathematical terms, this means that for any `x` in `R`, we have `f(x) * (f(1))⁻¹ = f(x)`, where `f` is the algebra map from `R` to `S`.

For any commutative semiring `R`, submonoid `M` of `R`, localization `S` of `R` at `M`, and `x` in `R`, the image of `(x, 1)` under `IsLocalization.mk' S` equals the image of `x` under the algebra map from `R` to `S`. In other words, `f(x) * f(1)⁻¹ = f(x)`, where `f` is the algebra map.


theorem Mathlib.GroupTheory.Submonoid.Operations._auxLemma.20 :
    ∀ {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) {x : M}, (x ∈ MonoidHom.mker f) = (f x = 1) :=
  by sorry

This theorem states that for any types `M`, `N`, and `F`, if `M` and `N` have multiplicative and identity structure (expressed as `MulOneClass M` and `MulOneClass N`), `F` is function-like from `M` to `N` (expressed as `FunLike F M N`), and `F` is a monoid homomorphism class from `M` to `N` (expressed as `MonoidHomClass F M N`), then for any function `f` of type `F` and any element `x` of type `M`, `x` is in the multiplicative kernel (or mker) of `f` if and only if the function `f` applied to `x` equals the multiplicative identity, which in this context is `1`.

In mathematical terms, if `f: M → N` is a monoid homomorphism, the multiplicative kernel of `f` (denoted `MonoidHom.mker f` in Lean and usually `ker f` in mathematical notation) is the set of all elements `x` in `M` such that `f(x) = 1`, where `1` is the identity element of the monoid `N`. The theorem states that `x` belongs to the kernel of `f` if and only if `f(x) = 1`.

For any monoid homomorphisms `f: M → N` between multiplicative monoids `M` and `N`, the element `x` in `M` belongs to the multiplicative kernel of `f` if and only if `f(x) = 1`.