theorem Seminorm.continuous_of_continuousAt_zero :
    ∀ {𝕝 : Type u_6} {E : Type u_7} [inst : SeminormedRing 𝕝] [inst_1 : AddCommGroup E] [inst_2 : Module 𝕝 E]
      [inst_3 : TopologicalSpace E] [inst_4 : TopologicalAddGroup E] {p : Seminorm 𝕝 E},
      ContinuousAt (⇑p) 0 → Continuous ⇑p :=
  by sorry

This theorem states that for any seminorm `p` on a semi-normed ring `𝕝` and an additive commutative group `E` that is also a `𝕝`-module with a topology compatible with the group structure, if the seminorm `p` is continuous at the zero element, then `p` is a continuous function. In other words, if for every sequence of elements in `E` that converges to zero, the corresponding sequence of their seminorms also converges to zero, then for every convergent sequence in `E`, the sequence of their seminorms is also convergent.

If a seminorm on a semi-normed ring is continuous at the zero element, then it is a continuous function on the associated topology of the compatible additive commutative group.


theorem MeasureTheory.AECover.integral_tendsto_of_countably_generated :
    ∀ {α : Type u_1} {ι : Type u_2} {E : Type u_3} [inst : MeasurableSpace α] {μ : MeasureTheory.Measure α}
      {l : Filter ι} [inst_1 : NormedAddCommGroup E] [inst_2 : NormedSpace ℝ E] [inst_3 : Filter.IsCountablyGenerated l]
      {φ : ι → Set α},
      MeasureTheory.AECover μ l φ →
        ∀ {f : α → E},
          MeasureTheory.Integrable f μ →
            Filter.Tendsto (fun i => ∫ (x : α) in φ i, f x ∂μ) l (nhds (∫ (x : α), f x ∂μ)) :=
  by sorry

The theorem `MeasureTheory.AECover.integral_tendsto_of_countably_generated` states that for any types `α`, `ι`, and `E`, given a measurable space `α`, a measure `μ` on `α`, a filter `l` on `ι` that is countably generated, and a function `φ` mapping `ι` to a set of `α` such that `φ` forms an almost everywhere cover with respect to `μ` and `l`. Then for any function `f` from `α` to `E` that is integrable with respect to `μ`, the limit as `i` tends to infinity (in the sense of the filter `l`) of the integral over the set `φ(i)` of `f` with respect to `μ` is equal to the integral over the entire space `α` of `f` with respect to `μ`. This is essentially saying that if we have a sequence of sets that covers almost everywhere in the space, the limit of the integrals of a function over these sets is the same as the integral of the function over the whole space.

Given a measurable space `(α, Σ, μ)`, a countably generated filter `l` on `ι`, a measurable function `φ : ι -> Σ`, an almost everywhere cover `φ` of `α` with respect to `μ` and `l`, and an integrable function `f : α -> E`, the limit as `i` in `l` tends to infinity of the integrals of `f` over `φ(i)` equals the integral of `f` over `α`.


theorem StructureGroupoid.le_iff :
    ∀ {H : Type u} [inst : TopologicalSpace H] {G₁ G₂ : StructureGroupoid H}, G₁ ≤ G₂ ↔ ∀ e ∈ G₁, e ∈ G₂ := by sorry

This theorem states that for any given type `H` equipped with a `TopologicalSpace` structure, and any two `StructureGroupoid` objects `G₁` and `G₂` of type `H`, `G₁` is less than or equal to `G₂` if and only if every element `e` in `G₁` is also an element in `G₂`. Essentially, this theorem defines the concept of one `StructureGroupoid` being a subset (or equal) to another in the context of topological spaces.

For any topological spaces `H` and `G₁`, `G₂` being a subgroupoid of `G₁` (as structures on `H`) if and only if every element in `G₁` is an element in `G₂`.


theorem Polynomial.degree_linear_le :
    ∀ {R : Type u} {a b : R} [inst : Semiring R],
      Polynomial.degree (Polynomial.C a * Polynomial.X + Polynomial.C b) ≤ 1 :=
  by sorry

The theorem `Polynomial.degree_linear_le` states that for any semiring `R` and any elements `a` and `b` of `R`, the degree of the polynomial `(Polynomial.C a * Polynomial.X + Polynomial.C b)`, which is essentially a linear polynomial `ax + b`, is less than or equal to 1. Here, `Polynomial.C a` is the constant polynomial `a`, `Polynomial.X` is the polynomial variable (the equivalent of `x` in mathematical notation), and `Polynomial.degree` computes the highest power of the polynomial variable that appears in the polynomial.

The degree of the linear polynomial `ax + b` over a semiring is less than or equal to 1, where `a` and `b` are elements of the semiring and `x` is the polynomial variable.


theorem Subgroup.card_bot : ∀ {G : Type u_1} [inst : Group G] {x : Fintype ↥⊥}, Fintype.card ↥⊥ = 1 := by sorry

This theorem, `Subgroup.card_bot`, states that for any type `G` which is a group, the number of elements in the bottom subgroup (denoted by `⊥`) is always equal to 1. Here, `⊥` represents the trivial subgroup which contains only the group's identity element. Thus, regardless of the specific group `G` we are dealing with, the cardinality of this trivial subgroup is always 1.

The cardinality of the trivial subgroup of any group is 1.


theorem Int.commute_cast : ∀ {α : Type u_3} [inst : NonAssocRing α] (a : α) (n : ℤ), Commute a ↑n := by sorry

The theorem `Int.commute_cast` states that for any given type α, which is a Non-Associative Ring, and any elements `a` from α and `n` from the set of integers, the operation of multiplication of `a` and the cast of `n` to α (denoted as ↑n) commutes. In other words, for any integer `n` and any element `a` in a Non-Associative Ring α, we have `a * ↑n = ↑n * a`.

For any non-associative ring α and integers n and a in α, the multiplication of a and the cast of n to α commutes: a * ↑n = ↑n * a.


theorem mul_nonpos_of_nonneg_of_nonpos :
    ∀ {α : Type u_1} {a b : α} [inst : MulZeroClass α] [inst_1 : Preorder α] [inst_2 : PosMulMono α],
      0 ≤ a → b ≤ 0 → a * b ≤ 0 :=
  by sorry

This theorem states that for any type `α` that is a multiplication-zero class and has a preorder and positive multiplication monoticity property, if `a` and `b` are elements of `α` such that `a` is nonnegative (i.e., `0 ≤ a`) and `b` is nonpositive (i.e., `b ≤ 0`), then the product of `a` and `b` is nonpositive (i.e., `a * b ≤ 0`). In simpler terms, it states that the product of a nonnegative number and a nonpositive number is less than or equal to zero.

For any multiplication-zero class `α` with preorder and positive multiplication monotonicity, `0 ≤ a` and `b ≤ 0` imply `a * b ≤ 0`.


theorem sup_lt_iff : ∀ {α : Type u} [inst : LinearOrder α] {a b c : α}, b ⊔ c < a ↔ b < a ∧ c < a := by sorry

This theorem states that for any type `α` that has a linear order, and for any three elements `a`, `b`, and `c` of this type, the supremum (`b ⊔ c`, also known as the maximum or "max") of `b` and `c` is less than `a` if and only if both `b` and `c` are less than `a`. In mathematical terms, we have `max(b, c) < a` if and only if `b < a` and `c < a`.

For any type with a linear order, the maximum of two elements is strictly less than a third element if and only if both are strictly less than that element.


theorem Set.uIoc_comm : ∀ {α : Type u_1} [inst : LinearOrder α] (a b : α), Ι a b = Ι b a := by sorry

This theorem, `Set.uIoc_comm`, states that for any type `α` that has a linear order, the interval `Ι a b` (which represents the set of all elements between `a` and `b`) is the same as the interval `Ι b a`. In other words, the order of `a` and `b` does not matter when defining an interval between them.

For any type `α` with a linear order, the interval `Ι a b` equals `Ι b a`.


theorem Fin.insertNth_eq_iff :
    ∀ {n : ℕ} {α : Fin (n + 1) → Type u} {i : Fin (n + 1)} {x : α i} {p : (j : Fin n) → α (Fin.succAbove i j)}
      {q : (j : Fin (n + 1)) → α j}, Fin.insertNth i x p = q ↔ q i = x ∧ p = fun j => q (Fin.succAbove i j) :=
  by sorry

The theorem `Fin.insertNth_eq_iff` states that for any natural number `n`, a type `α` indexed by `Fin (n + 1)`, an index `i` of type `Fin (n + 1)`, an element `x` of type `α i`, a function `p` from `Fin n` to `α`  (where for each `j`, `α (Fin.succAbove i j)`), and another function `q` from `Fin (n + 1)` to `α`, then `Fin.insertNth i x p` being equal to `q` is equivalent to `q i` being equal to `x` and `p` being equal to a function such that for each `j`, it equals `q (Fin.succAbove i j)`. In other words, the function `q` is equal to the function that inserts `x` at position `i` in the sequence `p` if and only if `q i` is `x` and `p` is the sequence obtained from `q` by removing the element at position `i`.

The theorem `Fin.insertNth_eq_iff` asserts that a function `q : Fin (n + 1) → α` equals the function obtained by inserting an element `x : α` at position `i : Fin (n + 1)` in another function `p : Fin n → α` if and only if `q i = x` and for all `j : Fin n`, `q (Fin.succAbove i j) = p j`.


theorem Multiset.rel_map_left :
    ∀ {α : Type u_1} {β : Type v} {γ : Type u_2} {r : α → β → Prop} {s : Multiset γ} {f : γ → α} {t : Multiset β},
      Multiset.Rel r (Multiset.map f s) t ↔ Multiset.Rel (fun a b => r (f a) b) s t :=
  by sorry

The theorem `Multiset.rel_map_left` states that for any types `α`, `β`, and `γ`, any relation `r` from `α` to `β`, any multiset `s` of elements of type `γ`, any function `f` from `γ` to `α`, and any multiset `t` of elements of type `β`, there is an equivalence between the assertion that the multiset resulting from mapping the function `f` over `s` is related to `t` by the multiset relation induced by `r`, and the assertion that `s` is related to `t` by the multiset relation induced by the composition of `f` and `r`. In other words, mapping a function over a multiset and then relating it to another multiset is equivalent to relating the original multiset to the other multiset by a relation that incorporates the function.

For any types α, β, γ, relation r from α to β, multiset s of γ, function f from γ to α, and multiset t of β, the multisets f[s] and r[t] are equivalent if and only if s and t are equivalent with respect to the relation r composited with f.


theorem Mathlib.Order.Filter.NAry._auxLemma.6 :
    ∀ {α : Type u_1} {β : Type u_3} {γ : Type u_5} (m : α → β → γ) (f : Filter α) (g : Filter β),
      Filter.map₂ m f g = Filter.map (fun p => m p.1 p.2) (f ×ˢ g) :=
  by sorry

This theorem states that, for any types `α`, `β`, and `γ`, and for any binary function `m : α → β → γ` and filters `f : Filter α` and `g : Filter β`, the image of the binary function `m` as a function from filters `f` and `g` to `Filter γ` (denoted as `Filter.map₂ m f g`) is the same as the image of the function that takes a pair `p` and maps it to the result of applying `m` to the elements of `p` (i.e., `m p.1 p.2`), under the filter formed by the product of `f` and `g` (denoted as `Filter.map (fun p => m p.1 p.2) (f ×ˢ g)`). This is a statement about the equivalence of two different ways to construct the image of a function under a filter.

For any functions `m : α -> β -> γ`, `f : Filter α`, and `g : Filter β`, `Filter.map₂ m f g = Filter.map (fun p => m p.1 p.2) (f ×ˢ g)` (where `p` is a pair from `α x β`).


/-- **Fundamental theorem of calculus-2**, on semi-infinite intervals `(a, +∞)`.
When a function has a limit at infinity `m`, and its derivative is integrable, then the
integral of the derivative on `(a, +∞)` is `m - f a`. Version assuming differentiability
on `(a, +∞)` and continuity at `a⁺`. -/
theorem MeasureTheory.integral_Ioi_of_hasDerivAt_of_tendsto :
    ∀ {E : Type u_1} {f f' : ℝ → E} {a : ℝ} {m : E} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E]
      [inst_2 : CompleteSpace E],
      ContinuousWithinAt f (Set.Ici a) a →
        (∀ x ∈ Set.Ioi a, HasDerivAt f (f' x) x) →
          MeasureTheory.IntegrableOn f' (Set.Ioi a) MeasureTheory.volume →
            Filter.Tendsto f Filter.atTop (nhds m) → ∫ (x : ℝ) in Set.Ioi a, f' x = m - f a :=
  by sorry

This theorem is a version of the Fundamental Theorem of Calculus-2, focusing on semi-infinite intervals $(a, +\infty)$. It states that if a function has a limit `m` at infinity and its derivative is integrable, then the integral of the derivative over the interval $(a, +\infty)$ is equal to `m - f a`. This is under the assumption that the function is differentiable on the interval $(a, +\infty)$ and continuous at `a⁺`. In more formal terms, for a function `f` with derivative `f'` and a real number `a`, if `f` is continuous at `a` within the closed interval [a, +\infty), and for all `x` in the open interval (a, +\infty), `f` has a derivative at `x` that equals `f'(x)`, and if `f'` is integrable on the interval (a, +\infty), and if `f` tends to `m` at infinity, then the integral of `f'` over the interval (a, +\infty) equals `m - f a`.

If a differentiable function `f` on the interval $(a,+\infty)$ with continuous derivative `f'` has a limit `m` at infinity and is integrable on $(a,+\infty)$, then $\int\_a^\infty f'(x) dx = m - f(a)$.


theorem Set.Ici_bot : ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : OrderBot α], Set.Ici ⊥ = Set.univ := by sorry

The theorem `Set.Ici_bot` states that for any type `α` that has a preorder and a least element (denoted `⊥`), the left-closed right-infinite interval starting from that least element (`Set.Ici ⊥`) is equal to the universal set (`Set.univ`). In other words, for such an ordered type, the interval of all elements greater than or equal to the least element includes every element in the type, which is the definition of the universal set.

For any type with a preorder and a least element, the set of elements greater than or equal to the least element is equal to the universal set.


theorem SeparationQuotient.isOpenMap_mk :
    ∀ {X : Type u_1} [inst : TopologicalSpace X], IsOpenMap SeparationQuotient.mk := by sorry

The theorem `SeparationQuotient.isOpenMap_mk` declares that for any topological space `X`, the natural map from `X` to its separation quotient, denoted as `SeparationQuotient.mk`, is an open map. An open map, in this context, is a function where the image of any open set in `X` is also an open set in the separation quotient of `X`.

The natural map from a topological space to its separation quotient is an open function.


theorem ENat.one_le_iff_ne_zero : ∀ {n : ℕ∞}, 1 ≤ n ↔ n ≠ 0 := by sorry

This theorem states that for any natural number `n` that can take on the value of infinity (`ℕ∞`), the condition `1 ≤ n` is logically equivalent to `n ≠ 0`. In other words, in the extended natural numbers, `n` being greater than or equal to one implies that it is not equal to zero, and vice versa.

For natural numbers `n` including infinity (`ℕ∞`), `1 ≤ n` is logically equivalent to `n ≠ 0`.


theorem Matroid.basis_iff' :
    ∀ {α : Type u_1} {M : Matroid α} {I X : Set α},
      M.Basis I X ↔ (M.Indep I ∧ I ⊆ X ∧ ∀ (J : Set α), M.Indep J → I ⊆ J → J ⊆ X → I = J) ∧ X ⊆ M.E :=
  by sorry

This theorem states that for any type `α`, a `Matroid` `M` on `α`, and sets `I` and `X` of `α`, the set `I` is a basis of `X` in `M` if and only if `I` is independent in `M`, `I` is a subset of `X`, and for any independent set `J` of `α` in `M` such that `I` is a subset of `J` and `J` is a subset of `X`, `I` must equal `J`. Furthermore, `X` is a subset of the elements of `M`.

A set `I` is a basis of a matroid `M` over a type `α` if and only if it is independent in `M`, is a subset of `X` in `M`, and for any independent `J` with `I` and `J` both subsets of `X`, `I` equals `J`.


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

This theorem states that for any type `E` that forms a normed additive commutative group and a normed space over the real numbers, and for any continuous differentiable "bump" function `f` centered at `c` in `E`, the value of `f` at any point `x` in `E` will always be less than or equal to 1. A "bump" function is a smooth function which is equal to 1 at the center and tapers off to 0 away from the center.

For any normed additive commutative group `E` over the real numbers, any continuous differentiable "bump" function `f` centered at `c` in `E` satisfies `f(x) ≤ 1` for all `x` in `E`.


theorem List.ofFn_get : ∀ {α : Type u} (l : List α), List.ofFn (List.get l) = l := by sorry

This theorem states that for any list `l` of elements of some type `α`, if we build a new list using the function `List.ofFn` with `List.get l` as its argument (a function that retrieves the element at a given index in `l`), the new list will be identical to the original list `l`. In other words, retrieving each element from the list `l` in order and constructing a new list from those elements results in a list that is the same as `l`. It's essentially saying that the `List.ofFn` function with `List.get l` as its argument is a way to clone or copy a list.

For any list `l` of type `α`, the list obtained by applying `List.ofFn` with `List.get` on `l` is equal to the original list `l`. In other words, `List.ofFn (λ (i, x) := List.get i l) = l`.


FreeGroup.reduce.min

/-- The second theorem that characterises the function `reduce`: the maximal reduction of a word
only reduces to itself.  -/
theorem FreeGroup.reduce.min :
    ∀ {α : Type u} {L₁ L₂ : List (α × Bool)} [inst : DecidableEq α],
      FreeGroup.Red (FreeGroup.reduce L₁) L₂ → FreeGroup.reduce L₁ = L₂ :=
  by sorry

The theorem `FreeGroup.reduce.min` states that for any type `α` and for any lists `L₁` and `L₂` of pairs of elements of `α` and a boolean, if `α` has decidable equality, then if there is a reflexive-transitive closure of `Red.Step` (a reduction step) from the maximal reduction of `L₁` to `L₂`, the maximal reduction of `L₁` must be equal to `L₂`. In essence, this theorem characterizes the behavior of the `reduce` function in the `FreeGroup` context: the maximal reduction of a word can only reduce to the word itself.

If `α` has decidable equality and there exists a reflexive-transitive closure of reduction steps from the maximal reduction of `L₁` to `L₂` in the free group on `α`, then `L₁` and `L₂` are equal.


theorem intervalIntegral.integral_deriv_eq_sub' :
    ∀ {E : Type u_3} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [inst_2 : CompleteSpace E] {f' : ℝ → E}
      {a b : ℝ} (f : ℝ → E),
      deriv f = f' →
        (∀ x ∈ Set.uIcc a b, DifferentiableAt ℝ f x) →
          ContinuousOn f' (Set.uIcc a b) → ∫ (y : ℝ) in a..b, f' y = f b - f a :=
  by sorry

The theorem `intervalIntegral.integral_deriv_eq_sub'` states that for every real-valued function `f` on a normed additive commutative group `E` with a normed space structure over the real numbers, and which is complete, given its derivative `f'`, and any two real numbers `a` and `b`, if the function `f` is differentiable at every point in the closed interval between `a` and `b` (inclusive), and the derivative `f'` is continuous on this interval, then the integral of `f'` from `a` to `b` equals the value of `f` at `b` minus the value of `f` at `a`. This is essentially the fundamental theorem of calculus.

If a real-valued function on a complete normed additive commutative group with a normed space structure is differentiable with a continuous derivative on a closed interval, then the integral of its derivative equals the function's value at the right endpoint minus its value at the left endpoint.


theorem MvPolynomial.quotient_map_C_eq_zero :
    ∀ {R : Type u_1} {σ : Type u_2} [inst : CommRing R] {I : Ideal R} {i : R},
      i ∈ I → (RingHom.comp (Ideal.Quotient.mk (Ideal.map MvPolynomial.C I)) MvPolynomial.C) i = 0 :=
  by sorry

The theorem `MvPolynomial.quotient_map_C_eq_zero` states that for any commutative ring `R`, any ideal `I` of `R`, any multivariate polynomial `σ`, and any element `i` of `R` that lies in `I`, the composition of the ring homomorphism from `R` to the quotient ring `R/I` and the constant polynomial function `MvPolynomial.C` evaluated at `i` is zero. In other words, if a constant `i` from a ring `R` is in an ideal `I`, then mapping `i` into the multivariate polynomial ring over `R` and then further mapping into the quotient ring `R/I` results in zero.

For any commutative ring R, ideal I, multivariate polynomial σ, and element i in I, the constant polynomial function evaluated at i in the quotient ring R/I is zero (i.e., MvPolynomial.C(i) = 0).


theorem OrderIso.map_csInf' :
    ∀ {α : Type u_1} {β : Type u_2} [inst : ConditionallyCompleteLattice α] [inst_1 : ConditionallyCompleteLattice β]
      (e : α ≃o β) {s : Set α}, Set.Nonempty s → BddBelow s → e (sInf s) = sInf (⇑e '' s) :=
  by sorry

The theorem `OrderIso.map_csInf'` states that for any two types `α` and `β`, each equipped with a conditionally complete lattice structure, and an order isomorphism `e` from `α` to `β`, if `s` is a nonempty set in `α` that is bounded below, then the image of the infimum (greatest lower bound) of `s` under `e` is equal to the infimum of the image of `s` under `e`. In other words, the order isomorphism `e` preserves the infimum operation from `α` to `β` for sets that are nonempty and have a lower bound.

For order isomorphisms between conditionally complete lattices, the image of the infimum of a nonempty, bounded-below set under the isomorphism is equal to the infimum of the image of that set.


theorem MeasureTheory.isFiniteMeasure_of_le :
    ∀ {α : Type u_1} {m0 : MeasurableSpace α} {ν : MeasureTheory.Measure α} (μ : MeasureTheory.Measure α)
      [inst : MeasureTheory.IsFiniteMeasure μ], ν ≤ μ → MeasureTheory.IsFiniteMeasure ν :=
  by sorry

This theorem states that for any type `α`, given a measurable space `m0` over `α` and two measure theories `ν` and `μ` over `α`, if `μ` is a finite measure and `ν` is less than or equal to `μ`, then `ν` is also a finite measure. In mathematical terms, if `μ` is a finite measure (i.e., the measure of the entire space is finite) and `ν` is a measure such that for all measurable sets `A`, `ν(A) ≤ μ(A)`, then `ν` is also a finite measure.

If `μ` is a finite measure over a measurable space `α` and `ν` is a measure over `α` with `ν(A) ≤ μ(A)` for all measurable sets `A`, then `ν` is also a finite measure.


theorem IsLocalization.coeSubmodule_le_coeSubmodule :
    ∀ {R : Type u_1} [inst : CommRing R] {M : Submonoid R} {S : Type u_2} [inst_1 : CommRing S] [inst_2 : Algebra R S]
      [inst_3 : IsLocalization M S],
      M ≤ nonZeroDivisors R →
        ∀ {I J : Ideal R}, IsLocalization.coeSubmodule S I ≤ IsLocalization.coeSubmodule S J ↔ I ≤ J :=
  by sorry

This theorem states that for any commutative ring `R`, any submonoid `M` of `R`, any type `S` which is also a commutative ring and an `R`-algebra, and for any `S` which is a localization of `M`, if `M` is a subset of non-zero divisors of `R`, then for any two ideals `I` and `J` of `R`, the image of `I` under the submodule construction induced by the localization is a submodule of the image of `J` if and only if `I` is a submodule of `J`. Essentially, the ordering of ideals in `R` is preserved under the localization map. The proof is not displayed here.

For any commutative rings `R` and `S` with `S` being a localization of a submonoid `M` of `R` consisting of non-zero divisors, the submodule relationship between ideals of `R` is preserved under the submodule construction induced by the localization map.


/-- 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 (closure s) t = EMetric.hausdorffEdist s t :=
  by sorry

This theorem states that for any two sets `s` and `t` in a pseudo-emetric space `α`, the Hausdorff edistance (or Hausdorff distance) between the closure of `s` and `t` is equal to the Hausdorff edistance between `s` and `t`. In other words, replacing a set `s` with its closure, which is the smallest closed set containing `s`, does not alter the Hausdorff edistance to another set `t`. This edistance is the smallest `r` such that each set is contained in the `r`-neighborhood of the other one.

The Hausdorff distance between the closures of sets `s` and `t` in a pseudo-metric space equals the Hausdorff distance between `s` and `t`.


theorem Nat.AtLeastTwo.one_lt : ∀ {n : ℕ} [inst : Nat.AtLeastTwo n], 1 < n := by sorry

This theorem states that for any natural number `n` that is at least two, `n` is greater than one. In other words, if a natural number `n` satisfies the property of being at least two (as enforced by `Nat.AtLeastTwo`), then `n` is always strictly larger than one.

For any natural number `n` with `n ≥ 2`, we have `n > 1`.


theorem Nat.coprime_primes : ∀ {p q : ℕ}, Nat.Prime p → Nat.Prime q → (Nat.Coprime p q ↔ p ≠ q) := by sorry

The theorem `Nat.coprime_primes` states that for every two natural numbers `p` and `q`, if `p` and `q` are both prime (i.e., they are natural numbers that are at least 2 and their only divisors are themselves and 1), then `p` and `q` are coprime (i.e., their greatest common divisor is 1) if and only if `p` is not equal to `q`. This reflects the fundamental property of prime numbers, where two different prime numbers do not share any common divisor apart from 1.

If two natural numbers `p` and `q` are both prime, then they are coprime if and only if `p` is not equal to `q`.


theorem ultrafilter_extend_extends :
    ∀ {α : Type u} {γ : Type u_1} [inst : TopologicalSpace γ] [inst_1 : T2Space γ] (f : α → γ),
      Ultrafilter.extend f ∘ pure = f :=
  by sorry

The theorem `ultrafilter_extend_extends` states that for any types `α` and `γ`, where `γ` is a topological space and a T2 space (also known as a Hausdorff space), and given any function `f` from `α` to `γ`, the composition of `Ultrafilter.extend f` and `pure` is equal to `f`. In other words, the extension of the function `f` to the Ultrafilter topology, when applied to elements of `α` (which are made 'pure' by the monadic `pure` operation), is the same as the original function `f`. This shows the 'extendability' of the function `f` to the Ultrafilter topology.

For any function `f` from a type `α` to a T2 topological space `γ`, the extension of `f` to the Ultrafilter topology, composed with the `pure` operation, equals `f`.


theorem Computation.results_of_terminates :
    ∀ {α : Type u} (s : Computation α) [_T : Computation.Terminates s],
      Computation.Results s (Computation.get s) (Computation.length s) :=
  by sorry

The theorem `Computation.results_of_terminates` states that for any computation `s` of type `α` that terminates, `s` returns a result after exactly its computed length number of steps. This result is exactly the one obtained using the `Computation.get` function. In other words, if you have a terminating computation, the result of that computation and the length of the computation (in terms of steps) are perfectly characterized by the `Computation.Results` predicate.

For any terminating computation `s` of type `α` in Lean, the result `Computation.get s` is equal to the value obtained after exactly `Computation.length s` steps.


/-- A version of the **binomial theorem** for commuting elements in noncommutative semirings.  -/
theorem Commute.add_pow :
    ∀ {R : Type u_1} [inst : Semiring R] {x y : R},
      Commute x y →
        ∀ (n : ℕ), (x + y) ^ n = Finset.sum (Finset.range (n + 1)) fun m => x ^ m * y ^ (n - m) * ↑(Nat.choose n m) :=
  by sorry

This theorem is a version of the **binomial theorem** for noncommutative semirings. It states that for any semiring `R`, and any two elements `x` and `y` in `R` that commute (meaning `x * y = y * x`), for any natural number `n`, the `n`-th power of the sum of `x` and `y` equals the sum, taken over all natural numbers less than or equal to `n`, of the product of the `m`-th power of `x`, the `(n - m)`-th power of `y`, and the binomial coefficient `n choose m`. In mathematical notation, this is expressed as `(x + y)^n = Σ_{m=0}^{n} (x^m * y^(n - m) * (n choose m))`.

For any commuting elements `x` and `y` in a semiring `R` and natural number `n`, the `n`-th power of `x + y` equals the sum, over all `m` from `0` to `n`, of the product of `x^m * y^(n - m) * (n choose m)`.


theorem LieSubalgebra.coe_to_submodule :
    ∀ {R : Type u} {L : Type v} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L]
      (L' : LieSubalgebra R L), ↑L'.toSubmodule = ↑L' :=
  by sorry

This theorem states that for any Lie subalgebra `L'` of a Lie algebra `L` over a commutative ring `R`, the coercion of `L'` to a submodule is equal to the coercion of `L'` itself. This ensures that the underlying set of `L'` as a submodule is the same as that of `L'` as a Lie subalgebra, giving consistency across different algebraic structures.

The coercion of a Lie subalgebra of a Lie algebra as a submodule is equal to the subalgebra itself.


theorem Polynomial.degree_X_pow_le :
    ∀ {R : Type u} [inst : Semiring R] (n : ℕ), Polynomial.degree (Polynomial.X ^ n) ≤ ↑n := by sorry

The theorem `Polynomial.degree_X_pow_le` states that, for any semiring `R` and natural number `n`, the degree of the polynomial which is the variable `X` raised to the power `n` (`Polynomial.X ^ n`) is less than or equal to `n`. In other words, the highest power of `X` that appears in the polynomial `X^n` is no greater than `n`.

For any semiring R and natural number n, the degree of the polynomial X^n is less than or equal to n.


theorem ProjectiveSpectrum.gc_homogeneousIdeal :
    ∀ {R : Type u_1} {A : Type u_2} [inst : CommSemiring R] [inst_1 : CommRing A] [inst_2 : Algebra R A]
      (𝒜 : ℕ → Submodule R A) [inst_3 : GradedAlgebra 𝒜],
      GaloisConnection (fun I => ProjectiveSpectrum.zeroLocus 𝒜 ↑I) fun t => ProjectiveSpectrum.vanishingIdeal t :=
  by sorry

This theorem, `ProjectiveSpectrum.gc_homogeneousIdeal`, establishes a Galois connection between the function mapping an ideal `I` to the zero locus in the projective spectrum of a graded algebra `𝒜`, and the function mapping a set `t` to its vanishing ideal in the same projective spectrum. Here, the graded algebra `𝒜` is a function from natural numbers `ℕ` to submodules of an algebra `A` over a commutative semiring `R`. The zero locus of an ideal is the set of all points where the functions in the ideal vanish, and the vanishing ideal of a set is the ideal of all functions that vanish on that set. A Galois connection between two functions `l` and `u` means that for all `a` and `b`, `l a` is less than or equal to `b` if and only if `a` is less than or equal to `u b`.

The function mapping an ideal to its zero locus in the projective spectrum and the function mapping a set to its vanishing ideal form a Galois connection.


theorem Mathlib.Data.Set.Card._auxLemma.33 :
    ∀ {α : Type u} {s : Set α} {a : α} (hs : Set.Finite s), (a ∈ Set.Finite.toFinset hs) = (a ∈ s) := by sorry

This theorem states that for any type `α`, any set `s` of type `α`, and any element `a` of type `α`, if `s` is a finite set, then the membership of `a` in the finite set represented by the finite set `s` is equivalent to the membership of `a` in `s`. In other words, an element is in the `Finset` representation of a finite set if and only if it is in the original set.

For any type `α`, any finite set `s` of type `α`, and any `α` element `a`, `a` is in the finite set `s` if and only if `a` is in the `Finset` representation of `s`.


theorem HomologicalComplex.dTo_eq :
    ∀ {ι : Type u_1} {V : Type u} [inst : CategoryTheory.Category.{v, u} V]
      [inst_1 : CategoryTheory.Limits.HasZeroMorphisms V] {c : ComplexShape ι} (C : HomologicalComplex V c) {i j : ι}
      (r : c.Rel i j),
      HomologicalComplex.dTo C j = CategoryTheory.CategoryStruct.comp (HomologicalComplex.xPrevIso C r).hom (C.d i j) :=
  by sorry

The theorem `HomologicalComplex.dTo_eq` states that, for any two types `ι` and `V`, given `V` is a category with zero morphisms, and `c` is a complex shape of `ι`, for any homological complex `C` of `V` and `c`, and for any two objects `i` and `j` of type `ι` such that the complex shape `c` establishes a relation `r` between `i` and `j`, the differential mapping into `C.X j` is equal to the composition of the isomorphism from `C.xPrev j` to `C.X i` and the differential mapping from `C.X i` to `C.X j`. In other words, the theorem relates the mapping into a point in a homological complex to the composition of an isomorphism and a differential mapping.

For any homological complex over a category with zero morphisms, the differential mapping into a complex's j-th vector is equal to the composition of the isomorphism from the i-th vector to the preceding vector, and the differential mapping from the i-th vector to the j-th vector, for any objects i and j related by the complex's shape.


theorem MeasureTheory.AEStronglyMeasurable.comp_aemeasurable :
    ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace β] {g : α → β} {γ : Type u_5} {x : MeasurableSpace γ}
      {x_1 : MeasurableSpace α} {f : γ → α} {μ : MeasureTheory.Measure γ},
      MeasureTheory.AEStronglyMeasurable g (MeasureTheory.Measure.map f μ) →
        AEMeasurable f μ → MeasureTheory.AEStronglyMeasurable (g ∘ f) μ :=
  by sorry

The theorem `MeasureTheory.AEStronglyMeasurable.comp_aemeasurable` states that for any given types `α`, `β`, and `γ`, topological space `β`, function `g` from `α` to `β`, measurable spaces `x` for `γ` and `x_1` for `α`, function `f` from `γ` to `α`, and a measure `μ` over `γ`, if `g` is almost everywhere strongly measurable with respect to the pushforward of measure `μ` by `f`, and `f` is almost everywhere measurable with respect to the measure `μ`, then the composition of `g` and `f` (i.e., `g ∘ f`) is almost everywhere strongly measurable with respect to the measure `μ`.

In other words, under the described conditions, almost everywhere strong measurability and almost everywhere measurability are preserved under function composition.

If functions `f` and `g` are almost everywhere measurable with respect to a measure `μ`, and `g` is almost everywhere strongly measurable with respect to the pushforward of `μ` by `f`, then their composition `g ∘ f` is almost everywhere strongly measurable with respect to `μ`.


theorem Filter.eventually_sub_nonneg :
    ∀ {α : Type u} {β : Type v} [inst : OrderedRing β] {l : Filter α} {f g : α → β}, 0 ≤ᶠ[l] g - f ↔ f ≤ᶠ[l] g := by
  sorry

The theorem `Filter.eventually_sub_nonneg` states that for any two functions `f` and `g` from a type `α` to an ordered ring `β` and any filter `l` on `α`, the difference `g - f` is nonnegative eventually (at some point and for all points thereafter) with respect to filter `l` if and only if `f` is lesser than or equal to `g` eventually with respect to the same filter. The direction of implication goes both ways: if the difference is nonnegative, then `f` is less than or equal to `g`, and vice versa.

For any functions $f, g : \alpha \to \beta$ from a type $\alpha$ to an ordered ring $\beta$, and any filter $l$ on $\alpha$, the difference $g - f$ is eventually nonnegative with respect to $l$ if and only if $f$ is eventually less than or equal to $g$ with respect to $l$.


theorem ENNReal.toReal_add : ∀ {a b : ENNReal}, a ≠ ⊤ → b ≠ ⊤ → (a + b).toReal = a.toReal + b.toReal := by sorry

The theorem `ENNReal.toReal_add` states that for any two elements `a` and `b` of the extended nonnegative real numbers (which are typically denoted as [0, ∞] and are relevant as the codomain of a measure), given that neither of them is the top element, the real part of their sum equals the sum of their real parts. This is a property ensuring the consistency of the 'toReal' operation with addition in the extended nonnegative real numbers.

For any `a, b` in the extended nonnegative real numbers with `a, b` not top element, `(toReal a + toReal b) = toReal (a + b)`.


/-- **Alias** of `Left.one_le_inv_iff`.

---

Uses `left` co(ntra)variant.  -/
theorem one_le_inv' :
    ∀ {α : Type u} [inst : Group α] [inst_1 : LE α]
      [inst_2 : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1] {a : α}, 1 ≤ a⁻¹ ↔ a ≤ 1 :=
  by sorry

This theorem, `one_le_inv'`, states that for any type `α` that forms a group and has a less than or equal to (`≤`) operation, and also satisfies a certain covariant class property related to multiplication and the `≤` operation, the inverse `a⁻¹` of an element `a` of `α` is greater than or equal to 1 if and only if `a` is less than or equal to 1. This theorem uses the `left` covariant.

For any group `α` with a `≤` operation satisfying a certain covariant property, `a≤1` if and only if `1≤a⁻¹`.


/-- In a linear ordered field, for positive `a` and `b` we have `a⁻¹ ≤ b ↔ b⁻¹ ≤ a`.
See also `inv_le_of_inv_le` for a one-sided implication with one fewer assumption.  -/
theorem inv_le : ∀ {α : Type u_2} [inst : LinearOrderedSemifield α] {a b : α}, 0 < a → 0 < b → (a⁻¹ ≤ b ↔ b⁻¹ ≤ a) := by
  sorry

This theorem states that in any linearly ordered semi-field, if `a` and `b` are positive, then the reciprocal of `a` is less than or equal to `b` if and only if the reciprocal of `b` is less than or equal to `a`. This is a sort of 'reciprocal comparison' property of elements in these structures. There is also a related theorem `inv_le_of_inv_le` that provides a one-sided implication with one less assumption.

In a linearly ordered semi-field, the reciprocal of one positive element is less than or equal to another if and only if the reciprocal of the other is less than or equal to the first.


Filter.IsBoundedUnder.comp

theorem Filter.IsBoundedUnder.comp :
    ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {r : α → α → Prop} {l : Filter γ} {q : β → β → Prop} {u : γ → α}
      {v : α → β},
      (∀ (a₀ a₁ : α), r a₀ a₁ → q (v a₀) (v a₁)) → Filter.IsBoundedUnder r l u → Filter.IsBoundedUnder q l (v ∘ u) :=
  by sorry

This theorem states that given types α, β, and γ, a relation 'r' on α, a filter 'l' over γ, a relation 'q' on β, a function 'u' from γ to α, and a function 'v' from α to β, if for any two elements a₀, a₁ of type α, the relation 'r' on a₀ and a₁ implies the relation 'q' on the images of a₀ and a₁ under 'v', and if the image of the filter 'l' under 'u' is eventually bounded with respect to 'r', then the image of the filter 'l' under the composition of 'v' and 'u' is eventually bounded with respect to 'q'. In other words, the boundedness condition under a function and a relation can be maintained under function composition and relation implication.

If a filter is eventually bounded under a relation-preserving function composed with a function whose image is eventually bounded under a relation, then the image of the filter under the composition is eventually bounded under the relation.


/-- For positive `a` and `b`, the prime factors of `a * b` are the union of those of `a` and `b`  -/
theorem Nat.perm_factors_mul :
    ∀ {a b : ℕ}, a ≠ 0 → b ≠ 0 → List.Perm (Nat.factors (a * b)) (Nat.factors a ++ Nat.factors b) := by sorry

This theorem states that for any two positive numbers `a` and `b`, the prime factorization of their product `a * b` is a permutation of the concatenation of the prime factorizations of `a` and `b`. That is, the prime factors of `a * b` are exactly the collection of the prime factors of `a` and `b`, possibly rearranged.

The product of two positive numbers has the same prime factors, possibly in a different order, as the concatenation of their prime factorizations.


theorem Pi.toLex_strictMono :
    ∀ {ι : Type u_1} {β : ι → Type u_2} [inst : LinearOrder ι] [inst_1 : IsWellOrder ι fun x x_1 => x < x_1]
      [inst_2 : (i : ι) → PartialOrder (β i)], StrictMono ⇑toLex :=
  by sorry

The theorem `Pi.toLex_strictMono` states that for all types `ι` with a linear order and well-order properties, and all type families `β` indexed by `ι` with a partial order on each type, the function `toLex`, which is an identity function on `Lex` of a type, is strictly monotone. In other words, if `a` and `b` are elements of `ι` and `a < b`, then `toLex(a) < toLex(b)`. This suggests that `toLex` preserves the order of elements, which is a key property for many mathematical structures and algorithms.

For any type `ι` with linear and well-order properties, and type family `β` over `ι` with a partial order, the function `toLex : ι → Lex β` is strictly monotone with respect to the linear order on `ι`.


/-- If two additive homomorphisms from `Π₀ i, β i` are equal on each `single a b`, then
they are equal.

See note [partially-applied ext lemmas].  -/
theorem DFinsupp.addHom_ext' :
    ∀ {ι : Type u} {β : ι → Type v} [inst : DecidableEq ι] [inst_1 : (i : ι) → AddZeroClass (β i)] {γ : Type w}
      [inst_2 : AddZeroClass γ] ⦃f g : (Π₀ (i : ι), β i) →+ γ⦄,
      (∀ (x : ι), AddMonoidHom.comp f (DFinsupp.singleAddHom β x) = AddMonoidHom.comp g (DFinsupp.singleAddHom β x)) →
        f = g :=
  by sorry

This theorem states that if we have two additive homomorphisms `f` and `g` from the direct sum of a family of additive monoids `β i` (for `i` in some index set `ι`) to another additive monoid `γ`, and if these two homomorphisms are equal when composed with the additive homomorphism corresponding to the `single a b` operation for every `a` in the index set `ι`, then `f` and `g` are equal. Here, the `single a b` operation is defined as inserting an element `b` from `β a` into the direct sum in the position corresponding to `a`. The proof of this theorem relies on the properties of additive homomorphisms and the structure of the direct sum.

If two additive homomorphisms from the direct sum of a family of additive monoids to another additive monoid agree on the `single a b` operation for every index `a`, then they are equal.


theorem inv_mul_eq_div : ∀ {α : Type u_1} [inst : DivisionCommMonoid α] (a b : α), a⁻¹ * b = b / a := by sorry

This theorem, named `inv_mul_eq_div`, states that for any Division Commutative Monoid type `α` and any two elements `a` and `b` of this type, the multiplication of the inverse of `a` and `b` is equal to the result of dividing `b` by `a`. In mathematical language, it asserts that $a^{-1} * b = \frac{b}{a}$ for any `a` and `b` in the Division Commutative Monoid.

For any element `a` and `b` in a Division Commutative Monoid, `a^(-1) * b = b / a`.


theorem sdiff_le_sdiff_left :
    ∀ {α : Type u_2} [inst : GeneralizedCoheytingAlgebra α] {a b c : α}, a ≤ b → c \ b ≤ c \ a := by sorry

This theorem defines a property of generalized coheyting algebras. In particular, it states that for any given type `α` that forms a generalized coheyting algebra, if `a` is less than or equal to `b`, then the difference of `c` and `b` is less than or equal to the difference of `c` and `a`. Here, '\ ' denotes the operation of set-difference in the algebra.

For any type `α` forming a generalized cohetning algebra in Lean 4 and any elements `a ≤ b` in `α`, we have `b \ a ≤ c \ a` for any `c` in `α`.


theorem Subgroup.inf_relindex_right :
    ∀ {G : Type u_1} [inst : Group G] (H K : Subgroup G), Subgroup.relindex (H ⊓ K) K = Subgroup.relindex H K := by
  sorry

This theorem states that for any type `G` with a group structure and for any two subgroups `H` and `K` of `G`, the relative index of the intersection of `H` and `K` with `K` is equal to the relative index of `H` with `K`. In mathematical terms, it asserts that if `H` and `K` are subgroups of a group `G`, then the relative index of `H ∩ K` in `K` (`[K : H ∩ K]`) is equal to the relative index of `H` in `K` (`[K : H]`). This relative index is defined as the index of the subgroup formed by the subset of `H` within `K` (or equivalently, the quotient of the order of `K` by the order of `H`), giving the number of left cosets of `H` in `K`, or returning zero if this number is infinite.

For any groups G, H, and K with H, K subgroups of G, the index of H in K equals the index of H ∩ K in K.


theorem Mathlib.Combinatorics.SetFamily.Shadow._auxLemma.4 :
    ∀ {α : Type u_1} {s t : Finset α} [inst : DecidableEq α], (t ⊆ s ∧ (s \ t).card = 1) = (t ⋖ s) := by sorry

This theorem, `Mathlib.Combinatorics.SetFamily.Shadow._auxLemma.4`, states that for any type `α`, and for any finite sets `s` and `t` of type `α` where equality of elements in `α` is decidable, the statement that `t` is a subset of `s` and the cardinality of the set difference `s \ t` is one, is equivalent to `t` being a shadow of `s`. The shadow of a set `s`, denoted `t ⋖ s`, is a concept in combinatorics referring to all sets that can be obtained from `s` by removing one element.

For any type `α` with decidable equality and finite sets `s` and `t` of type `α`, `t` being a subset of `s` with cardinality difference equal to one is equivalent to `t` being a shadow of `s`.


/-- An `R`-finite torsion-free module has positive `finrank` iff it is nontrivial.  -/
theorem FiniteDimensional.finrank_pos_iff :
    ∀ {R : Type u} {M : Type v} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] [inst_3 : Nontrivial R]
      [inst_4 : StrongRankCondition R] [inst_5 : Module.Finite R M] [inst_6 : NoZeroSMulDivisors R M],
      0 < FiniteDimensional.finrank R M ↔ Nontrivial M :=
  by sorry

This theorem states that for a module `M` over a ring `R`, which is both torsion-free and finite (`Module.Finite R M`), and meets the conditions of being non-trivial (`Nontrivial R`) and satisfying the strong rank condition (`StrongRankCondition R`), it has a positive rank (`0 < FiniteDimensional.finrank R M`) if and only if the module `M` itself is non-trivial (`Nontrivial M`). Here, 'non-trivial' refers to the property that the module contains an element that is not the zero element, and 'torsion-free' means that there is no non-zero scalar in `R` that multiplies a non-zero element of `M` to give the zero element in `M`.

A finite, torsion-free module over a ring with the strong rank condition is non-trivial if and only if it has positive rank.


/-- If an element `b` becomes right-regular after multiplying it on the right by a right-regular
element, then `b` is right-regular.  -/
theorem IsRightRegular.of_mul :
    ∀ {R : Type u_1} [inst : Semigroup R] {a b : R}, IsRightRegular (b * a) → IsRightRegular b := by sorry

The theorem `IsRightRegular.of_mul` states that, for any type `R` that forms a semigroup under multiplication, given elements `a` and `b` of `R`, if `b` multiplied on the right by `a` is a right-regular element (meaning that multiplication on the right by `b * a` is an injective operation), then `b` itself is right-regular. This means that multiplying any element of `R` on the right by `b` yields a unique result, with no two different elements of `R` giving the same product when multiplied by `b`.

If `b * a` is right-regular in a semigroup `R`, then `b` is right-regular.


List.Ico.mem

theorem List.Ico.mem : ∀ {n m l : ℕ}, l ∈ List.Ico n m ↔ n ≤ l ∧ l < m := by sorry

The theorem `List.Ico.mem` asserts that for any three natural numbers `n`, `m`, and `l`, `l` is a member of the interval list from `n` to `m` (denoted `List.Ico n m` in Lean) if and only if `l` is greater than or equal to `n` and less than `m`. In other words, `l` belongs to the closed-open interval `[n, m)` in the natural numbers. This theorem provides a condition for membership in this specific type of list of natural numbers in Lean.

For any natural numbers n, m, and l, l belongs to the interval List.Ico n m if and only if n <= l < m.


theorem ProbabilityTheory.IsMeasurableRatCDF.stieltjesFunctionAux_def :
    ∀ {α : Type u_4} (f : α → ℚ → ℝ) (a : α) (x : ℝ),
      ProbabilityTheory.IsMeasurableRatCDF.stieltjesFunctionAux f a x = ⨅ q, f a ↑q :=
  by sorry

This theorem states that for any type `α`, for any function `f` from `α` to rational numbers to real numbers, and for any elements `a` of `α` and `x` of real numbers, the operation of `IsMeasurableRatCDF.stieltjesFunctionAux` applied to `f`, `a`, and `x` is equal to the infimum of applying `f` to `a` and the real number representation of a rational number `q`. In more informal terms, it asserts that the stieltjesFunctionAux operation extracts the smallest value of `f` over all rational numbers greater than `x` for a fixed `a`.

For any type `α`, any function `f` from `α` to rational numbers to real numbers, and any `a` of type `α` and `x` of type real, the value of `IsMeasurableRatCDF.stieltjesFunctionAux` on `f`, `a`, and `x` equals the infimum of `f a` and the real number representation of the greatest rational number `q` less than or equal to `x`.


theorem Associates.mk_mul_mk :
    ∀ {α : Type u_1} [inst : CommMonoid α] {x y : α}, Associates.mk x * Associates.mk y = Associates.mk (x * y) := by
  sorry

This theorem, `Associates.mk_mul_mk`, states that for any type `α` that is a commutative monoid, and any two elements `x` and `y` of `α`, the product of the canonical quotient mappings of `x` and `y` into the `Associates` of `α` is equal to the canonical quotient mapping of the product of `x` and `y`. In other words, the function `Associates.mk` preserves the multiplication operation from the original monoid to the `Associates` structure.

For any commutative monoid `α` and its elements `x` and `y`, the canonical quotient mappings of `x` and `y` into the `Associates` of `α` are equal to the canonical quotient mapping of the product of `x` and `y`.


Function.Involutive.leftInverse

theorem Function.Involutive.leftInverse :
    ∀ {α : Sort u} {f : α → α}, Function.Involutive f → Function.LeftInverse f f := by sorry

The theorem `Function.Involutive.leftInverse` states that for any type `α` and any function `f : α → α`, if `f` is an involutive function (meaning that applying `f` twice to any element gives back the original element, i.e., `f ∘ f = id`), then `f` is its own left inverse. In other words, `f` composed with itself equals the identity function, which can be written as `f ∘ f = id`.

If a function `f : α → α` is involutive (i.e., `f ∘ f = id`), then `f` is its own left inverse (i.e., `f ∘ f = id = id ∘ f`).


theorem MeasureTheory.monotone_lintegral :
    ∀ {α : Type u_1} {x : MeasurableSpace α} (μ : MeasureTheory.Measure α), Monotone (MeasureTheory.lintegral μ) := by
  sorry

The theorem `MeasureTheory.monotone_lintegral` states that for any measurable space `α` and any measure `μ` on this space, the function `MeasureTheory.lintegral μ` is monotone. In other words, given two functions `a` and `b` from `α` to the extended non-negative real numbers such that `a ≤ b`, it follows that the lower Lebesgue integral of `a` with respect to `μ` is less than or equal to the lower Lebesgue integral of `b` with respect to `μ`. This property is crucial in many parts of measure theory and integration theory.

For any measurable space and measure, the integral operator is monotone, i.e., if `a ≤ b` are measurable functions, then `∫(a) dμ ≤ ∫(b) dμ`.


ContinuousLinearMap.hasDerivAt

theorem ContinuousLinearMap.hasDerivAt :
    ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {F : Type v} [inst_1 : NormedAddCommGroup F]
      [inst_2 : NormedSpace 𝕜 F] {x : 𝕜} (e : 𝕜 →L[𝕜] F), HasDerivAt (⇑e) (e 1) x :=
  by sorry

The theorem `ContinuousLinearMap.hasDerivAt` states that, for any type `𝕜` endowed with a non-trivially normed field structure, any type `F` forming a normed additive commutative group over `𝕜`, and any element `x` from `𝕜`, if `e` is a continuous linear map from `𝕜` to `F`, then `e` has a derivative at every point `x` in `𝕜`, and the derivative is `e` applied to `1`. In other words, this theorem ensures that the derivative of a continuous linear map is just the map itself applied to one, and this holds true at any point in the domain.

For any normed field `𝕜`, normed additive commutative group `F` over `𝕜`, and continuous linear map `e` from `𝕜` to `F`, the derivative of `e` at any point `x` in `𝕜` is `e` itself.


theorem MeasureTheory.snorm_neg :
    ∀ {α : Type u_1} {F : Type u_3} {m0 : MeasurableSpace α} {p : ENNReal} {μ : MeasureTheory.Measure α}
      [inst : NormedAddCommGroup F] {f : α → F}, MeasureTheory.snorm (-f) p μ = MeasureTheory.snorm f p μ :=
  by sorry

The theorem `MeasureTheory.snorm_neg` states that the seminorm of the negative of a function `f`, under certain conditions, is equal to the seminorm of the function `f` itself. Specifically, for any measurable space `α`, any normed additive commutative group `F`, any measure `μ` on `α`, any extended nonnegative real number `p`, and any function `f` from `α` to `F`, we have `MeasureTheory.snorm (-f) p μ = MeasureTheory.snorm f p μ`. In simpler terms, taking the negative of a function does not change its `ℒp` seminorm, whether `p` is zero, positive but finite, or infinity.

For any measurable function `f` from a measurable space to a normed additive commutative group, and for any measure and `ℒp` norm, the `ℒp` seminorm of the negative of `f` is equal to that of `f`.


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

This theorem states that for any four natural numbers `a`, `b`, `c`, and `d`, if `a` divides `b` and `c` divides `d`, then the product of `a` and `c` divides the product of `b` and `d`. In mathematical notation, if $a | b$ and $c | d$, then $a \cdot c | b \cdot d$.

If `a` divides `b` and `c` divides `d`, then `a * c` divides `b * d`.


theorem AffineMap.lineMap_apply_one_sub :
    ∀ {k : Type u_1} {V1 : Type u_2} {P1 : Type u_3} [inst : Ring k] [inst_1 : AddCommGroup V1] [inst_2 : Module k V1]
      [inst_3 : AddTorsor V1 P1] (p₀ p₁ : P1) (c : k),
      (AffineMap.lineMap p₀ p₁) (1 - c) = (AffineMap.lineMap p₁ p₀) c :=
  by sorry

This theorem states that for any ring `k`, additive commutative group `V1`, and affine torsor `P1`, given any two points `p₀` and `p₁` in `P1` and any scalar `c` in `k`, the result of applying the affine map `lineMap` that maps `0` to `p₀` and `1` to `p₁`, to the scalar `(1 - c)` is the same as the result of applying the affine map `lineMap` that maps `0` to `p₁` and `1` to `p₀`, to the scalar `c`. In other words, it illustrates a kind of symmetry in how the `lineMap` function operates on points and scalars in an affine space.

For any ring `k`, additive commutative group `V1`, affine torsor `P1`, points `p₀, p₁ ∈ P1`, and scalar `c ∈ k`, `lineMap(0, p₀, p₁)(1 - c) = lineMap(0, p₁, p₀)(c)`.


UniformCauchySeqOn.prod'

theorem UniformCauchySeqOn.prod' :
    ∀ {α : Type u} {β : Type v} {ι : Type x} [inst : UniformSpace β] {F : ι → α → β} {s : Set α} {p : Filter ι}
      {β' : Type u_1} [inst_1 : UniformSpace β'] {F' : ι → α → β'},
      UniformCauchySeqOn F p s → UniformCauchySeqOn F' p s → UniformCauchySeqOn (fun i a => (F i a, F' i a)) p s :=
  by sorry

This theorem states that for any two sequences `F` and `F'` of type `ι → α → β` and `ι → α → β'` respectively, with `β` and `β'` being types equipped with a uniform space structure, and a filter `p` of type `ι` and a set `s` of type `α`. If `F` and `F'` are both uniformly Cauchy on `p` and `s`, then the sequence formed by pairing the corresponding elements of `F` and `F'` is also uniformly Cauchy on `p` and `s`.

In simpler terms, if we have two sequences that converge uniformly, then the sequence formed by taking pairs of elements from these two sequences also converges uniformly.

If `F` and `F'` are two uniformly Cauchy sequences of functions from `ι` to `α` to `β` and `β'` respectively, where `β` and `β'` are uniform spaces, and `p` is a filter on `ι` and `s` is a set of `α`, then the sequence of pairs `(F x) (F' x)` is uniformly Cauchy on `p` and `s`.


theorem Vector.mOfFn_part_some :
    ∀ {α : Type u_1} {n : ℕ} (f : Fin n → α), (Vector.mOfFn fun i => Part.some (f i)) = Part.some (Vector.ofFn f) := by
  sorry

The theorem `Vector.mOfFn_part_some` states that for any type `α` and natural number `n`, given a function `f` that maps `Fin n` (a finite set of size `n`) to `α`, the monadic function operation `Vector.mOfFn` applied on `Part.some` of the function `f` (which transforms the function value into a `Part` type with domain `True`) is equal to `Part.some` of the `Vector.ofFn` applied on `f`. In simpler terms, this theorem describes how the operation of creating a vector from a function and then wrapping it with the `Part.some` function is equivalent to first wrapping each function value with `Part.some` and then creating a vector from these values.

Given a function `f` from `Fin n` to type `α`, `Vector.mOfFn (Part.some f) = Part.some (Vector.ofFn f)`.


theorem Function.Semiconj₂.iterate :
    ∀ {α : Type u} {f : α → α} {op : α → α → α},
      Function.Semiconj₂ f op op → ∀ (n : ℕ), Function.Semiconj₂ f^[n] op op :=
  by sorry

The theorem `Function.Semiconj₂.iterate` states that for any type `α`, any function `f` from `α` to `α`, and any binary operation `op` on `α`, if `f` semiconjugates `op` to `op` (meaning that for all `x` and `y` in `α`, applying `f` after `op` is the same as applying `op` after `f`), then for any natural number `n`, the `n`-th iterate of `f` (i.e., applying `f` `n` times in succession) also semiconjugates `op` to `op`. In other words, the property of semiconjugating a binary operation is preserved under iteration of the function.

If a function semiconjugates a binary operation, then the iteration of the function also semiconjugates the binary operation.


theorem LinearMap.mul_apply :
    ∀ {R : Type u_1} {M : Type u_5} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
      (f g : Module.End R M) (x : M), (f * g) x = f (g x) :=
  by sorry

The theorem `LinearMap.mul_apply` states that for any semiring `R`, any additive commutative monoid `M`, with `M` being a module over `R`, and any two endomorphisms `f` and `g` of `M` defined over `R`, the multiplication of `f` and `g` applied to an element `x` of `M` (i.e., `(f * g) x`) is equal to `f` applied to the result of `g` applied to `x` (i.e., `f (g x)`). In other words, the multiplication operation on linear endomorphisms corresponds to the composition of those endomorphisms.

For any semiring R, additive commutative monoid M being an R-module, and endomorphisms f and g of M, we have (f * g) x = f (g x) for all x in M, i.e., multiplication of endomorphisms corresponds to their composition.


theorem Computable.option_some : ∀ {α : Type u_1} [inst : Primcodable α], Computable some := by sorry

This theorem states that for any type `α` that has an instance of `Primcodable`, the function `some` (which wraps a value in an option) is computable. In other words, if we can encode and decode values of type `α`, then we can also effectively compute the function that takes a value of `α` and produces its 'option' version.

If `α` has an instance of `Primcodable`, then the `some` function from `α` to `option α` is computable.


theorem Subgroup.map_sup :
    ∀ {G : Type u_1} [inst : Group G] {N : Type u_5} [inst_1 : Group N] (H K : Subgroup G) (f : G →* N),
      Subgroup.map f (H ⊔ K) = Subgroup.map f H ⊔ Subgroup.map f K :=
  by sorry

The theorem `Subgroup.map_sup` states that for any two subgroups `H` and `K` of a group `G`, and any group homomorphism `f` from `G` to another group `N`, the image of the join (supremum) of `H` and `K` under `f` is equal to the join (supremum) of the images of `H` and `K` under `f`. In other words, the map of the union of two subgroups is the union of the maps of the subgroups, preserving the structure of subgroups under the homomorphism.

For any group homomorphism \(f : G \rightarrow N\) and subgroups \(H, K \subseteq G\), \(f(\sup H \cup K) = \sup f(H) \cup f(K)\).


theorem OrderIso.comap_atTop :
    ∀ {α : Type u_3} {β : Type u_4} [inst : Preorder α] [inst_1 : Preorder β] (e : α ≃o β),
      Filter.comap (⇑e) Filter.atTop = Filter.atTop :=
  by sorry

The theorem `OrderIso.comap_atTop` states that for any two preordered types `α` and `β` and an order isomorphism `e` between them, the preimage (or inverse image) under `e` of the filter representing the limit towards infinity in `β` is the filter representing the limit towards infinity in `α`. In other words, pulling back the "towards infinity" filter along an order isomorphism doesn't change the filter.

For any order isomorphism between preordered types `α` and `β`, the inverse image of the filter of limit points in `β` is the filter of limit points in `α`.


theorem CategoryTheory.prod_comp :
    ∀ (C : Type u₁) [inst : CategoryTheory.Category.{v₁, u₁} C] (D : Type u₂)
      [inst_1 : CategoryTheory.Category.{v₂, u₂} D] {P Q R : C} {S T U : D} (f : (P, S) ⟶ (Q, T)) (g : (Q, T) ⟶ (R, U)),
      CategoryTheory.CategoryStruct.comp f g =
        (CategoryTheory.CategoryStruct.comp f.1 g.1, CategoryTheory.CategoryStruct.comp f.2 g.2) :=
  by sorry

This theorem, `CategoryTheory.prod_comp`, states that for any two categories `C` and `D` with any three objects `P, Q, R` from `C` and `S, T, U` from `D`, and any two morphisms `f` and `g` such that `f` is from `(P, S)` to `(Q, T)` and `g` is from `(Q, T)` to `(R, U)`, the composition of the morphisms `f` and `g` in the product category is equal to the pair of the compositions of the corresponding morphisms in the original categories `C` and `D`. In other words, composing morphisms in a product category is the same as composing the corresponding morphisms in the factors of the product, taken componentwise.

In the product category of two categories C and D, the composition of morphisms (f : P → Q in C) and (g : Q → R in D), where P, Q, R are objects from C and S, T, U are objects from D, is equal to the pair of the compositions of f and g in C and D, respectively.


List.Perm.erase

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

This theorem states that for any type `α` with decidable equality, and any element `a` of this type, if two lists `l₁` and `l₂` of elements of type `α` are permutations of each other, then the lists resulting from erasing the element `a` from `l₁` and `l₂` are also permutations of each other. In other words, the operation of erasing a given element preserves the permutation relation between two lists.

For types `α` with decidable equality and any element `a` in `α`, if lists `l₁` and `l₂` of `α` are permutations of each other, then the lists obtained by removing `a` from `l₁` and `l₂` are also permutations of each other.


theorem inv_surjective : ∀ {G : Type u_3} [inst : InvolutiveInv G], Function.Surjective Inv.inv := by sorry

The theorem `inv_surjective` states that for all types `G` that have an involutive inverse structure (denoted `[inst : InvolutiveInv G]`), the inversion function (defined as `Inv.inv`) is surjective. In other words, for every element `g` in `G`, there exists some element `h` in `G` such that when `h` is inverted, it equals `g`. This is a fundamental property in the study of algebraic structures with inversion.

For every type `G` equipped with an involutive inverse structure, the inversion function is a surjection.


theorem List.mem_ofFn : ∀ {α : Type u} {n : ℕ} (f : Fin n → α) (a : α), a ∈ List.ofFn f ↔ a ∈ Set.range f := by sorry

This theorem, `List.mem_ofFn`, states that for any type `α`, any natural number `n`, any function `f` from the finite set `Fin n` to `α`, and any element `a` of type `α`, `a` belongs to the list generated by applying `f` to each element in `Fin n` if and only if `a` belongs to the range of `f`. In other words, an element is in the list produced by a function when it is applied to the finite set if and only if it is in the set of values that the function can produce.

For any type `α`, natural number `n`, function `f` from `Fin n` to `α`, and `a` in `α`, `a` is in the list `[f x | x ∈ Fin n]` if and only if `a` is in the range of `f`.


theorem Mathlib.GroupTheory.MonoidLocalization._auxLemma.6 :
    ∀ {M : Type u_1} [inst : CommMonoid M] {S : Submonoid M} {a c : M} {b d : ↥S},
      (Localization.mk a b = Localization.mk c d) = (Localization.r S) (a, b) (c, d) :=
  by sorry

This theorem states that for any commutative monoid `M` and any submonoid `S` of `M`, and for any elements `a`, `c` of `M` and `b`, `d` of `S`, the equality of two localizations `Localization.mk a b` and `Localization.mk c d` is equivalent to the congruence of the pairs `(a, b)` and `(c, d)` under the congruence relation `Localization.r S` defined on `M × S`. In other words, two localizations are equal if and only if their associated pairs are related by the specific congruence relation that characterizes the localization.

For any commutative monoid `M` and submonoid `S`, two localizations `Localization.mk a b` and `Localization.mk c d` of `M` with respect to `S` are equal if and only if `(a, b)` and `(c, d)` are related by the congruence relation `Localization.r S` on `M × S`.


/-- For a bounded set `s : Set ℝ`, its `EMetric.diam` is equal to `sSup s - sInf s` reinterpreted as
`ℝ≥0∞`.  -/
theorem Real.ediam_eq : ∀ {s : Set ℝ}, Bornology.IsBounded s → EMetric.diam s = ENNReal.ofReal (sSup s - sInf s) := by
  sorry

This theorem states that for any set of real numbers `s` that is bounded (as specified by the condition `Bornology.IsBounded s`), the diameter of the set `s` (given by `EMetric.diam s`) is equal to the supremum of the set `s` (`sSup s`) minus its infimum (`sInf s`). This difference is then converted to the type `ℝ≥0∞` (non-negative extended real numbers) using the function `ENNReal.ofReal`. The diameter of a set in this context refers to the greatest distance between any two points in the set, and `sSup` and `sInf` represent the least upper bound and the greatest lower bound of the set, respectively.

For any bounded set of real numbers `s`, the diameter is equal to the supremum minus the infimum, or equivalently, the difference between the supremum and infimum of `s` in the extended real numbers.


theorem Fin.succ_inj : ∀ {n : ℕ} {a b : Fin n}, Fin.succ a = Fin.succ b ↔ a = b := by sorry

The theorem `Fin.succ_inj` states that for any natural number `n` and any two elements `a` and `b` of the finite set of natural numbers less than `n` (denoted as `Fin n`), the function `Fin.succ` being equal on `a` and `b` (i.e., `Fin.succ a = Fin.succ b`) is equivalent to `a` being equal to `b` (i.e., `a = b`). In other words, the function `Fin.succ`, which adds 1 to a given natural number while ensuring that the result is still less than the incremented natural number `n+1`, is injective (or one-to-one).

The function `Fin.succ` from the finite set `Fin n` to itself is injective, i.e., `Fin.succ a = Fin.succ b` implies `a = b`.


theorem HomologicalComplex.from_single_hom_ext :
    ∀ {V : Type u} [inst : CategoryTheory.Category.{v, u} V] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms V]
      [inst_2 : CategoryTheory.Limits.HasZeroObject V] {ι : Type u_1} [inst_3 : DecidableEq ι] (c : ComplexShape ι)
      {K : HomologicalComplex V c} {j : ι} {A : V} {f g : (HomologicalComplex.single V c j).obj A ⟶ K},
      f.f j = g.f j → f = g :=
  by sorry

The theorem `HomologicalComplex.from_single_hom_ext` states that for any category `V` with zero morphisms and zero object, any complex shape `c`, any homological complex `K` on `V` with shape `c`, any object `j` from a type `ι` with decidable equality, and any object `A` from `V`, if we have two morphisms `f` and `g` from the single-object homological complex at `j` with object `A` to `K`, then if the morphism at `j` in `f` is equal to the morphism at `j` in `g`, it follows that `f` and `g` are equal. This theorem is essential in homological algebra for comparing morphisms between homological complexes.

Given a homological complex `K` on a zero object category `V` with decidable equality, two morphisms `f` and `g` from the single-object complex at `j` with object `A` to `K` having equal morphism at `j`, imply `f = g`.


theorem PartENat.withTopEquiv_natCast : ∀ (n : ℕ), PartENat.withTopEquiv ↑n = ↑n := by sorry

The theorem `PartENat.withTopEquiv_natCast` states that for all natural numbers `n`, the equivalence between `PartENat` and the extended natural numbers `ℕ∞` (which is defined by the function `PartENat.withTopEquiv`), when applied to the embedding of `n` into `PartENat` (denoted by `↑n`), results in the embedding of `n` into `ℕ∞` (also denoted by `↑n`). In other words, this theorem asserts that the equivalence preserves the embedding of natural numbers into these two types.

The theorem `PartENat.withTopEquiv_natCast` asserts that the natural number embedding function `↑` is preserved under the equivalence `PartENat.withTopEquiv` between `PartENat` and `ℕ∞`.


CliffordAlgebra.induction

/-- If `C` holds for the `algebraMap` of `r : R` into `CliffordAlgebra Q`, the `ι` of `x : M`,
and is preserved under addition and muliplication, then it holds for all of `CliffordAlgebra Q`.

See also the stronger `CliffordAlgebra.left_induction` and `CliffordAlgebra.right_induction`.
 -/
theorem CliffordAlgebra.induction :
    ∀ {R : Type u_1} [inst : CommRing R] {M : Type u_2} [inst_1 : AddCommGroup M] [inst_2 : Module R M]
      {Q : QuadraticForm R M} {C : CliffordAlgebra Q → Prop},
      (∀ (r : R), C ((algebraMap R (CliffordAlgebra Q)) r)) →
        (∀ (x : M), C ((CliffordAlgebra.ι Q) x)) →
          (∀ (a b : CliffordAlgebra Q), C a → C b → C (a * b)) →
            (∀ (a b : CliffordAlgebra Q), C a → C b → C (a + b)) → ∀ (a : CliffordAlgebra Q), C a :=
  by sorry

This theorem states that for any commutative ring `R`, any additive commutative group `M` that is also an `R`-module, and any quadratic form `Q` on `M`, if a property `C` holds for the algebraic mapping of an element `r` of `R` into the Clifford algebra `CliffordAlgebra Q`, and for the canonical linear map `ι` of an element `x` from `M` into `CliffordAlgebra Q`, moreover, if this property `C` is preserved under both the multiplication and addition of the elements of `CliffordAlgebra Q`, then it must hold for all elements of `CliffordAlgebra Q`.

This induction principle is quite powerful, as it allows us to prove properties about all elements of the Clifford algebra, provided we can prove them for elements coming from the base ring and module and show that they are preserved under the algebraic operations.

Given a commutative ring `R`, an `R`-module `M` with a quadratic form `Q`, if a property `C` holds for all elements of `CliffordAlgebra Q` that map from `R` and `M`, and is closed under multiplication and addition in `CliffordAlgebra Q`, then `C` holds for all elements of `CliffordAlgebra Q`.


theorem Localization.neg_mk :
    ∀ {R : Type u_1} [inst : CommRing R] {M : Submonoid R} (a : R) (b : ↥M),
      -Localization.mk a b = Localization.mk (-a) b :=
  by sorry

This theorem states that for any commutative ring `R` and any submonoid `M` of `R`, for any element `a` of `R` and any element `b` of `M`, the negation of the localization of `R` at `M` of the pair `(a, b)` is equal to the localization of `R` at `M` of the pair `(-a, b)`. In other words, negating the equivalence class of `(a, b)` in the localization of `R` at `M` results in the equivalence class of `(-a, b)`. This is a property of localization in the context of commutative ring theory.

For any commutative ring `R` and submonoid `M`, the negative of the localization of `(a, b)` in `R` at `M` equals the localization of `(-a, b)` in `R` at `M`, for all `a` in `R` and `b` in `M`.


theorem CategoryTheory.ShortComplex.cyclesMap_id :
    ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
      (S : CategoryTheory.ShortComplex C) [inst_2 : CategoryTheory.ShortComplex.HasLeftHomology S],
      CategoryTheory.ShortComplex.cyclesMap (CategoryTheory.CategoryStruct.id S) =
        CategoryTheory.CategoryStruct.id (CategoryTheory.ShortComplex.cycles S) :=
  by sorry

This theorem states that in the context of category theory, for any given category `C` that has zero morphisms, and any short complex `S` in `C` that has left homology data, the map of the cycles of the short complex `S` under the identity morphism is equal to the identity morphism on the cycles of `S`. In simpler terms, applying the identity operation to the short complex and then mapping to its cycles is the same as directly applying the identity operation to the cycles of the short complex.

In any category with zero morphisms, the identity morphism on the cycles of a short complex is equal to the cycles of the identity morphism on the complex.


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

This theorem, named `AlgebraicTopology.DoldKan.PInfty_f_naturality`, asserts a principle of naturality for the Dold-Kan correspondence in algebraic topology. Specifically, for any category `C` which is preadditive, any natural number `n`, and any two simplicial objects `X` and `Y` in `C` with a morphism `f` from `X` to `Y`, the composition of `f` with the `n`-th Dold-Kan correspondence functor applied to `Y` is equal to the composition of the `n`-th Dold-Kan correspondence functor applied to `X` with `f`. In other words, the Dold-Kan correspondence functor commutes with morphisms in the category of simplicial objects.

For any preadditive category `C`, the Dold-Kan correspondence functor from simplicial objects in `C` to chain complexes preserves natural transformations.


theorem nnnorm_indicator_eq_indicator_nnnorm :
    ∀ {α : Type u_1} {E : Type u_2} [inst : SeminormedAddCommGroup E] {s : Set α} (f : α → E) (a : α),
      ‖Set.indicator s f a‖₊ = Set.indicator s (fun a => ‖f a‖₊) a :=
  by sorry

The theorem `nnnorm_indicator_eq_indicator_nnnorm` states that for any type `α`, any semi-normed additive commutative group `E`, any set `s` of elements of type `α`, any function `f` from `α` to `E`, and any element `a` of type `α`, the non-negative norm (`‖‖₊`) of the set indicator function applied to `s`, `f`, and `a` is equal to the set indicator function applied to `s`, the function mapping each element to its non-negative norm, and `a`. In simpler terms, it says that the non-negative norm of the indicator function of a set is the same as the indicator function of the non-negative norm.

For any semi-normed additive commutative group E, set s ⊆ α, function f : α → E, and element a ∈ α, the non-negative norm ∥IndicATOR s∥₊(a) = IndicATOR {x : α | ∥f x∥₊ ≤ ∥f a∥₊}(a).


theorem ENNReal.mul_top' : ∀ {a : ENNReal}, a * ⊤ = if a = 0 then 0 else ⊤ := by sorry

The theorem `ENNReal.mul_top'` states that for every element `a` of the extended nonnegative real numbers (ENNReal), the product of `a` and positive infinity (`⊤`) is determined by whether `a` is zero. If `a` is zero, then the product is zero. Otherwise, if `a` is nonzero, then the product is positive infinity (`⊤`).

For every `a` in ENNReal, `a * ⊤ = ⊤` if `a` is nonzero, and `a * ⊤ = 0` if `a` is zero.


theorem nsmul_right_mono :
    ∀ {M : Type u_3} [inst : AddMonoid M] [inst_1 : Preorder M]
      [inst_2 : CovariantClass M M (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1]
      [inst_3 : CovariantClass M M (Function.swap fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] (n : ℕ),
      Monotone fun a => n • a :=
  by sorry

The theorem `nsmul_right_mono` states that for any natural number `n` and any type `M` that is an additive monoid and a preorder, and for which addition is monotone increasing both on the left and on the right (i.e., satisfies the conditions of both `CovariantClass M M (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1` and `CovariantClass M M (Function.swap fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1`), the function that multiplies an element of `M` by `n` (denoted `n • a`) is also monotone increasing. In other words, if `a ≤ b` then `n • a ≤ n • b`, where `n • a` denotes the n-fold addition of `a` to itself.

For any additive monoid M with monotone increasing addition on both sides and natural number n, the function n • (.) from M to M, defined as repeated addition (n-fold), is monotone increasing.


theorem LinearMap.comp_id :
    ∀ {R₂ : Type u_3} {R₃ : Type u_4} {M₂ : Type u_11} {M₃ : Type u_12} [inst : Semiring R₂] [inst_1 : Semiring R₃]
      [inst_2 : AddCommMonoid M₂] [inst_3 : AddCommMonoid M₃] {module_M₂ : Module R₂ M₂} {module_M₃ : Module R₃ M₃}
      {σ₂₃ : R₂ →+* R₃} (f : M₂ →ₛₗ[σ₂₃] M₃), LinearMap.comp f LinearMap.id = f :=
  by sorry

The theorem `LinearMap.comp_id` states that for any semirings `R₂` and `R₃`, additive commutative monoids `M₂` and `M₃`, if `M₂` and `M₃` are modules over `R₂` and `R₃` respectively, and if `σ₂₃` is a ring homomorphism from `R₂` to `R₃`, then for any linear map `f` from `M₂` to `M₃` over `σ₂₃`, the composition of `f` with the identity map is equal to `f` itself. In other words, applying an identity transformation in the context of linear maps doesn't change the original linear map.

For any ring homomorphism σ₂₃ from semiring R₂ to semiring R₃, and linear maps f : M₂ → M₃ over σ₂₃ from additive commutative monoids M₂ and M₃, the composition of f with the identity map is equal to f itself.


theorem dist_one_left : ∀ {E : Type u_6} [inst : SeminormedGroup E], dist 1 = norm := by sorry

This theorem, named `dist_one_left`, states that for any type `E` which forms a seminormed group, the distance from the origin to `1` in this space is equal to the norm of the space. In mathematical terms, for any `E` where `E` is a seminormed group, the distance function `dist 1` is equivalent to the norm of the group.

In a seminormed group `E`, the distance from the origin to `1` is equal to the norm of the identity element.


theorem SetTheory.PGame.sub_zero : ∀ (x : SetTheory.PGame), x - 0 = x + 0 := by sorry

This theorem states that for any "PGame" in set theory, the difference of the game and zero is equal to the sum of the game and zero. Here, "PGame" refers to the mathematical concept of games, which are combinatorial structures used in game theory and math. It essentially asserts that zero works as an identity element both in subtraction and addition within the context of "PGames".

For any "PGame" P in set theory, P - 0 = P + 0.


/-- The function `z ^ w` is continuous in `(z, w)` provided that `z` does not belong to the interval
`(-∞, 0]` on the real line. See also `Complex.continuousAt_cpow_zero_of_re_pos` for a version that
works for `z = 0` but assumes `0 < re w`.  -/
theorem continuousAt_cpow : ∀ {p : ℂ × ℂ}, p.1 ∈ Complex.slitPlane → ContinuousAt (fun x => x.1 ^ x.2) p := by sorry

The theorem `continuousAt_cpow` states that the function `z ^ w` where `z` and `w` are complex numbers (`ℂ`) is continuous at a point `p`, which is a pair of complex numbers, provided that the first component of `p` (i.e., `p.1` or `z`) does not belong to the interval `(-∞, 0]` on the real line. In other words, `z` must not be lying on the negative real axis or be zero. This condition is captured by the requirement that `p.1` must be in the "slit plane", which is the complex plane with the closed negative real axis removed. Note that there is also another version of this theorem `Complex.continuousAt_cpow_zero_of_re_pos` that allows `z` to be zero but under the additional assumption that the real part of `w` is strictly positive.

The function `z ^ w` is continuous at the complex number `p = (z, w)` if `z` is not in the closed negative half-plane.


theorem nullMeasurableSet_lt :
    ∀ {α : Type u_1} {δ : Type u_5} [inst : TopologicalSpace α] [inst_1 : MeasurableSpace α]
      [inst_2 : OpensMeasurableSpace α] [inst_3 : MeasurableSpace δ] [inst_4 : LinearOrder α]
      [inst_5 : OrderClosedTopology α] [inst : SecondCountableTopology α] {μ : MeasureTheory.Measure δ} {f g : δ → α},
      AEMeasurable f μ → AEMeasurable g μ → MeasureTheory.NullMeasurableSet {a | f a < g a} μ :=
  by sorry

The theorem `nullMeasurableSet_lt` states that for any types `α` and `δ`, where `α` is a topological space, a measurable space, has an order that is closed in its topology, and has a second countable topology, and `δ` is a measurable space; given a measure `μ` on `δ`, and two functions `f`, `g` from `δ` to `α` that are almost everywhere measurable with respect to `μ`, then the set of points in `δ` where `f` is strictly less than `g` is a null measurable set with respect to `μ`. In other words, this set can be approximated by a measurable set up to a set of null measure.

Given measurable spaces `α` with a second countable topology and order topology, and `δ`, a measurable space with a measure `μ`, and almost everywhere measurable functions `f` and `g` from `δ` to `α`, the set where `f` is strictly less than `g` is a null measurable set with respect to `μ`.


theorem MeasureTheory.hasFiniteIntegral_norm_iff :
    ∀ {α : Type u_1} {β : Type u_2} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} [inst : NormedAddCommGroup β]
      (f : α → β), MeasureTheory.HasFiniteIntegral (fun a => ‖f a‖) μ ↔ MeasureTheory.HasFiniteIntegral f μ :=
  by sorry

The theorem `MeasureTheory.hasFiniteIntegral_norm_iff` states that for any types `α` and `β`, with `α` being a measurable space and `μ` being a measure on `α`, and `β` being a normed add commutative group, a function `f` from `α` to `β` has a finite integral with respect to the measure `μ` if and only if the function that assigns the norm of `f(a)` to each `a` in `α` also has a finite integral with respect to `μ`. In other words, the finiteness of the integral of `f` and the finiteness of the integral of the norm of `f` are equivalent.

The theorem `MeasureTheory.hasFiniteIntegral_norm_iff` asserts that a measurable function from a measurable space to a normed add commutative group has a finite integral if and only if the function assigning the norm of its values to each point has a finite integral.


theorem continuousOn_congr :
    ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] {f g : α → β} {s : Set α},
      Set.EqOn g f s → (ContinuousOn g s ↔ ContinuousOn f s) :=
  by sorry

This theorem, `continuousOn_congr`, states that for any two functions `f` and `g` from a type `α` to a type `β`, both of which are equipped with a topological space structure, and for any set `s` of type `α`, if `g` and `f` are equal on the set `s` (meaning that for every element `x` in `s`, `g(x) = f(x)`), then `g` is continuous on `s` if and only if `f` is continuous on `s`. In mathematical terms, if two functions are equal on a subset of their domain, their continuity on that subset is equivalent.

For functions `f` and `g` from a topological space `α` to a topological space `β`, if `g = f` on a subset `s` of `α` and `f` is continuous on `s`, then `g` is also continuous on `s`.


theorem Subalgebra.pow_mem :
    ∀ {R : Type u} {A : Type v} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A]
      (S : Subalgebra R A) {x : A}, x ∈ S → ∀ (n : ℕ), x ^ n ∈ S :=
  by sorry

This theorem states that for any commutative semiring `R`, a semiring `A`, and an algebra structure on `A` over `R`, if `x` is an element of a certain subalgebra `S` of `A` over `R`, then `x` raised to any natural number power `n` is also an element of the subalgebra `S`. In other words, the subalgebra is closed under exponentiation with natural number exponents.

If `R` is a commutative semiring, `A` is a semiring with an algebra structure over `R`, and `S` is a subalgebra of `A`, then for all `x ∈ S` and `n ∈ ℕ`, `x^n ∈ S`.


theorem CategoryTheory.ihom.ev_coev :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.MonoidalCategory C] (A B : C)
      [inst_2 : CategoryTheory.Closed A],
      CategoryTheory.CategoryStruct.comp
          (CategoryTheory.MonoidalCategory.whiskerLeft A ((CategoryTheory.ihom.coev A).app B))
          ((CategoryTheory.ihom.ev A).app (CategoryTheory.MonoidalCategory.tensorObj A B)) =
        CategoryTheory.CategoryStruct.id (CategoryTheory.MonoidalCategory.tensorObj A B) :=
  by sorry

The theorem `CategoryTheory.ihom.ev_coev` states that for any category `C` that is also a monoidal category, and for any objects `A` and `B` in `C` where `A` is a closed object, the composition of the coevaluation natural transformation (which is whiskered left by `A`) applied to `B` and the evaluation natural transformation applied to the tensor product of `A` and `B` is equivalent to the identity morphism on the tensor product of `A` and `B`. In other words, the coevaluation and evaluation natural transformations satisfy a certain kind of "round trip" property in the context of monoidal categories.

For any monoidal category `C` and objects `A, B` in `C` with `A` closed, the coevaluation and evaluation natural transformations satisfy `coev(B) ∘ ev(A ⊗ B) ≈ id(A ⊗ B)`.


theorem Int.lt_iff_le_not_le : ∀ {a b : ℤ}, a < b ↔ a ≤ b ∧ ¬b ≤ a := by sorry

This theorem states that for any two integers `a` and `b`, `a` is less than `b` if and only if `a` is less than or equal to `b` and it is not true that `b` is less than or equal to `a`. Essentially, it confirms that `a` is strictly less than `b` only when `a` is at most `b` and `b` is not at most `a`.

For integers `a` and `b`, `a` is strictly less than `b` if and only if `a` is less than `b` and `b` is not less than `a`.


theorem Multiset.attach.proof_1 : ∀ {α : Type u_1} (s : Multiset α), ∀ _a ∈ s, _a ∈ s := by sorry

The theorem `Multiset.attach.proof_1` states that for any type `α`, and any multiset `s` of that type, any element `_a` that is in `s` will still be in `s`. It guarantees that if an element is part of a multiset, it remains in that multiset, underlining the permanence of elements in multisets. This is a fundamental property of multisets, equivalent to saying that if an object is in a bag, it remains in that bag unless removed.

For any type `α` and multiset `s` of type `α`, if an element `a` is in `s`, then `a` is still in `s`.


theorem dvd_gcd_iff :
    ∀ {α : Type u_1} [inst : CancelCommMonoidWithZero α] [inst_1 : GCDMonoid α] (a b c : α),
      a ∣ gcd b c ↔ a ∣ b ∧ a ∣ c :=
  by sorry

This theorem, `dvd_gcd_iff`, states that for any type `α` that is a cancelable commutative monoid with zero and has a Greatest Common Divisor (GCD) structure, a given element `a` of `α` divides the GCD of two other elements `b` and `c` if and only if `a` divides both `b` and `c`. In mathematical terms, $a | gcd(b, c)$ if and only if $a | b$ and $a | c$.

For any cancelable commutative monoid with zero and a GCD structure, an element divides the GCD of two other elements if and only if it divides both elements.


theorem Set.iUnion_congr_of_surjective :
    ∀ {α : Type u_1} {ι : Sort u_4} {ι₂ : Sort u_6} {f : ι → Set α} {g : ι₂ → Set α} (h : ι → ι₂),
      Function.Surjective h → (∀ (x : ι), g (h x) = f x) → ⋃ x, f x = ⋃ y, g y :=
  by sorry

The theorem `Set.iUnion_congr_of_surjective` states that for all types `α`, `ι`, and `ι₂`, and for all functions `f : ι → Set α` and `g : ι₂ → Set α`, and a function `h : ι → ι₂`, if the function `h` is surjective and for all `x : ι`, `g (h x) = f x`, then the indexed union over all `x` in `ι` of the sets `f x` is equal to the indexed union over all `y` in `ι₂` of the sets `g y`. In simpler terms, if we have a surjective function that transforms each element of `ι` into an element of `ι₂` in such a way that the sets these elements index are the same, then the union of all the sets indexed by elements of `ι` is the same as the union of all the sets indexed by elements of `ι₂`.

If `h : ι → ι₂` is surjective and for all `x : ι`, `g (h x) = f x`, then `⋃x : ι. f x = ⋃y : ι₂. g y`.


theorem Metric.cthickening_singleton :
    ∀ {α : Type u_2} [inst : PseudoMetricSpace α] (x : α) {δ : ℝ},
      0 ≤ δ → Metric.cthickening δ {x} = Metric.closedBall x δ :=
  by sorry

The theorem `Metric.cthickening_singleton` states that for any type `α` equipped with a pseudo metric space structure, and for any element `x` of type `α` and any real number `δ` greater than or equal to zero, the closed `δ`-thickening of the set containing only `x` is equal to the closed ball centered at `x` with radius `δ`. In other words, the set of all points at an infimum distance of at most `δ` from `x` is the same as the set of all points whose distance from `x` is at most `δ`.

For any pseudo metric space `(α, d)` and `x ∈ α` with real `δ ≥ 0`, the closed `δ`-thickening of the singleton set `{x}` equals the closed ball `{y | d(x, y) ≤ δ}`.


theorem Real.coe_nnabs : ∀ (x : ℝ), ↑(Real.nnabs x) = |x| := by sorry

This theorem states that for any real number `x`, the coercion (or conversion) of the non-negative absolute value of `x` (`Real.nnabs x`) back to a real number produces the standard absolute value of `x`. In mathematical terms, given any real number `x`, the absolute value `|x|` is equivalent to transforming `x` to a non-negative real number using `Real.nnabs` and then converting it back to a real number.

For any real number `x`, the absolute value `|x|` is equal to the coercion of `Real.nnabs x` back to a real number.


theorem CategoryTheory.Subobject.isIso_iff_mk_eq_top :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X Y : C} (f : X ⟶ Y) [inst_1 : CategoryTheory.Mono f],
      CategoryTheory.IsIso f ↔ CategoryTheory.Subobject.mk f = ⊤ :=
  by sorry

The theorem `CategoryTheory.Subobject.isIso_iff_mk_eq_top` in Lean 4 states that for any category `C`, and any objects `X` and `Y` in `C`, a morphism `f` from `X` to `Y` is an isomorphism if and only if the subobject generated by `f` is equal to the top element in the lattice of subobjects of `Y`. Here, the mono condition on `f` ensures that `f` really defines a subobject of `Y`.

In category `C`, a morphism `f` from object `X` to object `Y` is an isomorphism if and only if the subobject `f''(X)` generated by `f` equals the top element in the lattice of subobjects of `Y`.


theorem Ordinal.nfpFamily_fp :
    ∀ {ι : Type u} {f : ι → Ordinal.{max u v} → Ordinal.{max u v}} {i : ι},
      Ordinal.IsNormal (f i) → ∀ (a : Ordinal.{max u v}), f i (Ordinal.nfpFamily f a) = Ordinal.nfpFamily f a :=
  by sorry

The theorem `Ordinal.nfpFamily_fp` states that for any type `ι`, any function `f` from `ι` to a normal ordinal function, and any `i` of type `ι`, if `f i` is a normal ordinal function then for any ordinal `a`, applying `f i` to the next common fixed point of the family (at least `a`) gives you the next common fixed point itself. In simpler terms, the next common fixed point is a fixed point for each of the normal functions in the family.

For any type `ι`, function `f` from `ι` to normal ordinal functions, and `i` of type `ι`, if `f i` is a normal ordinal function and `a` is the next common fixed point of the family `(f i)` (or greater), then `(f i) (next_cpp a) = next_cpp a`.


/-- A monotone function continuous at the supremum of a nonempty set sends this supremum to
the supremum of the image of this set.  -/
theorem Monotone.map_sSup_of_continuousAt' :
    ∀ {α : Type u} {β : Type v} [inst : ConditionallyCompleteLinearOrder α] [inst_1 : TopologicalSpace α]
      [inst_2 : OrderTopology α] [inst_3 : ConditionallyCompleteLinearOrder β] [inst_4 : TopologicalSpace β]
      [inst_5 : OrderClosedTopology β] {f : α → β} {A : Set α},
      ContinuousAt f (sSup A) →
        Monotone f → Set.Nonempty A → autoParam (BddAbove A) _auto✝ → f (sSup A) = sSup (f '' A) :=
  by sorry

This theorem states that if you have a monotone function `f` that is also continuous at the supremum (`sSup`) of a nonempty set `A`, then the value of `f` at the `sSup` of `A` is equal to the `sSup` of the image of `A` under `f`. This essentially means that the function `f` is mapping the supremum of `A` to the supremum of its image. Additionally, it is assumed that the set `A` is bounded above, but this is an automatic parameter which Lean fills in on its own, without requiring explicit specification. The theorem applies in the context of conditionally complete linear orders and topological spaces where the order topology is derived from the linear order and the topology is closed under limit of sequences decreasing to a limit.

If `f` is a monotone and continuous function on a nonempty, bounded above set `A` in a conditionally complete linear order or topological space, then `f(sSup A) = sSup (f ``A``)`.


theorem edist_vadd_left :
    ∀ {M : Type u} {X : Type w} [inst : PseudoEMetricSpace X] [inst_1 : VAdd M X] [inst_2 : IsometricVAdd M X] (c : M)
      (x y : X), edist (c +ᵥ x) (c +ᵥ y) = edist x y :=
  by sorry

This theorem, named `edist_vadd_left`, states that for any types `M` and `X`, given that `X` forms a pseudoemetric space and that `M` can be vector added to `X` in an isometric fashion (i.e., preserving the distance), the distance from `c +ᵥ x` to `c +ᵥ y` (where `c` is in `M`, `x` and `y` are in `X`) is the same as the distance from `x` to `y`. In mathematical notation, this is saying that for all `c`, `x`, `y`, we have `edist (c +ᵥ x) (c +ᵥ y) = edist x y`, where `edist` represents the extended distance function in the pseudoemetric space.

For any pseudometric space `(X, edist)` and vector `c` in a vector space `M` that can be isometrically added to `X`, the extended distance `edist` between `c +ᵥ x` and `c +ᵥ y` equals the extended distance between `x` and `y`, for all `x, y` in `X`.


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

This Lean theorem, `CategoryTheory.ShortComplex.LeftHomologyData.map_leftHomologyMap'`, states that for any two short complexes `S₁` and `S₂` in categories `C` and `D` with zero morphisms, given a morphism `φ` from `S₁` to `S₂`, left homology data `hl₁` for `S₁` and `hl₂` for `S₂`, and a functor `F` from `C` to `D` which preserves zero morphisms and left homology data, the mapping of the left homology map of `φ` by `F` is equal to the left homology map of the mapping of `φ` by the short complex functor of `F`, with the mappings of `hl₁` and `hl₂` by `F` as the respective left homology data. Essentially, the theorem asserts that the process of mapping a left homology map by a functor is compatible with the process of mapping a morphism between short complexes by the short complex functor of the same functor and then taking the left homology map.

Given short complexes $S\_1$ and $S\_2$ in categories $C$ and $D$ with zero morphisms, a morphism $\varphi$ from $S\_1$ to $S\_2$, left homology data $hł\_1$ for $S\_1$ and $hł\_2$ for $S\_2$, and a functor $F$ from $C$ to $D$ preserving zero morphisms and left homology data, the map of the left homology map of $\varphi$ by $F$ equals the left homology map of the map of $\varphi$ by the short complex functor of $F$, with the images of $hł\_1$ and $hł\_2$ under $F$ as the respective left homology data.


theorem Mathlib.Algebra.Group.Semiconj.Basic._auxAddLemma.3 : ∀ {α : Sort u_1} {a b : α}, (a = b) = (b = a) := by sorry

This theorem, `Mathlib.Algebra.Group.Semiconj.Basic._auxAddLemma.3`, states that for any type `α` and any two elements `a` and `b` of this type, the statement "`a` is equal to `b`" is the same as the statement "`b` is equal to `a`". In other words, the theorem asserts the symmetry of equality in any sort or type.

The theorem asserts that for all types `α` and elements `a`, `b` of type `α`, the equality `a = b` is equivalent to `b = a`.


theorem List.unzip_eq_map :
    ∀ {α : Type u} {β : Type u_1} (l : List (α × β)), List.unzip l = (List.map Prod.fst l, List.map Prod.snd l) := by
  sorry

This theorem states that for any list of pairs, where the pairs are of types `α` and `β`, the operation of "unzipping" the list (separating it into two lists where one contains all the first elements of the pairs and the other contains the second elements) is equivalent to creating two new lists separately by mapping the `Prod.fst` operation (which extracts the first element of a pair) and `Prod.snd` operation (which extracts the second element of a pair) over the original list. In other words, for any list `l` of pairs, `List.unzip l` will produce the same result as `(List.map Prod.fst l, List.map Prod.snd l)`. In LaTeX mathematics, it can be expressed as:

For all lists \(l\) of pairs (with elements from types \(\alpha\) and \(\beta\)), the operation of unzipping \(l\) is equivalent to the operation of mapping the first and second projections over \(l\). That is,
\[
\text{{List.unzip}}(l) = (\text{{List.map Prod.fst}}(l), \text{{List.map Prod.snd}}(l))
\]

For any list of pairs between types `α` and `β`, the operation of unzipping the list is equivalent to mapping `Prod.fst` and `Prod.snd` separately. That is, `List.unzip l = (List.map Prod.fst l, List.map Prod.snd l)`.


theorem image_minimals_of_rel_iff_rel :
    ∀ {β : Type u_2} {α : Type u_1} {f : α → β} {r : α → α → Prop} {s : β → β → Prop} {x : Set α},
      (∀ ⦃a a' : α⦄, a ∈ x → a' ∈ x → (r a a' ↔ s (f a) (f a'))) → f '' minimals r x = minimals s (f '' x) :=
  by sorry

The theorem `image_minimals_of_rel_iff_rel` states that for any types `α` and `β`, a function `f` from `α` to `β`, a binary relation `r` on `α`, a binary relation `s` on `β`, and a set `x` of type `α`, if for every pair of elements `a` and `a'` in `x` the relation `r` holds between `a` and `a'` if and only if the relation `s` holds between `f(a)` and `f(a')`, then the image of the set of minimal elements under `r` in `x` under the function `f` is equal to the set of minimal elements under `s` in the image of `x` under `f`. In other words, if `f` preserves the relation between elements of `x`, it also preserves the set of minimal elements under these relations when applied to `x`.

If a function preserves the relation between elements of a set such that two elements are related if and only if their images under the function are related, then the images under the function of the minimal elements of the set are the minimal elements of the image set.