theorem Polynomial.reflect_add :
    ∀ {R : Type u_1} [inst : Semiring R] (f g : Polynomial R) (N : ℕ),
      Polynomial.reflect N (f + g) = Polynomial.reflect N f + Polynomial.reflect N g :=
  by sorry

The theorem `Polynomial.reflect_add` states that for any semiring `R`, any two polynomials `f` and `g` over `R`, and any natural number `N`, the reflection of the sum of `f` and `g` with respect to `N` is equal to the sum of the reflections of `f` and `g` individually with respect to `N`. In other words, the `reflect` operation over polynomials is distributive over addition. This can be expressed mathematically as: for all `f`, `g` in Polynomial `R` and for all `N` in ℕ, `reflect(N, f + g) = reflect(N, f) + reflect(N, g)`, where `reflect` is a function that rearranges the coefficients of a polynomial.

For any semiring R, natural number N, and polynomials f and g over R, the reflection of the sum of f and g with respect to N is equal to the sum of the reflections of f and g with respect to N. In other words, the reflection operation over polynomials distributes over polynomial addition.


theorem CompleteLattice.independent_map_orderIso_iff :
    ∀ {ι : Sort u_5} {α : Type u_6} {β : Type u_7} [inst : CompleteLattice α] [inst_1 : CompleteLattice β] (f : α ≃o β)
      {a : ι → α}, CompleteLattice.Independent (⇑f ∘ a) ↔ CompleteLattice.Independent a :=
  by sorry

This theorem states that for any sort `ι`, types `α` and `β` with both having a CompleteLattice instance, and a function `f` that is an order isomorphism between `α` and `β`, the function `a` from `ι` to `α` is independent (in the sense of complete lattices) if and only if the function `f ∘ a` (i.e., the composition of `f` and `a`) is independent. In other words, independence of a function in the domain of the order isomorphism is preserved under the mapping of the order isomorphism.

For any order isomorphism `f` between complete lattices `α` and `β`, and any independent function `a` from a sort `ι` to `α`, the function `f ∘ a` is also independent in `β`.


theorem MeasureTheory.Measure.addHaar_closedBall_center :
    ∀ {E : Type u_3} [inst : NormedAddCommGroup E] [inst_1 : MeasurableSpace E] [inst_2 : BorelSpace E]
      (μ : MeasureTheory.Measure E) [inst_3 : MeasureTheory.Measure.IsAddHaarMeasure μ] (x : E) (r : ℝ),
      ↑↑μ (Metric.closedBall x r) = ↑↑μ (Metric.closedBall 0 r) :=
  by sorry

This theorem states that for any normed additive commutative group `E` with a measurable space structure, a Borel space structure, and an associated Add Haar measure `μ`, the measure of the closed ball of radius `r` centered at any point `x` in `E` is equal to the measure of the closed ball of the same radius `r` centered at the origin. In other words, Add Haar measures are translation invariant in the sense that shifting the center of a closed ball doesn't change its measure.

For any normed additive commutative group `E` with a measurable space structure, Borel space structure, and an Add Haar measure `μ`, the measure of a closed ball in `E` is translation invariant, i.e., the measure of the closed ball centered at `x` with radius `r` is equal to the measure of the closed ball centered at the origin with radius `r`.


theorem Trunc.exists_rep : ∀ {α : Sort u_1} (q : Trunc α), ∃ a, Trunc.mk a = q := by sorry

This theorem, `Trunc.exists_rep`, states that for any type `α` and any element `q` of the type `Trunc α`, there exists an element `a` of type `α` such that `Trunc.mk a` is equal to `q`. In other words, every instance of the truncated type `Trunc α` has a representative value in the original type `α`.

For every type `α` and every `q` in `Trunc α`, there exists an `a` in `α` such that `Trunc.mk a = q`.


SModEq.top

theorem SModEq.top :
    ∀ {R : Type u_1} [inst : Ring R] {M : Type u_2} [inst_1 : AddCommGroup M] [inst_2 : Module R M] {x y : M},
      x ≡ y [SMOD ⊤] :=
  by sorry

This theorem states that for any ring `R` and its associated module `M`, any two elements `x` and `y` from the module `M` are congruent modulo the top element, denoted by `⊤`. This congruence is true irrespective of the actual values of `x` and `y`. In other words, in the context of a module over a ring, all elements are congruent under the highest (top) modular relation.

In any ring R and its module M, all elements x and y in M are congruent modulo the top element ⊤.


theorem Relation.reflGen_eq_self : ∀ {α : Type u_1} {r : α → α → Prop}, Reflexive r → Relation.ReflGen r = r := by sorry

This theorem states that for any type `α` and any binary relation `r` on `α`, if `r` is a reflexive relation (i.e., for every element `x` in `α`, `r x x` holds), then the reflexive closure of `r` (denoted by `Relation.ReflGen r`) is equal to `r` itself. In mathematical terms, if `r` is a reflexive relation on a set `α`, then the smallest reflexive relation containing `r` is `r` itself.

If `r` is a reflexive relation on a set `α`, then `Relation.ReflGen r = r`.


theorem ZFSet.eq_empty : ∀ (x : ZFSet), x = ∅ ↔ ∀ (y : ZFSet), y ∉ x := by sorry

This theorem states that for any set `x` in the ZFC universe of sets, `x` is equal to the empty set if and only if for all sets `y`, `y` is not an element of `x`. In other words, a set `x` is empty if it does not contain any other set.

A set is empty if and only if it has no elements.


theorem Mathlib.AlgebraicTopology.SimplicialSet._auxLemma.4 : ∀ {p q : Prop}, (¬(p ∨ q)) = (¬p ∧ ¬q) := by sorry

This theorem, `Mathlib.AlgebraicTopology.SimplicialSet._auxLemma.4`, is a statement in propositional logic. It asserts that for any two propositions `p` and `q`, the negation of the disjunction (`p ∨ q`) is logically equivalent to the conjunction of their individual negations (`¬p ∧ ¬q`). In other words, "not (p or q)" is the same as "not p and not q".

The theorem asserts that the negation of the disjunction of two propositions is logically equivalent to the conjunction of their individual negations. In mathematical notation, ¬(p ∨ q) ≡ ¬p ∧ ¬q.


theorem finrank_span_singleton :
    ∀ {K : Type u} {V : Type v} [inst : DivisionRing K] [inst_1 : AddCommGroup V] [inst_2 : Module K V] {v : V},
      v ≠ 0 → FiniteDimensional.finrank K ↥(Submodule.span K {v}) = 1 :=
  by sorry

This theorem states that for any division ring `K` and an additive commutative group `V` that is also a `K`-module, if `v` is a non-zero element of `V`, then the rank of the submodule of `V` generated (or spanned) by the singleton set `{v}` is `1`. In other words, the dimension of the vector space spanned by a single non-zero vector is `1`.

For any division ring K and additive commutative group V being a K-module, the dimension of the subspace spanned by a non-zero element in V is 1.


theorem PiLp.nnnorm_eq_sum :
    ∀ {ι : Type u_2} [inst : Fintype ι] {p : ENNReal} [inst_1 : Fact (1 ≤ p)] {β : ι → Type u_5},
      p ≠ ⊤ →
        ∀ [inst_2 : (i : ι) → SeminormedAddCommGroup (β i)] (f : PiLp p β),
          ‖f‖₊ = (Finset.sum Finset.univ fun i => ‖f i‖₊ ^ p.toReal) ^ (1 / p.toReal) :=
  by sorry

The theorem `PiLp.nnnorm_eq_sum` states that for any given indexed type `ι` that is finite, a nonnegative real number `p` (extended by adding infinity) that is greater than or equal to 1, and any type `β` that is a function of the index `ι`, whenever `p` is not infinity, for a function `f` of type `PiLp p β` (a copy of a Pi type), the nonnegative norm of `f` is equal to the p-th root of the sum, across all indices in the universal finite set of `ι`, of the p-th power of the nonnegative norm of `f` evaluated at the index. The sum operation here is defined in the context of an additive commutative monoid.
In other words, this theorem characterizes the `L^p` norm of a function in terms of the `p`-norms of its components.

For any finite indexed type `ι`, nonnegative real number `p ≥ 1` (extending it with infinity), and a function `f` of type `PiLp p β`, the `L^p` norm of `f` equals the `p`-th root of the sum, across all indices in `ι`, of the `p`-th power of the nonnegative norm of `f` evaluated at each index.


theorem MvPowerSeries.monomial_def :
    ∀ {σ : Type u_1} {R : Type u_2} [inst : Semiring R] [inst_1 : DecidableEq σ] (n : σ →₀ ℕ),
      MvPowerSeries.monomial R n = LinearMap.stdBasis R (fun x => R) n :=
  by sorry

This theorem establishes that for any type `σ`, type `R` with a semiring structure, and any function `n` from `σ` to natural numbers, the `n`-th monomial of a multivariate formal power series over `R` is equivalent to the standard basis over `R` evaluated at `n`. This is the case provided that equality between elements of `σ` is decidable. In mathematical terms, it asserts the correspondence between the `n`-th monomial in a power series and the `n`-th basis vector in a vector space over a semiring.

For any type `σ` with decidable equality, type `R` with a semiring structure, and function `n` from `σ` to natural numbers, the `n`-th monomial of a multivariate formal power series over `R` equals the standard basis vector evaluated at `n`.


theorem Mathlib.AlgebraicTopology.SimplicialSet._auxLemma.3 :
    ∀ {α : Type u} {s : Set α}, (s = Set.univ) = (Set.univ ⊆ s) := by sorry

This theorem states that for any type `α` and a set `s` of that type, `s` equals the universal set of `α` if and only if the universal set of `α` is a subset of `s`. In mathematical terms, given a set `s` of elements of some type `α`, `s` is identical to the universal set of `α` (i.e., the set containing all elements of `α`) if and only if every element of the universal set is also an element of `s`.

A set `s` of type `α` is equal to the universal set of `α` if and only if the universal set is a subset of `s`.


theorem Ideal.IsPrime.mem_of_pow_mem :
    ∀ {α : Type u} [inst : Semiring α] {I : Ideal α}, Ideal.IsPrime I → ∀ {r : α} (n : ℕ), r ^ n ∈ I → r ∈ I := by sorry

This theorem states that for any type `α` that forms a semiring, and any ideal `I` in this semiring, if `I` is a prime ideal, then for any element `r` of `α` and any natural number `n`, if `r` raised to the power `n` is in `I`, then `r` must also be in `I`. Here, Ideal `I` is a special kind of subset of the semiring `α` which itself forms a semiring and has additional properties. A prime ideal is an ideal that has an analogous property to prime numbers in number theory: if an operation (multiplication in the case of numbers, ring multiplication in the case of ideals) of two elements results in an element in the prime ideal, then at least one of the elements must be in the prime ideal.

For any semiring `α` and prime ideal `I` in `α`, if for some element `r` in `α` and natural number `n`, `r^n` is in `I`, then `r` is in `I`.


theorem MeasureTheory.lintegral_tsum :
    ∀ {α : Type u_1} {β : Type u_2} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} [inst : Countable β]
      {f : β → α → ENNReal},
      (∀ (i : β), AEMeasurable (f i) μ) → ∫⁻ (a : α), ∑' (i : β), f i a ∂μ = ∑' (i : β), ∫⁻ (a : α), f i a ∂μ :=
  by sorry

This theorem, `MeasureTheory.lintegral_tsum`, states that for any measure space `α` with a measure `μ`, and for any countable type `β`, if we have a function `f` from `β` and `α` to the extended nonnegative real numbers (`ENNReal`) that is almost everywhere measurable for each `i` in `β`, then the integral over `α` of the sum of `f i a` over `i` in `β` (with respect to the measure `μ`) is equal to the sum over `i` in `β` of the integral over `α` of `f i a` (with respect to the measure `μ`).

In mathematical terms, if `f : β → α → ENNReal` is almost everywhere measurable for each `i` in `β`, then we have the equality:
```
∫⁻ a, (∑' i, f i a) dμ = ∑' i, ∫⁻ a, f i a dμ
```
This is an application of Fubini's theorem to the extended nonnegative real numbers, allowing us to interchange the order of summation and integration.

 For any measure space `(α, μ)` and countable family `{f_i : α → ENNReal}_{i ∈ β}` of almost everywhere measurable functions, we have:

∫⁻ a, (∑' i, f_i a) dμ = ∑' i, ∫⁻ a, f_i a dμ.


theorem map_mem_minimals :
    ∀ {β : 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'))) →
        ∀ {a : α}, a ∈ minimals r x → f a ∈ minimals s (f '' x) :=
  by sorry

The theorem `map_mem_minimals` is a statement about the transformation of antichains. It states that for any two types `α` and `β`, a function `f` from `α` to `β`, a relation `r` on `α`, a relation `s` on `β`, and a set `x` of type `α`, if for all `a` and `a'` in `x`, `a` relates to `a'` under `r` if and only if `f(a)` relates to `f(a')` under `s`, then for any `a` in the set of minimal elements of `x` under `r`, `f(a)` is in the set of minimal elements of the image of `x` under `f` with respect to `s`.

In simpler terms, this theorem says if you have a function that preserves the relationship of elements when mapping from one set to another, then the image of any minimal element in the original set under the function is a minimal element in the image set.

If a function preserves the relation between minimal elements of two sets, then the image of any minimal element under the function is a minimal element in the image set.


theorem Mathlib.Algebra.Star.Basic._auxLemma.1 :
    ∀ {R : Type u} [inst : InvolutiveStar R] {x y : R}, (star x = star y) = (x = y) := by sorry

This theorem, labeled as `Mathlib.Algebra.Star.Basic._auxLemma.1`, states that for any type `R` equipped with an operation `star` that is involutive (meaning applying `star` twice yields the original element), and any two elements `x` and `y` of type `R`, the proposition that the `star` of `x` equals the `star` of `y` is equivalent to the proposition that `x` equals `y`. In simpler words, if the `star` operation applied to `x` and `y` gives the same result, then `x` and `y` are themselves equal.

For any type `R` and involutive operation `star` on `R`, if `x` and `y` in `R` satisfy `star x = star y`, then `x = y`.


theorem Finset.measurableSet_biInter :
    ∀ {α : Type u_1} {β : Type u_2} {m : MeasurableSpace α} {f : β → Set α} (s : Finset β),
      (∀ b ∈ s, MeasurableSet (f b)) → MeasurableSet (⋂ b ∈ s, f b) :=
  by sorry

The theorem `Finset.measurableSet_biInter` states that for any types `α` and `β`, given a measurable space `m` over `α`, a function `f` from `β` to the set of `α`, and a finite set `s` of `β`, if every set `f(b)` with `b` belonging to `s` is measurable, then the intersection of all these sets `f(b)` is also measurable.

In mathematical terms, this theorem says that if $f : \beta \rightarrow \text{Set}\, \alpha$ is a function where $\forall b \in s$, $f(b)$ is measurable, then $\bigcap_{b \in s} f(b)$ is also measurable in the same measure space on `α`.

If `f : β -> Set α` is a function such that for every `b` in a finite set `s` from `β`, `f(b)` is measurable in the measure space on `α`, then the intersection of all `f(b)` for `b` in `s` is measurable in the same measure space on `α`.


theorem Real.contDiffAt_sqrt : ∀ {x : ℝ} {n : ℕ∞}, x ≠ 0 → ContDiffAt ℝ n Real.sqrt x := by sorry

This theorem states that the square root function is continuously differentiable at any non-zero real number. Here, `ContDiffAt ℝ n Real.sqrt x` means that the square root function `Real.sqrt` is n-times continuously differentiable at the point `x` in the real numbers. This property holds for any real number `x` that is not equal to zero, and for any `n` in the extended natural numbers (which includes infinity).

The square root function `Real.sqrt` is continuously differentiable for all non-zero real numbers `x`.


theorem NNRat.coe_inj : ∀ {p q : NNRat}, ↑p = ↑q ↔ p = q := by sorry

This theorem, `NNRat.coe_inj`, asserts that for any two nonnegative rational numbers `p` and `q`, the equality of their coercions (i.e., treating them as regular rational numbers) implies the equality of `p` and `q` themselves. In other words, no two different nonnegative rational numbers can be interpreted as the same rational number. This is the statement of injectivity for the coercion from `NNRat` to `Rat`.

For all nonnegative rational numbers p and q, if p = (rat.coerce p) = (rat.coerce q), then p = q.


theorem Valuation.map_eq_of_sub_lt :
    ∀ {R : Type u_3} {Γ₀ : Type u_4} [inst : Ring R] [inst_1 : LinearOrderedCommGroupWithZero Γ₀] (v : Valuation R Γ₀)
      {x y : R}, v (y - x) < v x → v y = v x :=
  by sorry

The theorem `Valuation.map_eq_of_sub_lt` states that for any type `R`, which is a ring, and any type `Γ₀`, which is a linearly ordered commutative group with zero, and for any valuation `v` of type `R` to `Γ₀`, if the valuation of `(y - x)` is less than the valuation of `x`, then the valuation of `y` is equal to the valuation of `x`. Here, `x` and `y` are any elements of the ring `R`. This theorem captures a particular property of valuation functions in the context of ring theory.

If `v` is a valuation from a ring `R` to a linearly ordered commutative group `Γ₀` with zero, then `v(x) ≤ v(y)` implies `v(x) = v(y)` for any `x, y` in `R`.


theorem ContinuousLinearMap.smulRight_one_pow :
    ∀ {R : Type u_1} [inst : Ring R] [inst_1 : TopologicalSpace R] [inst_2 : TopologicalRing R] (c : R) (n : ℕ),
      ContinuousLinearMap.smulRight 1 c ^ n = ContinuousLinearMap.smulRight 1 (c ^ n) :=
  by sorry

This theorem states that for any ring `R` that also has the structure of a topological space and a topological ring, and for any element `c` of `R` and natural number `n`, raising the continuous linear map that scales by `c` to the power of `n` is equal to the continuous linear map that scales by `c` raised to the power of `n`. In mathematical terms, this means that (1 * c)^n = 1 * (c^n) when working with continuous linear maps in a topological ring.

For any continuous linear map scaling element `c` in a topological ring `R`, (scaling map)^n = scaling map^n.


theorem WithTop.coe_eq_zero : ∀ {α : Type u} [inst : Zero α] {a : α}, ↑a = 0 ↔ a = 0 := by sorry

This theorem, `WithTop.coe_eq_zero`, states that for any type `α` that has a zero element, the equality holds between the lifted value `↑a = 0` and the original value `a = 0`. In other words, the element `a` of type `α` is zero if and only if its lifted version (via `WithTop.coe`, which injects `α` into `WithTop α`) is also zero.

For any type `α` with a zero element, the lifted value `WithTop.coe a` equals zero if and only if the original value `a` is zero.


theorem Mathlib.SetTheory.Ordinal.Arithmetic._auxLemma.18 :
    ∀ {α : Type u} [inst : LinearOrder α] {a b : α}, (¬a < b) = (b ≤ a) := by sorry

This theorem from the Mathlib library in Set Theory's Ordinal Arithmetic section states that for any given type `α` with a linear order, for any two elements `a` and `b` of this type, the condition of `a` not being less than `b` (`¬a < b`) is equivalent to `b` being less than or equal to `a` (`b ≤ a`). This is a basic property of ordered sets being formalized, and mirrors the statement we have in mathematics that if one element is not smaller than another, then the second must be smaller or equal to the first.

For any linear order type `α`, the conditions `a ≤ b` and `¬a < b` are equivalent for all elements `a` and `b` of `α`.


Stream'.coinduction

theorem Stream'.coinduction :
    ∀ {α : Type u} {s₁ s₂ : Stream' α},
      Stream'.head s₁ = Stream'.head s₂ →
        (∀ (β : Type u) (fr : Stream' α → β), fr s₁ = fr s₂ → fr (Stream'.tail s₁) = fr (Stream'.tail s₂)) → s₁ = s₂ :=
  by sorry

The `Stream'.coinduction` theorem expresses a coinduction principle for infinite streams of elements of a given type `α`. It asserts that for any two streams `s₁` and `s₂` of type `α`, if the head of `s₁` is equal to the head of `s₂` and for all types `β` and all functions `fr` from a stream to type `β`, if `fr` applied to `s₁` is equal to `fr` applied to `s₂`, then `fr` applied to the tail of `s₁` is equal to `fr` applied to the tail of `s₂`. This implies that the two streams `s₁` and `s₂` are equal. In other words, two streams are the same if they have the same head and their tails behave the same under any function from streams to another type.

If two infinite streams over a type have equal heads and agree on the behavior of every function from streams to another type when applied to their tails, then the streams are equal.


theorem Prod.snd_iSup :
    ∀ {α : Type u_1} {β : Type u_2} {ι : Sort u_5} [inst : SupSet α] [inst_1 : SupSet β] (f : ι → α × β),
      (iSup f).2 = ⨆ i, (f i).2 :=
  by sorry

The theorem `Prod.snd_iSup` states that for any types `α` and `β`, and any index type `ι`, given a function `f : ι → α × β` that maps elements of `ι` to pairs of elements from `α` and `β`, and given that `α` and `β` have supremum sets, the second component of the indexed supremum of `f` (`iSup f`).2 is equal to the supremum over `ι` of the second component of `f(i)` (`f i).2. In mathematical terms, it states that $\sup_{i} f(i)_2 = (\sup_i f(i))_2$, where $f(i)_2$ denotes the second component of the pair produced by `f`.

The second component of the indexed supremum of a function mapping elements from an index type to pairs equals the supremum of the second components of the function values over the index type.


theorem Complex.normSq_eq_abs : ∀ (x : ℂ), Complex.normSq x = Complex.abs x ^ 2 := by sorry

This theorem states that for any complex number `x`, the square of its absolute value (denoted as `Complex.abs x ^ 2`) is equal to its squared norm (denoted as `Complex.normSq x`). In other words, it asserts the equivalence between the square of a complex number's absolute value and its norm squared. This is closely related to the Pythagorean theorem in the complex number realm, as the absolute value and squared norm are the counterparts of the length of the hypotenuse and the sum of the squares of the other two sides, respectively.

For any complex number x, the square of its absolute value equals its squared norm (i.e., Complex.abs x ^ 2 = Complex.normSq x).


/-- Suppose `X Y : SheafedSpace C`, where `C` is a concrete category,
whose forgetful functor reflects isomorphisms, preserves limits and filtered colimits.
Then a morphism `X ⟶ Y` that is a topological open embedding
is an open immersion iff every stalk map is an iso.
 -/
theorem AlgebraicGeometry.SheafedSpace.IsOpenImmersion.of_stalk_iso :
    ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.Limits.HasLimits C]
      [inst_2 : CategoryTheory.Limits.HasColimits C] [inst_3 : CategoryTheory.ConcreteCategory C]
      [inst_4 : CategoryTheory.ReflectsIsomorphisms (CategoryTheory.forget C)]
      [inst_5 : CategoryTheory.Limits.PreservesLimits (CategoryTheory.forget C)]
      [inst_6 : CategoryTheory.Limits.PreservesFilteredColimits (CategoryTheory.forget C)]
      {X Y : AlgebraicGeometry.SheafedSpace C} (f : X ⟶ Y),
      OpenEmbedding ⇑f.base →
        ∀ [H : ∀ (x : ↑↑X.toPresheafedSpace), CategoryTheory.IsIso (AlgebraicGeometry.PresheafedSpace.stalkMap f x)],
          AlgebraicGeometry.SheafedSpace.IsOpenImmersion f :=
  by sorry

This theorem is about sheafed spaces in the context of a concrete category `C`. Suppose `X` and `Y` are sheafed spaces in this category, and `C` has special properties: it has limits and colimits, its forgetful functor reflects isomorphisms, and preserves limits and filtered colimits. Then, if a morphism `f` from `X` to `Y` is a topological open embedding, it will be an open immersion if and only if every stalk map induced by `f` is an isomorphism. Stalk maps are maps between the stalks of the sheaves at corresponding points, and an isomorphism of stalk maps implies that the morphism `f` is locally an isomorphism in the category `C`. Being an open immersion means that `f` is a monomorphism in the category of sheafed spaces and the underlying continuous map is an open embedding.

A topological open embedding between sheafed spaces in a category with preserving and reflecting isomorphisms for limits and colimits is an open immersion if and only if all induced stalk maps are isomorphisms.


/-- A subsemiring contains the semiring's 1.  -/
theorem Subsemiring.one_mem : ∀ {R : Type u} [inst : NonAssocSemiring R] (s : Subsemiring R), 1 ∈ s := by sorry

This theorem states that for any given type `R` that has a structure of a non-associative semiring, the multiplicative identity (1) of the semiring is always an element of any subsemiring `s` of `R`. Thus, the structure of a subsemiring always inherits the multiplicative identity from its parent semiring.

For any non-associative semiring `R` and subsemiring `s` of `R`, the multiplicative identity of `R` is an element of `s`.


theorem Set.eq_of_subset_of_ncard_le :
    ∀ {α : Type u_1} {s t : Set α}, s ⊆ t → Set.ncard t ≤ Set.ncard s → autoParam (Set.Finite t) _auto✝ → s = t := by
  sorry

This theorem states that for any given type `α` and any given sets `s` and `t` of this type, if `s` is a subset of `t` and the cardinality of `t` is less than or equal to the cardinality of `s` (with the assumption that `t` is a finite set), then `s` and `t` are actually the same set. Note that the `autoParam` for `Set.Finite t` is a mechanism to automatically provide the proof for `t` being a finite set.

If `α` is a type, `s` and `t` are subsets of `α`, `s` is a subset of `t`, and `t` is finite, then `s` and `t` are equal.


theorem edist_pi_le_iff :
    ∀ {β : Type v} {π : β → Type u_2} [inst : Fintype β] [inst_1 : (b : β) → EDist (π b)] {f g : (b : β) → π b}
      {d : ENNReal}, edist f g ≤ d ↔ ∀ (b : β), edist (f b) (g b) ≤ d :=
  by sorry

The theorem `edist_pi_le_iff` states that for all types `β` and `π` functions from `β` to `π`, given the condition that `β` is a finite type and for all `b` in `β` there is an extended distance `EDist` on `π b`, for any two functions `f` and `g` from `β` to `π b` and an extended nonnegative real number `d`, the extended distance between `f` and `g` is less than or equal to `d` if and only if the extended distance between `f b` and `g b` for all `b` in `β` is less than or equal to `d`. In other words, the extended distance between the two functions `f` and `g` is bounded by `d` if and only if the extended distance between each of the corresponding elements they produce is also bounded by `d` for all elements in `β`.

For functions `f` and `g` from a finite type `β` to a type `π` equipped with an extended distance, `EDist`, the extended distance between `f` and `g` is less than or equal to a given extended nonnegative real number `d` if and only if the extended distance between `f(b)` and `g(b)` is less than or equal to `d` for all `b` in `β`.


theorem EReal.nhds_bot_basis : Filter.HasBasis (nhds ⊥) (fun x => True) fun x => Set.Iio ↑x := by sorry

This theorem states that the neighborhood filter at the bottom element, represented as `⊥` in extended real numbers (`EReal`), has a basis consisting of left-infinite right-open intervals. In other words, the filter of all neighborhoods around negative infinity in the extended real numbers has a basis such that each basis element is a set of real numbers less than some given real number. This basis is represented by the predicate function that always returns true.

The neighborhood filter at the bottom element of extended real numbers has a basis consisting of left-infinite right-open intervals.


theorem AddSubgroup.inclusion_injective :
    ∀ {G : Type u_1} [inst : AddGroup G] {H K : AddSubgroup G} (h : H ≤ K),
      Function.Injective ⇑(AddSubgroup.inclusion h) :=
  by sorry

The theorem `AddSubgroup.inclusion_injective` states that for any type `G` that forms an additive group, and any additive subgroups `H` and `K` of `G` such that `H` is contained in `K`, the inclusion homomorphism from `H` to `K` is injective. In other words, if we have two elements in `H` that are mapped to the same element in `K` by the inclusion homomorphism, then those two elements were actually the same to start with.

If `H` is an additive subgroup of an additive group `G` with `H` contained in `K`, then the inclusion homomorphism from `H` to `K` is injective.


/-- If `s : Set α` is a nonempty countable set, then there exists a map
`f : ℕ → α` such that `s = range f`.  -/
theorem Set.Countable.exists_eq_range :
    ∀ {α : Type u} {s : Set α}, Set.Countable s → Set.Nonempty s → ∃ f, s = Set.range f := by sorry

The theorem `Set.Countable.exists_eq_range` states that given any nonempty countable set `s` of type `α`, there exists a function `f` from the set of natural numbers `ℕ` to `α` such that the set `s` is equal to the range of `f`. In other words, for any nonempty countable set, we can find a function that maps each natural number to a unique element in the set, thereby covering all elements of the set.

Given a nonempty countable set, there exists a function from natural numbers to set elements such that the set is the range of that function.


theorem OnePoint.isOpen_compl_image_coe :
    ∀ {X : Type u_1} [inst : TopologicalSpace X] {s : Set X}, IsOpen (OnePoint.some '' s)ᶜ ↔ IsClosed s ∧ IsCompact s :=
  by sorry

The theorem `OnePoint.isOpen_compl_image_coe` states that for any type `X` with a topology and a set `s` of `X`, the set complement of the image of `s` under the `OnePoint.some` function is open if and only if the set `s` is both closed and compact in the topological space `X`. In other words, the image of `s` under `OnePoint.some` has an open complement if and only if `s` is a compact and closed set in the topological space.

The set complement of the image of a compact and closed set `s` in a topological space under the `OnePoint.some` function is open.


theorem Finsupp.unique_single :
    ∀ {α : Type u_1} {M : Type u_5} [inst : Zero M] [inst_1 : Unique α] (x : α →₀ M), x = fun₀ | default => x default :=
  by sorry

The theorem `Finsupp.unique_single` states that for any type `α` and a type `M` with a zero element, provided that `α` is unique, for any function `x` from `α` to `M` that has finite support (`α →₀ M`), `x` can be represented as a function which maps all elements in `α` to the default value of `x`. In other words, if `α` has only one element, any function from `α` to `M` with finite support can only have one possible mapping, which is to map the single element in `α` to its default value in `M`.

If `α` is a type with a unique element, then any function from `α` to a type `M` with a zero element and finite support maps the unique element in `α` to its default value in `M`.


theorem AddCommute.zsmul_right :
    ∀ {G : Type w} [inst : AddGroup G] {a b : G}, AddCommute a b → ∀ (m : ℤ), AddCommute a (m • b) := by sorry

The theorem `AddCommute.zsmul_right` states that for any type `G` that is an additive group, given two elements `a` and `b` of `G` that commute additively (i.e., `a + b = b + a`), and any integer `m`, the operation `a` and `m • b` (where `m • b` signifies the operation of scalar multiplication of `b` by `m`) also commute additively. This means that if `a` and `b` commute in the group `G`, then `a` also commutes with any integer multiple of `b`.

If `a` and `b` are elements of an additive group `G` that commute (i.e., `a + b = b + a`), then for any integer `m`, `a` commutes with `m • b` (`a + (m • b) = (m • b) + a`).


theorem Mathlib.SetTheory.Ordinal.Arithmetic._auxLemma.39 : ∀ (o : Ordinal.{u_3}), (0 ≤ o) = True := by sorry

This theorem states that for every ordinal 'o' in the type of well orders in a given type 'u_3', it is always true that 'o' is greater than or equal to zero. This is expressed in the theorem as `(0 ≤ o) = True`, which means that the inequality 'o is greater than or equal to zero' always holds for any ordinal 'o'.

Every ordinal in a given type is greater than or equal to zero. (or equivalently, the zero ordinal is less than or equal to every ordinal in the given type.)


theorem Finset.fiber_nonempty_iff_mem_image :
    ∀ {α : Type u_1} {β : Type u_2} [inst : DecidableEq β] (f : α → β) (s : Finset α) (y : β),
      (Finset.filter (fun x => f x = y) s).Nonempty ↔ y ∈ Finset.image f s :=
  by sorry

The theorem `Finset.fiber_nonempty_iff_mem_image` states that for any types `α` and `β` with decidable equality on `β`, any function `f` from `α` to `β`, any finite set `s` of `α`, and any element `y` of `β`, the fiber of `f` over `y` in `s` (i.e., the set of elements of `s` mapped to `y` by `f`) is nonempty if and only if `y` is in the image of `f` on `s`. In other words, there is an element of `s` that `f` maps to `y` if and only if `y` is a value `f` takes on `s`.

For any function `f` from type `α` to type `β` with decidable equality on `β`, a finite set `s` of `α`, and an element `y` of `β`, the fiber of `f` over `y` in `s` is nonempty if and only if `y` is in the image of `f` on `s`.


theorem Nat.ceil_lt_add_one :
    ∀ {α : Type u_2} [inst : LinearOrderedSemiring α] [inst_1 : FloorSemiring α] {a : α}, 0 ≤ a → ↑⌈a⌉₊ < a + 1 := by
  sorry

This theorem, `Nat.ceil_lt_add_one`, states that for any non-negative real number `a` (denoted as `α`), the ceiling function of `a` (denoted as `⌈a⌉₊`) when converted back to real number, is strictly less than `a` plus one. In other words, the ceiling of any non-negative real number is always less than the next integer in the number line. This is applicable in the context of a linearly ordered semiring and a floor semiring.

For any non-negative real number `α`, the ceiling function `⌈α⌉₊` satisfies `⌈α⌉₊ < α + 1`.


theorem Monoid.lcm_orderOf_eq_exponent :
    ∀ {G : Type u} [inst : Monoid G] [inst_1 : Fintype G], Finset.lcm Finset.univ orderOf = Monoid.exponent G := by
  sorry

The theorem `Monoid.lcm_orderOf_eq_exponent` states that for any type `G` that has a monoid structure and is also a finite type, the least common multiple (lcm) of the order of each element in the universal finite set (`Finset.univ`) is equal to the exponent of the monoid `G`. In other words, the smallest positive integer `n` such that raising any element of the group to the power of `n` yields the identity element (if such an integer exists), is equal to the least common multiple of the orders of all elements in the group. If no such integer exists, the convention is to return `0`.

For any finite monoid `G`, the least common multiple of the orders of its elements equals the exponent of the monoid `G`. If no such common exponent exists, the result is `0`.


theorem Set.preimage_mul_const_Ici_of_neg :
    ∀ {α : Type u_1} [inst : LinearOrderedField α] (a : α) {c : α},
      c < 0 → (fun x => x * c) ⁻¹' Set.Ici a = Set.Iic (a / c) :=
  by sorry

The theorem `Set.preimage_mul_const_Ici_of_neg` states that for any type `α` which is a linear ordered field, a value `a` of type `α`, and a value `c` of type `α` that is less than zero, the preimage of the set of all `x` such that `a` is less than or equal to `x * c` is equal to the set of all `x` such that `x` is less than or equal to `a / c`. In mathematical terms, for a negative constant `c`, the operation of multiplying by `c` transforms the interval `[a, ∞)` to `(-∞, a/c]`.

For any linear ordered field `α`, `a : α` with `c : α` negative, the set inverse images under multiplication by `c` of the sets `{x : α | a ≤ x}` and `{x : α | x ≤ a / c}` are equal.


Matroid.Base.exchange

theorem Matroid.Base.exchange :
    ∀ {α : Type u_1} {M : Matroid α} {B₁ B₂ : Set α} {e : α},
      M.Base B₁ → M.Base B₂ → e ∈ B₁ \ B₂ → ∃ y ∈ B₂ \ B₁, M.Base (insert y (B₁ \ {e})) :=
  by sorry

The Base Exchange Theorem in Matroid states that for any type `α` and any matroid `M` of type `α`, and for any two sets `B₁` and `B₂` of type `α`, and an element `e` of type `α`, if `B₁` and `B₂` are both bases of `M` and if `e` is an element of the difference of `B₁` and `B₂`, then there exists an element `y` in the difference of `B₂` and `B₁` such that the set obtained by inserting `y` into the difference of `B₁` and the singleton set `{e}` is also a base of `M`.

In simpler terms, if `B₁` and `B₂` are bases of the same matroid and `e` is in `B₁` but not in `B₂`, then there's an element `y` in `B₂` (but not in `B₁`) such that if we remove `e` from `B₁` and add `y`, the resulting set is still a base of the matroid. This theorem is a cornerstone in the theory of matroids, underlying the concept of bases exchangeability.

If two bases of a matroid differ by exactly one element, then there exists an element in each base that can be exchanged to obtain another base.


theorem Set.mul_subset_mul :
    ∀ {α : Type u_2} [inst : Mul α] {s₁ s₂ t₁ t₂ : Set α}, s₁ ⊆ t₁ → s₂ ⊆ t₂ → s₁ * s₂ ⊆ t₁ * t₂ := by sorry

This theorem, named `Set.mul_subset_mul`, states that for any type `α` that has a multiplication operation (`Mul α`), if we have four sets of elements of type `α` (denoted by `s₁`, `s₂`, `t₁`, and `t₂`), and if `s₁` is a subset of `t₁` and `s₂` is a subset of `t₂`, then the set formed by multiplying elements from `s₁` and `s₂` is a subset of the set formed by multiplying elements from `t₁` and `t₂`. This is expressed in the language of set theory using the subset symbol `⊆` and the multiplication operation on sets `*`.

If `s₁ ⊆ t₁` and `s₂ ⊆ t₂`, then `s₁ * s₂ ⊆ t₁ * t₂`, where `*` denotes set multiplication over types with a defined multiplication operation.


theorem PartialHomeomorph.IsImage.iff_symm_preimage_eq :
    ∀ {X : Type u_1} {Y : Type u_3} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y]
      {e : PartialHomeomorph X Y} {s : Set X} {t : Set Y},
      PartialHomeomorph.IsImage e s t ↔ e.target ∩ ↑(PartialHomeomorph.symm e) ⁻¹' s = e.target ∩ t :=
  by sorry

This theorem states that for any given topological spaces `X` and `Y`, a partial homeomorphism `e` from `X` to `Y`, and two sets `s` of `X` and `t` of `Y`, the set `t` is an image of the set `s` under the partial homeomorphism `e` if and only if the intersection of the target of `e` and the preimage of the set `s` under the inverse of `e` equals the intersection of the target of `e` and the set `t`.

For any topological spaces X and Y, a partial homeomorphism e from X to Y, and sets s in X and t in Y, s is the image of t under e if and only if e(s^-1) ∩ t = e(s^-1) ∩ e(s).


theorem iSup_univ :
    ∀ {α : Type u_1} {β : Type u_2} [inst : CompleteLattice α] {f : β → α}, ⨆ x ∈ Set.univ, f x = ⨆ x, f x := by sorry

This theorem, `iSup_univ`, states that for any types `α` and `β`, where `α` is a complete lattice, and for any function `f` from `β` to `α`, the supremum (⨆) of the function `f` over all elements `x` in the universal set of `β` is the same as the supremum of the function `f` over all elements `x` of type `β`. In other words, taking the supremum of the function `f` over the universal set (which contains all elements of `β`) is equivalent to taking the supremum of `f` over the entire type `β`.

For any complete lattice α and function f from type β to α, the supremum of f over the universal set of β equals the supremum of f over type β.


theorem cauchy_map_iff_exists_tendsto :
    ∀ {α : Type u} {β : Type v} [uniformSpace : UniformSpace α] [inst : CompleteSpace α] {l : Filter β} {f : β → α}
      [inst : Filter.NeBot l], Cauchy (Filter.map f l) ↔ ∃ x, Filter.Tendsto f l (nhds x) :=
  by sorry

The theorem `cauchy_map_iff_exists_tendsto` states that for any types `α` and `β` where `α` is a uniform and complete space, given a filter `l` over `β` that is not the bottom filter, and a function `f` mapping from `β` to `α`, the filter formed by mapping `f` over `l` is Cauchy if and only if there exists an element `x` for which `f` tends to (in the sense of filters) the neighborhood filter at `x`. In mathematical terms, this theorem connects the property of a filter being Cauchy with the existence of a limit in the topological sense, under the action of a function.

A filter `l` over a uniform and complete space `β` maps to a Cauchy filter in `α` under a function `f:` `β` → `α` if and only if there exists an `x` in `α` such that `f` tends to the neighborhood filter at `x`.


/-- An induction principle for closure membership. If `p` holds for `0`, `1`, and all elements
of `s`, and is preserved under addition, negation, and multiplication, then `p` holds for all
elements of the closure of `s`.  -/
theorem NonUnitalSubring.closure_induction :
    ∀ {R : Type u} [inst : NonUnitalNonAssocRing R] {s : Set R} {p : R → Prop} {x : R},
      x ∈ NonUnitalSubring.closure s →
        (∀ x ∈ s, p x) →
          p 0 →
            (∀ (x y : R), p x → p y → p (x + y)) →
              (∀ (x : R), p x → p (-x)) → (∀ (x y : R), p x → p y → p (x * y)) → p x :=
  by sorry

This theorem, `NonUnitalSubring.closure_induction`, provides an induction principle for membership in the closure of a set `s` under the context of a non-unital non-associative ring `R`. It states that for any ring element `x` and a property `p` on elements of `R`, if `x` is in the closure of `s`, `p` holds for all elements of `s`, `p` is true for the additive identity `0` and `1`, `p` is preserved under addition, negation and multiplication of any two elements of `R`, then `p` is also true for `x`. In simpler terms, if a property holds for `0`, `1`, all elements in a set, and is preserved under the ring operations, then it holds for all elements in the closure of the set in a non-unital non-associative ring context.

In a non-unital non-associative ring, if a property holds for 0, 1, and all elements in a set, and is preserved under addition, negation, and multiplication, then the property holds for all elements in the closure of the set.


theorem Mathlib.MeasureTheory.Constructions.BorelSpace.Basic._auxLemma.22 :
    ∀ {α : Type u} (x : α), (x ∈ Set.univ) = True := by sorry

This theorem states that for any type `α` and any element `x` of type `α`, the statement "x is in the universal set of α" is always true. In other words, every element of a given type is contained in the universal set of that type. Here, the universal set `Set.univ` of a type `α` is defined as the set containing all elements of `α`.

For any type `α` and element `x` of type `α`, `x` is an element of the universal set `Set.univ` of type `α`.


/-- Two solutions are equal if their `x` and `y` components are equal.  -/
theorem Pell.Solution₁.ext :
    ∀ {d : ℤ} {a b : Pell.Solution₁ d},
      Pell.Solution₁.x a = Pell.Solution₁.x b → Pell.Solution₁.y a = Pell.Solution₁.y b → a = b :=
  by sorry

The theorem `Pell.Solution₁.ext` states that for any integer `d` and any two solutions `a` and `b` to the Pell equation `x^2 - d*y^2 = 1`, if the `x` component of `a` is equal to the `x` component of `b` and the `y` component of `a` is equal to the `y` component of `b`, then the solutions `a` and `b` themselves are equal. In other words, two solutions to the Pell equation are identical if they have the same `x` and `y` components.

If two solutions (x₁, y₁) and (x₂, y₂) satisfy x₁^2 - d*y₁^2 = 1 and x₂^2 - d*y₂^2 = 1 with x₁ = x₂ and y₁ = y₂, then (x₁, y₁) = (x₂, y₂).


theorem NormedSpace.star_exp :
    ∀ {𝕂 : Type u_1} {𝔸 : Type u_2} [inst : Field 𝕂] [inst_1 : Ring 𝔸] [inst_2 : Algebra 𝕂 𝔸]
      [inst_3 : TopologicalSpace 𝔸] [inst_4 : TopologicalRing 𝔸] [inst_5 : T2Space 𝔸] [inst_6 : StarRing 𝔸]
      [inst_7 : ContinuousStar 𝔸] (x : 𝔸), star (NormedSpace.exp 𝕂 x) = NormedSpace.exp 𝕂 (star x) :=
  by sorry

This theorem, `NormedSpace.star_exp`, states that for any two types, `𝕂` and `𝔸`, where `𝕂` is a field, `𝔸` is a ring, `𝔸` is an algebra over `𝕂`, `𝔸` has a star operation (that is, it is a star ring), and `𝔸` has a topology that makes it a topological space, a topological ring, and it is Hausdorff (T2 space), and the star operation is continuous (ContinuousStar 𝔸), then the star of the exponential function `NormedSpace.exp 𝕂 x` is equal to the exponential function of the star of `x`, `NormedSpace.exp 𝕂 (star x)`. This essentially means that the star operation commutes with the exponential function in this normed space context.

If `𝕂` is a field, `𝔸` is a commutative topological Hausdorff star ring over `𝕂`, `𝔸` has a topology making it a normed space, and the star operation is continuous, then the star of the exponential function is equal to the exponential function of the star of any element in `𝔸`.


/-- Note that this goal could also be stated `(Disjoint on f) a b`  -/
theorem Disjoint.map_orderIso :
    ∀ {α : Type u_2} {β : Type u_3} [inst : SemilatticeInf α] [inst_1 : OrderBot α] [inst_2 : SemilatticeInf β]
      [inst_3 : OrderBot β] {a b : α} (f : α ≃o β), Disjoint a b → Disjoint (f a) (f b) :=
  by sorry

The theorem `Disjoint.map_orderIso` states that for any two elements `a` and `b` in a semilattice with a bottom element (which is a type of partial order), if `a` and `b` are disjoint, then their images under any order isomorphism `f` also are disjoint.

Here, `Disjoint a b` means that any element `x` which is less than or equal to both `a` and `b` is also less than or equal to the bottom element (denoted `⊥`). This definition of disjointness generalizes the concept of disjoint sets. An order isomorphism `f` is a bijective function that preserves the order relation, that is, for any two elements `x` and `y`, `x ≤ y` if and only if `f(x) ≤ f(y)`.

If `a` and `b` are disjoint elements in a semilattice with a bottom element and `f` is an order isomorphism, then `f(a)` and `f(b)` are also disjoint.


theorem ContinuousLinearMap.smulRight_one_one :
    ∀ {R₁ : Type u_1} [inst : Semiring R₁] {M₂ : Type u_6} [inst_1 : TopologicalSpace M₂] [inst_2 : AddCommMonoid M₂]
      [inst_3 : Module R₁ M₂] [inst_4 : TopologicalSpace R₁] [inst_5 : ContinuousSMul R₁ M₂] (c : R₁ →L[R₁] M₂),
      ContinuousLinearMap.smulRight 1 (c 1) = c :=
  by sorry

The theorem `ContinuousLinearMap.smulRight_one_one` states that for any continuous linear map `c`, in the context of a semiring `R₁`, a topological space `M₂` that is also an additive commutative monoid and a module over `R₁`, with continuous scalar multiplication from `R₁` to `M₂`, and a topology on `R₁`, `c` applied to 1 is equivalent to scalar multiplication by 1 (using `smulRight`) on the result of `c` applied to 1. This essentially says that scalar multiplication by 1 does not change the output of the continuous linear map when applied to 1.

For any continuous linear map `c` from a semiring `R₁` to a topological additive commutative monoid and module `M₂` over `R₁`, with continuous scalar multiplication, `c(1) = smulRight 1 (c 1)` in `M₂`.


theorem Complex.ofReal_exp_ofReal_re : ∀ (x : ℝ), ↑(Complex.exp ↑x).re = Complex.exp ↑x := by sorry

This theorem states that for any real number 'x', the real part of the complex exponential of 'x' (when 'x' is considered as a complex number by treating it as the real part and setting the imaginary part to zero), is equal to the complex exponential of 'x' itself. This identifies a property of the complex exponential function - when applied to real numbers, it essentially behaves like the real exponential function with respect to the real part.

The real part of the complex exponential of a real number 'x' is equal to the complex exponential of 'x' itself. In other words, Re(e^(x + i*0)) = e^x.


theorem Nat.cast_max : ∀ {α : Type u_3} [inst : LinearOrderedSemiring α] {a b : ℕ}, ↑(max a b) = max ↑a ↑b := by sorry

This theorem states that for any two natural numbers, `a` and `b`, and any type `α` that forms a linear ordered semiring, the maximum of `a` and `b` when cast into type `α` is the same as the maximum of `a` and `b` when each is individually cast into `α`. In other words, it doesn't matter if you take maximum before or after the casting operation, the result will be the same.

For any natural numbers `a` and `b` and a linear ordered semiring type `α`, the maximum of `a` and `b` in `α` is equal to the maximum of `a` and `b` each cast individually into `α`.


/-- Expand the square  -/
theorem norm_add_mul_self :
    ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
      (x y : E), ‖x + y‖ * ‖x + y‖ = ‖x‖ * ‖x‖ + 2 * RCLike.re ⟪x, y⟫_𝕜 + ‖y‖ * ‖y‖ :=
  by sorry

The theorem `norm_add_mul_self` states that for any two elements `x` and `y` of an inner product space over a certain field `𝕜` (which has a property defined by the type class `RCLike`), the square of the norm of `x + y` equals the sum of the square of the norm of `x`, twice the real part of the inner product of `x` and `y`, and the square of the norm of `y`. In mathematical notation, this would be expressed as ‖x + y‖^2 = ‖x‖^2 + 2 Re⟨x, y⟩ + ‖y‖^2. This is essentially the law of cosines in the context of inner product spaces.

The theorem `norm_add_mul_self` asserts that for elements `x` and `y` in an inner product space over a field `𝕜` with the `RCLike` property, the norm of their sum squared equals the sum of the squares of their individual norms, plus twice the real part of their inner product.


/-- The conditional cdf is a measurable function of `a : α` for all `x : ℝ`.  -/
theorem ProbabilityTheory.measurable_condCDF :
    ∀ {α : Type u_1} {mα : MeasurableSpace α} (ρ : MeasureTheory.Measure (α × ℝ)) (x : ℝ),
      Measurable fun a => ↑(ProbabilityTheory.condCDF ρ a) x :=
  by sorry

The theorem `ProbabilityTheory.measurable_condCDF` states that for any measure `ρ` on the product space of a measurable space `α` and the real numbers, and for any real number `x`, the function which maps each element of `α` to the value at `x` of the conditional cumulative distribution function (CDF) of the measure given the element is measurable. In other words, the conditional CDF, evaluated at a fixed real number `x`, is a measurable function of `a : α`.

For any measure $\rho$ on the product space of a measurable space $\alpha$ and the real numbers, the function mapping each $a \in \alpha$ to the value at $x$ of the conditional cumulative distribution function of $\rho$ given $a$ is measurable.


theorem Ordinal.mul_le_of_limit : ∀ {a b c : Ordinal.{u_4}}, Ordinal.IsLimit b → (a * b ≤ c ↔ ∀ b' < b, a * b' ≤ c) :=
  by sorry

The theorem `Ordinal.mul_le_of_limit` states that for any three ordinals `a`, `b`, and `c`, if `b` is a limit ordinal, then the product `a * b` is less than or equal to `c` if and only if for all `b'` less than `b`, the product `a * b'` is less than or equal to `c`. In essence, this theorem relates the property of being a limit ordinal with the property of respecting a certain order inequality when multiplied by another ordinal.

For any ordinals `a`, `b`, and `c`, if `b` is a limit ordinal, then `a * b <= c` if and only if `a * b' <= c` for all `b' < b`.


theorem AddSubgroup.add_mem_cancel_left :
    ∀ {G : Type u_1} [inst : AddGroup G] (H : AddSubgroup G) {x y : G}, x ∈ H → (x + y ∈ H ↔ y ∈ H) := by sorry

This theorem states that for any additive group `G` and any subgroup `H` of `G`, if an element `x` belongs to `H`, then another element `y` belongs to `H` if and only if the result of adding `x` to `y` also belongs to `H`. This is essentially saying that in an additive group, if a particular element is in a subgroup, then adding that element to another does not change the membership status of the second element in the subgroup.

For any additive group G and subgroup H, if x is in H and y belongs to G, then x + y is in H if and only if y is in H.


theorem PiLp.nnnorm_eq_ciSup :
    ∀ {ι : Type u_2} {β : ι → Type u_4} [inst : Fintype ι] [inst_1 : (i : ι) → SeminormedAddCommGroup (β i)]
      (f : PiLp ⊤ β), ‖f‖₊ = ⨆ i, ‖f i‖₊ :=
  by sorry

The theorem `PiLp.nnnorm_eq_ciSup` states that for any type `ι`, any function `β : ι → Type`, given that `ι` is a finite type and that for each `i : ι`, `β i` forms a seminormed additive commutative group, then for any function `f` from the Pi type with the `L^∞` distance (`PiLp ⊤ β`), the non-negative norm of `f` (`‖f‖₊`) is equal to the supremum (the least upper bound) over all `i`, of the non-negative norm of `f i` (`‖f i‖₊`).

For any finite type `ι` and a function `β : ι → Type` such that each `β i` forms a seminormed additive commutative group, the `L^∞` norm of a function `f` from the Pi type `PiLp ⊤ β` equals the supremum of the `L^∞` norms of `f i` over all `i` in `ι`.


theorem Multiset.map_lt_map :
    ∀ {α : Type u_1} {β : Type v} {f : α → β} {s t : Multiset α}, s < t → Multiset.map f s < Multiset.map f t := by
  sorry

The theorem `Multiset.map_lt_map` states that for any given types `α` and `β`, a function `f` from `α` to `β`, and multisets `s` and `t` of type `α`, if `s` is less than `t`, then the multiset obtained by mapping `f` over `s` is less than the multiset obtained by mapping `f` over `t`. In other words, if a multiset `s` is a proper subset of another multiset `t` (i.e., `s` has fewer elements than `t` or `s` is equal to `t` except for at least one additional element in `t`), applying a function to each element of `s` results in a multiset that is also a proper subset of the result of applying the same function to each element of `t`.

For any types `α`, multisets `s` and `t` of `α`, and function `f` from `α` to `β`, if `s` is a proper subset of `t`, then `Map f s` is a proper subset of `Map f t`.


IsMinFilter.congr

theorem IsMinFilter.congr :
    ∀ {α : Type u_1} {β : Type u_2} [inst : Preorder β] {f g : α → β} {a : α} {l : Filter α},
      IsMinFilter f l a → f =ᶠ[l] g → f a = g a → IsMinFilter g l a :=
  by sorry

The theorem `IsMinFilter.congr` states that for any two functions `f` and `g` from a type `α` to a type `β` with a preorder, if `f` is a minimal element in some filter `l` around a point `a` (meaning `f a` is less than or equal to `f x` for all `x` in a neighborhood defined by `l`), and if `f` and `g` are eventually equal in the filter `l`, and `f a` equals `g a`, then `g` is also a minimal element in the filter `l` around `a`. This theorem is a congruence property for minimality under a filter.

If functions `f` and `g` from type `α` to type `β` with a preorder have equal values at a point `a`, are eventually equal in a filter `l` around `a`, and `f` is minimal in `l` around `a`, then `g` is also minimal in `l` around `a`.


theorem Nat.min_comm : ∀ (a b : ℕ), min a b = min b a := by sorry

This theorem states that the minimum operation over natural numbers is commutative. In other words, for any two natural numbers `a` and `b`, the minimum of `a` and `b` is the same as the minimum of `b` and `a`. This aligns with the intuitive concept of minimum, where the order of the two numbers doesn't affect the result.

For all natural numbers `a` and `b`, `a minimun b` equals `b minimum a`.


theorem AffineIsometry.map_vsub :
    ∀ {𝕜 : Type u_1} {V : Type u_2} {V₂ : Type u_5} {P : Type u_10} {P₂ : Type u_11} [inst : NormedField 𝕜]
      [inst_1 : SeminormedAddCommGroup V] [inst_2 : NormedSpace 𝕜 V] [inst_3 : PseudoMetricSpace P]
      [inst_4 : NormedAddTorsor V P] [inst_5 : SeminormedAddCommGroup V₂] [inst_6 : NormedSpace 𝕜 V₂]
      [inst_7 : PseudoMetricSpace P₂] [inst_8 : NormedAddTorsor V₂ P₂] (f : P →ᵃⁱ[𝕜] P₂) (p1 p2 : P),
      (AffineIsometry.linearIsometry f) (p1 -ᵥ p2) = f p1 -ᵥ f p2 :=
  by sorry

This theorem states that for any normed field `𝕜`, seminormed add commutative groups `V` and `V₂`, normed spaces over `𝕜` for `V` and `V₂`, pseudometric spaces `P` and `P₂`, and normed add torsors for `P` with `V` and `P₂` with `V₂`, if you have an affine isometry `f` from `P` to `P₂` and two points `p1` and `p2` from `P`, then applying the linear isometry of `f` to the vector from `p2` to `p1` (denoted `p1 -ᵥ p2`) is equivalent to taking the vector from `f p2` to `f p1` (denoted `f p1 -ᵥ f p2`). In simpler terms, an affine isometry preserves the vectors between points under its linear part.

Given an affine isometry between two normed pseudometric spaces and two points in the first space, the vectors between the points are equivalent under the affine isometry's linear part.


theorem Algebra.adjoin_int :
    ∀ {R : Type u_1} [inst : Ring R] (s : Set R), Algebra.adjoin ℤ s = subalgebraOfSubring (Subring.closure s) := by
  sorry

This theorem states that for any ring `R` and a set `s` of elements from `R`, the minimal subalgebra that includes `s` when the ring of scalars is the integers (`ℤ`) is equivalent to a `ℤ`-subalgebra generated by the subring closure of `s`. In essence, this theorem is expressing a relationship between the operations of adjoining to an algebra and the closure of a subring within the context of integer scalars.

The minimal subalgebra of a ring generated by a set of elements is equal to the subring generated by the closure of that set under addition and multiplication, when the ring of scalars is the integers.


theorem Fin.prod_const :
    ∀ {α : Type u_1} [inst : CommMonoid α] (n : ℕ) (x : α), (Finset.prod Finset.univ fun _i => x) = x ^ n := by sorry

This theorem, named `Fin.prod_const`, states that for any types `α` (which has a `CommMonoid` instance) and a natural number `n`, and an element `x` of type `α`, the product of `x` for each element in the universal finite set `Finset.univ` (which iterates over all elements of `α`), is equal to `x` raised to the power `n`. It essentially says that the product of a constant value over a finite set is equal to the constant raised to the power of the size of the set.

For any type `α` with a `CommMonoid` instance, and any natural number `n` and element `x` of `α`, the product of `x` over all elements in the universal finite set `Finset.univ` equals `x` raised to the power `n`.


ModelWithCorners.continuousAt

theorem ModelWithCorners.continuousAt :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {H : Type u_3} [inst_3 : TopologicalSpace H] (I : ModelWithCorners 𝕜 E H) {x : H},
      ContinuousAt (↑I) x :=
  by sorry

The theorem `ModelWithCorners.continuousAt` states that for any non-trivially normed field `𝕜`, any normed addition commutative group `E` that is also a normed space over `𝕜`, and any topological space `H`, if `I` is a model with corners based on these types, then the function associated with `I` (obtained by casting `I` to a function) is continuous at any point `x` in `H`. In other words, for any given point `x` in `H`, the function's output values tend towards the function's value at `x` as the input values tend towards `x`.

For any non-trivially normed field 𝕜, normed addition commutative group E over 𝕜 as a normed space, and topological space H, the function derived from a model with corners I over (𝕜, E, H) is continuous at any point x in H.


theorem Multiset.Pi.cons_ne :
    ∀ {α : Type u_1} [inst : DecidableEq α] {δ : α → Sort v} {m : Multiset α} {a a' : α} {b : δ a}
      {f : (a : α) → a ∈ m → δ a} (h' : a' ∈ a ::ₘ m) (h : a' ≠ a), Multiset.Pi.cons m a b f a' h' = f a' ⋯ :=
  by sorry

The theorem `Multiset.Pi.cons_ne` states that for any type `α` with decidable equality, a function `δ` from `α` to any sort `v`, a multiset `m` of `α`, elements `a` and `a'` of `α`, a term `b` of type `δ a`, and a function `f` mapping any element `a` of `α` in the multiset `m` to `δ a`: if `a'` belongs to multiset created by adding `a` to `m` (`a ::ₘ m`) and `a'` is not equal to `a`, then the `Multiset.Pi.cons` function applied to `m`, `a`, `b`, `f`, `a'`, and the proof that `a'` belongs to `a ::ₘ m` equals the application of function `f` to `a'` and the proof that `a'` belongs to `m`. In other words, `Multiset.Pi.cons` behaves like function `f` for elements not equal to the one being inserted.

For any type `α` with decidable equality, multiset `m` of `α`, function `δ : α →* any sort v`, function `f : α → δ`, `a` and `a'` in `α`, if `a'` is in `m` after adding `a` (`a :: m`) and `a ≠ a'`, then `Multiset.Pi.cons m a b f a' (in_multiset! a' (insert a m)) = f a' (in_multiset! a' m)`.


theorem Rel.core_inter :
    ∀ {α : Type u_1} {β : Type u_2} (r : Rel α β) (s t : Set β), Rel.core r (s ∩ t) = Rel.core r s ∩ Rel.core r t := by
  sorry

This theorem states that for any relation `r` between two types `α` and `β`, and any two sets `s` and `t` of type `β`, the core of the relation `r` with respect to the intersection of sets `s` and `t` is equal to the intersection of the cores of `r` with respect to sets `s` and `t` individually. In other words, if we consider the elements of `α` that are related through `r` *only* to elements in both `s` and `t`, they form the same set as the intersection of the elements related *only* to elements in `s` and the elements related *only* to elements in `t`.

Given a relation `r` between types `α` and `β`, for sets `s` and `t` of type `β`, the core of `r` on `s ∩ t` equals the intersection of the cores of `r` on `s` and `r` on `t`.


theorem AdjoinRoot.lift_root :
    ∀ {R : Type u} {S : Type v} [inst : CommRing R] {f : Polynomial R} [inst_1 : CommRing S] {i : R →+* S} {a : S}
      (h : Polynomial.eval₂ i a f = 0), (AdjoinRoot.lift i a h) (AdjoinRoot.root f) = a :=
  by sorry

The theorem `AdjoinRoot.lift_root` states that for all rings `R` and `S`, given a commutative ring structure on `R` and `S`, a polynomial `f` of type `R`, a ring homomorphism `i` from `R` to `S`, and an element `a` of `S` such that evaluating `f` at `a` via `i` is zero, then lifting `i` to a ring homomorphism from `AdjoinRoot f` to `S` and applying this to the root of `f` adjoined to `R` results in `a`. In other words, the lift of `i` sends the root of `f` in the adjoined ring back to the original root `a` in `S`.

Given a commutative ring homomorphism `i` from ring `R` to `S`, if `i(f(x)) = 0` in `S` for some polynomial `f` over `R` and an element `x` in `AdjoinRoot f`, then `i(√[f](x)) = √[f](i(x)) = a`, where `a` is the root of `f` in `S`.


theorem Mathlib.RingTheory.Valuation.ValuationSubring._auxLemma.2 :
    ∀ {K : Type u} [inst : Field K] (A : ValuationSubring K) (x : K), (x ∈ A.toSubring) = (x ∈ A) := by sorry

This theorem states that for any field `K` and any element `x` in `K`, the element `x` belongs to the valuation subring `A` of `K` if and only if `x` belongs to the subring generated by `A`. Here, a valuation subring `A` of a field `K` is a subring that is closed under valuation, meaning that for any `x` in `K`, either `x` or its inverse (if it exists) belongs to `A`.

A field element `x` belongs to the valuation subring `A` of a field `K` if and only if it is contained in the subring generated by `A`.


theorem Mathlib.RingTheory.Valuation.ValuationSubring._auxLemma.4 :
    ∀ {K : Type u} [inst : Field K] {Γ : Type u_1} [inst_1 : LinearOrderedCommGroupWithZero Γ] (v : Valuation K Γ)
      (x : K), (x ∈ Valuation.valuationSubring v) = (v x ≤ 1) :=
  by sorry

This theorem states that for any field `K`, any linearly ordered commutative group with zero `Γ`, any valuation `v` of the field `K` with values in `Γ`, and any element `x` of the field `K`, `x` is in the valuation subring associated with the valuation `v` if and only if the valuation of `x` is less than or equal to 1. In mathematical notation, this is saying that $x \in \text{Valuation.valuationSubring} \, v$ if and only if $v(x) \leq 1$.

A field element `x` belongs to the valuation subring of a valuation `v` if and only if the valuation `v` of `x` is less than or equal to 1.


theorem Mathlib.RingTheory.Valuation.ValuationSubring._auxLemma.7 :
    ∀ {α : Type u} [inst : PartialOrder α] {a b : α}, (a = b) = (a ≤ b ∧ b ≤ a) := by sorry

This theorem states that for any type `α` that has a partial order, and for any two elements `a` and `b` of this type, `a` is equal to `b` if and only if `a` is less than or equal to `b` and `b` is less than or equal to `a`. In other words, in a partially ordered set, two elements are equal if they are mutually less than or equal to each other.

In a partially ordered set, two elements are equal if and only if they mutually satisfy the relation x ≤ y and y ≤ x.


theorem Mathlib.Data.DFinsupp.Order._auxLemma.16 :
    ∀ {ι : Type u} {β : ι → Type v} [inst : DecidableEq ι] [inst_1 : (i : ι) → Zero (β i)]
      [inst_2 : (i : ι) → (x : β i) → Decidable (x ≠ 0)] {f : Π₀ (i : ι), β i} {i : ι},
      (i ∈ DFinsupp.support f) = (f i ≠ 0) :=
  by sorry

This theorem, named `Mathlib.Data.DFinsupp.Order._auxLemma.16`, states that for any type `ι`, for any function `β` mapping `ι` to another type, given that equality on `ι` is decidable, that for any `i` of type `ι` there exists a zero element in `β i`, and that for any `i` in `ι` and any `x` in `β i` it is decidable whether `x` is not equal to zero, then for any function `f` of type `Π₀ (i : ι), β i` (a function that takes in `i` from `ι` and outputs an element from `β i`), and any `i` of type `ι`, `i` is in the support set of `f` if and only if the function `f` evaluated at `i` is not equal to zero.

In simpler words, this theorem says that an element `i` is in the support set of a function `f` (i.e., it is a point where `f` is non-zero) if and only if `f(i)` is not zero. The support set is defined for functions that map from a type `ι` to another type through a function `β`, where it is decidable whether elements are equal in `ι` and whether elements are zero in `β i`.

For any function `f` mapping a decidably-equaled type `ι` to another type `β` with decidable zero tests, the support set of `f` equals {`i` in `ι` | `f i` ≠ 0}.


theorem fourier_zero : ∀ {T : ℝ} {x : AddCircle T}, (fourier 0) x = 1 := by sorry

The `fourier_zero` theorem states that, for any real number `T` and any point `x` on the additive circle `AddCircle T`, the Fourier series at the zeroth term, i.e., `(fourier 0)`, evaluates to 1. In other words, the zeroth Fourier monomial, which can be considered as an exponential function of the form `exp (2 π i n x / T)`, is equal to 1 for all `x` in the additive circle. This can be understood as a mathematical statement: "For every real number T and for every x in the quotient space of R by the integer multiples of T (denoted as AddCircle T), the value of the Fourier series at the zero'th coefficient is always 1."

For any real number T and every x in the additive circle T, the zeroth Fourier coefficient's corresponding term in the Fourier series equals 1.


theorem MeasureTheory.IsAddFundamentalDomain.sum_restrict_of_ac :
    ∀ {G : Type u_1} {α : Type u_3} [inst : AddGroup G] [inst_1 : AddAction G α] [inst_2 : MeasurableSpace α]
      {s : Set α} {μ : MeasureTheory.Measure α} [inst_3 : MeasurableSpace G] [inst_4 : MeasurableVAdd G α]
      [inst_5 : MeasureTheory.VAddInvariantMeasure G α μ] [inst_6 : Countable G] {ν : MeasureTheory.Measure α},
      MeasureTheory.IsAddFundamentalDomain G s μ →
        MeasureTheory.Measure.AbsolutelyContinuous ν μ → (MeasureTheory.Measure.sum fun g => ν.restrict (g +ᵥ s)) = ν :=
  by sorry

This theorem, "MeasureTheory.IsAddFundamentalDomain.sum_restrict_of_ac", states that for any Additive Group `G` and type `α`, given an action of `G` on `α`, a measurable space structure on `α`, a set `s` of type `α`, a measure `μ` on `α`, a measurable space structure on `G`, a measurable addition structure on `α` with `G`, a `G`-additive invariant measure `μ` on `α`, a countability on `G`, and another measure `ν` on `α`, if `s` is an additive fundamental domain of `G` with respect to measure `μ` and if measure `ν` is absolutely continuous with respect to measure `μ`, then the sum of the measures `ν` restricted to `g +ᵥ s` for all `g` in `G` is equal to the measure `ν`. Here, `g +ᵥ s` denotes the `G`-action on `s`.

For any additive group `G`, measurable space `α`, action of `G` on `α`, measurable space structure, additive invariant measure `μ` on `α` (countable `G`), measurable addition structure, measurable space structure on `G`, and measures `μ` and `ν` on `α` with `μ` being `G`-invariant and `ν` absolutely continuous with respect to `μ`, if `s` is an additive fundamental domain of `G` with respect to `μ`, then the sum of `ν` restricted to `g + s` for all `g` in `G` equals `ν`.


/-- Banach fixed-point theorem, contraction mapping theorem, `EMetricSpace` version.
A contracting map on a complete metric space has a fixed point.
We include more conclusions in this theorem to avoid proving them again later.

The main API for this theorem are the functions `efixedPoint` and `fixedPoint`,
and lemmas about these functions.  -/
theorem ContractingWith.exists_fixedPoint :
    ∀ {α : Type u_1} [inst : EMetricSpace α] [cs : CompleteSpace α] {K : NNReal} {f : α → α},
      ContractingWith K f →
        ∀ (x : α),
          edist x (f x) ≠ ⊤ →
            ∃ y,
              Function.IsFixedPt f y ∧
                Filter.Tendsto (fun n => f^[n] x) Filter.atTop (nhds y) ∧
                  ∀ (n : ℕ), edist (f^[n] x) y ≤ edist x (f x) * ↑K ^ n / (1 - ↑K) :=
  by sorry

This theorem, often referred to as Banach's Fixed-Point Theorem or the Contraction Mapping Theorem for `EMetricSpace`, states that for any complete metric space, if there is a contracting map (a map that brings points closer together - specifically, a map `f` such that there exists a nonnegative real `K` with `K` less than `1` for which `f` is Lipschitz continuous with constant `K`), then `f` must have a fixed point. In other words, there exists some point `y` such that when `f` is applied to `y`, the result is `y` itself. Additionally, if the distance from any point `x` to its image under `f` is finite, then the sequence of repeated applications of `f` to `x` will converge to `y`, and the distance from the `n`th term of this sequence to `y` can be bounded by the distance from `x` to `f(x)` times `K` to the power `n` divided by `1 - K`. This theorem is an essential result in analysis and provides the theoretical foundation for many numerical algorithms, such as the method of successive approximations.

In a complete metric space, any contracting map (Lipschitz continuous with Lipschitz constant less than 1) has a unique fixed point, and any sequence starting from an arbitrary point converges to it.


theorem descPochhammer_eval_eq_descFactorial :
    ∀ (R : Type u) [inst : Ring R] (n k : ℕ), Polynomial.eval (↑n) (descPochhammer R k) = ↑(Nat.descFactorial n k) := by
  sorry

The theorem `descPochhammer_eval_eq_descFactorial` states that for any type `R` with a ring structure and any natural numbers `n` and `k`, the evaluation of the `descPochhammer` polynomial of `k` with coefficients in `R` at `n` is equal to the descending factorial of `n` taken `k` at a time. In other words, if you construct the polynomial `X * (X - 1) * ... * (X - k + 1)` and substitute `n` for `X`, you get the same result as if you computed `n! / (n - k)!`. This connects the algebraic structure of a polynomial with the number theoretic concept of a factorial.

For any ring `R` and natural numbers `n` and `k`, the evaluation of the `descPochhammer` polynomial of `k` with coefficients in `R` at `n` equals the descending factorial of `n` taken `k` at a time.


theorem CategoryTheory.ShortComplex.abelianImageToKernel.proof_4 :
    ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Abelian C]
      (S : CategoryTheory.ShortComplex C),
      CategoryTheory.CategoryStruct.comp (CategoryTheory.Abelian.image.ι S.f) S.g = 0 :=
  by sorry

This theorem is a statement in the field of category theory, specifically within the context of abelian categories. It says that for any short complex `S`, the composition of the morphism `ι` from the image of `S.f` and the morphism `S.g` is the zero morphism. Here, `S.f` and `S.g` are morphisms in an abelian category `C`, and `CategoryTheory.Abelian.image.ι S.f` denotes the inclusion from the image of `S.f` into the codomain. The composition of these morphisms is done using the `CategoryTheory.CategoryStruct.comp` function. In more mathematical terms, if we denote `ι` as the inclusion map, it says that `ι(S.f) ∘ S.g = 0` in the category `C`.

In an abelian category, for any short complex `S`, the composition of the morphism `S.g` with the inclusion `ι` of the image of `S.f` is the zero morphism.


theorem Monotone.directed_ge :
    ∀ {α : Type u} {β : Type v} [inst : Preorder α] [inst_1 : IsDirected α fun x x_1 => x ≥ x_1] [inst_2 : Preorder β]
      {f : α → β}, Monotone f → Directed (fun x x_1 => x ≥ x_1) f :=
  by sorry

The theorem `Monotone.directed_ge` states that for all types `α` and `β`, if `α` has a preorder relation and is directed with respect to the greater than or equal to relation, and `β` has a preorder relation, then for any function `f` from `α` to `β`, if `f` is a monotone function, it is also directed with respect to the greater than or equal to relation. In other words, if a function preserves the order from a directed set under a preorder relation, then there exists an element in the image of the function that is above any pair of elements in the image.

If `α` is a preordered and directed type, `β` is a preordered type, and `f : α → β` is a monotone function, then `f` is a directed function.


theorem Filter.map_equiv_symm :
    ∀ {α : Type u} {β : Type v} (e : α ≃ β) (f : Filter β), Filter.map (⇑e.symm) f = Filter.comap (⇑e) f := by sorry

The theorem `Filter.map_equiv_symm` states that for any types `α` and `β`, and for any equivalence `e : α ≃ β` and any filter `f` on `β`, the image of `f` under the inverse of `e` (obtained by applying the function `Filter.map` to the inverse of `e`) is the same as the preimage of `f` under `e` (obtained by applying the function `Filter.comap` to `e`). Essentially, this theorem is stating that mapping a filter through an inverse equivalence is the same as pulling back the filter through the original equivalence.

For any equivalence `e : α ≃ β` and filter `f` on `β`, `Filter.map (inv e) f = Filter.comap e f`.


theorem Filter.not_isBoundedUnder_of_tendsto_atTop :
    ∀ {α : Type u_1} {β : Type u_2} [inst : Preorder β] [inst_1 : NoMaxOrder β] {f : α → β} {l : Filter α}
      [inst_2 : Filter.NeBot l], Filter.Tendsto f l Filter.atTop → ¬Filter.IsBoundedUnder (fun x x_1 => x ≤ x_1) l f :=
  by sorry

The theorem `Filter.not_isBoundedUnder_of_tendsto_atTop` states that for any types α and β, whereby β is a preorder and also has no maximum element, and given a function `f` from α to β and a filter `l` on α that is not "bottom", if the function `f` tends to infinity (represented by `Filter.atTop`) for the filter `l`, then the image of the filter `l` under `f` is not eventually bounded with respect to the relation "less than or equal to". In simpler words, if the image of `f` under the filter `l` tends to infinity, then there doesn't exist a uniform bound for the values of `f` as `l` tends towards infinity.

If `f` is a function from type `α` to preorder `β` without a maximum element, `l` is a non-bottom filter on `α`, and `f` tends to infinity under `l`, then `Image l f` is unbounded in `β`.


theorem nhdsWithin_Ici_basis' :
    ∀ {α : Type u} [inst : TopologicalSpace α] [inst_1 : LinearOrder α] [inst_2 : OrderTopology α] {a : α},
      (∃ u, a < u) → Filter.HasBasis (nhdsWithin a (Set.Ici a)) (fun u => a < u) fun u => Set.Ico a u :=
  by sorry

The theorem `nhdsWithin_Ici_basis'` states that for any type `α` endowed with a topological space structure, a linear order and an order topology, and for any element `a` of that type `α`, given that there exists an element `u` in `α` such that `a` is less than `u`, the filter of the neighborhood within the set comprising of all elements greater than or equal to `a` (denoted by `Set.Ici a`) at the point `a` has a basis indexed by the sets of elements `u` where `u` is greater than `a`, and the basis elements are the sets of all `x` in `α` such that `x` is greater than or equal to `a` and less than `u` (denoted by `Set.Ico a u`). In simpler terms, this theorem provides a characterization of the neighborhoods within right-closed infinite intervals in terms of left-closed right-open intervals.

For any type endowed with a topological space structure, a linear order, and an order topology, the filter of neighborhoods at an element `a` with `a < u` for some `u` in the type has a basis consisting of left-closed right-open intervals `Set.Ico a u`.


theorem CategoryTheory.Faithful.of_comp_iso :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂}
      [inst_1 : CategoryTheory.Category.{v₂, u₂} D] {E : Type u₃} [inst_2 : CategoryTheory.Category.{v₃, u₃} E]
      {F : CategoryTheory.Functor C D} {G : CategoryTheory.Functor D E} {H : CategoryTheory.Functor C E}
      [inst_3 : CategoryTheory.Faithful H], (CategoryTheory.Functor.comp F G ≅ H) → CategoryTheory.Faithful F :=
  by sorry

This theorem, `CategoryTheory.Faithful.of_comp_iso`, states that given categories `C`, `D` and `E`, with `C` and `D` being functors `F` and `G` respectively, and another functor `H` from `C` to `E`, if `H` is a faithful functor (i.e., a functor that is injective on hom-sets) and the composition of `F` and `G` is isomorphic to `H`, then `F` is also a faithful functor. This theorem explores the property of faithfulness in the context of functor composition and isomorphism in Category Theory.

If functors `F: C -> E` and `G: D -> E` are such that `F` is faithful, `G` is a functor, `H: C -> E` is isomorphic to the composition `F ∘ G`, and `H` is faithful, then `F` is faithful.


theorem Polynomial.rootMultiplicity_eq_zero :
    ∀ {R : Type u} [inst : CommRing R] {p : Polynomial R} {x : R},
      ¬Polynomial.IsRoot p x → Polynomial.rootMultiplicity x p = 0 :=
  by sorry

The theorem `Polynomial.rootMultiplicity_eq_zero` states that for any commutative ring `R`, any polynomial `p` of `R`, and any element `x` of `R`, if `x` is not a root of the polynomial `p` (meaning that when `x` is substituted into `p`, the result is not zero), then the root multiplicity of `x` in `p` is zero. In other words, the term `X - C x` does not divide `p`.

If an element `x` in a commutative ring `R` is not a root of polynomial `p` in `R`, then the multiplicity of `x` as a root of `p` is zero.


theorem BoxIntegral.Box.coe_mk' :
    ∀ {ι : Type u_1} (l u : ι → ℝ), ↑(BoxIntegral.Box.mk' l u) = Set.pi Set.univ fun i => Set.Ioc (l i) (u i) := by
  sorry

This theorem states that for any type `ι` and two functions `l` and `u` from `ι` to the real numbers ℝ, the box defined by `l` and `u` (which may be the empty set if `l i` is not less than `u i` for all `i`) corresponds to the set of all functions from `ι` to ℝ that for each index `i` map to a value in the left-open right-closed interval from `l i` to `u i`. This means that all values that such a function can take are within the defined box.

For any type `ι` and functions `l` and `u` from `ι` to the real numbers, the set of functions from `ι` to the real numbers mapping each index `i` to a value in the left-open right-closed interval `[l i, u i]` is equal to the set of functions whose image under `l` and `u` define a box containing their entire image.


/-- The `vectorSpan` of two points is the span of their difference.  -/
theorem vectorSpan_pair :
    ∀ (k : Type u_1) {V : Type u_2} {P : Type u_3} [inst : Ring k] [inst_1 : AddCommGroup V] [inst_2 : Module k V]
      [inst_3 : AddTorsor V P] (p₁ p₂ : P), vectorSpan k {p₁, p₂} = Submodule.span k {p₁ -ᵥ p₂} :=
  by sorry

The theorem `vectorSpan_pair` states that for any ring `k`, additive commutative group `V`, module `k V`, and additive torsor `V P`, and for any two points `p₁` and `p₂` from set `P`, the vector span of set `{p₁, p₂}` is equal to the submodule span of the set containing the difference of `p₁` and `p₂`. This means that the smallest submodule that contains the differences of the points `p₁` and `p₂` is the same as the submodule generated by the single difference `p₁ -ᵥ p₂`.

For any additive commutative group V, module over a ring k, and additive torsor P, the vector span of two points p₁ and p₂ in P equals the submodule span of {p₁ - p₂}.


theorem DFinsupp.lex_lt_of_lt_of_preorder :
    ∀ {ι : Type u_1} {α : ι → Type u_2} [inst : (i : ι) → Zero (α i)] [inst_1 : (i : ι) → Preorder (α i)]
      (r : ι → ι → Prop) [inst_2 : IsStrictOrder ι r] {x y : Π₀ (i : ι), α i},
      x < y → ∃ i, (∀ (j : ι), r j i → x j ≤ y j ∧ y j ≤ x j) ∧ x i < y i :=
  by sorry

This theorem states that for any types ι and α (which is dependent on ι), equipped with a zero structure and a preorder on α, and a strict order on ι, if we have two elements 'x' and 'y' of the direct-sum type of α, and 'x' is strictly less than 'y', then there exists an index 'i' such that for all indices 'j' that are strictly less than 'i' according to order 'r', the component of 'x' at 'j' is less than or equal to the component of 'y' at 'j' and the component of 'y' at 'j' is less than or equal to the component of 'x' at 'j', and the component of 'x' at 'i' is strictly less than the component of 'y' at 'i'. In other words, it provides a condition for the lexicographic order of elements in a direct-sum type.

Given types ι and α with zero structures and preorders, and a strict order on ι, if 'x' and 'y' are elements of the direct sum of α, and 'x' is strictly less than 'y' according to the lexicographic order induced by the strict order on ι and the component-wise preorder on α, then there exists an index 'i' such that the component of 'x' at 'i' is strictly less than the component of 'y' at 'i'.


theorem Mathlib.MeasureTheory.Function.ConditionalExpectation.CondexpL1._auxLemma.1 : (¬False) = True := by sorry

This theorem, `Mathlib.MeasureTheory.Function.ConditionalExpectation.CondexpL1._auxLemma.1`, simply states that the negation of "false" is "true". In logical terms, it's expressing that if something is not false, then it must be true. This is a fundamental concept in boolean logic.

The negation of a false statement is true.


theorem MeasureTheory.memℒp_top_of_bound :
    ∀ {α : Type u_1} {E : Type u_2} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} [inst : NormedAddCommGroup E]
      {f : α → E},
      MeasureTheory.AEStronglyMeasurable f μ → ∀ (C : ℝ), (∀ᵐ (x : α) ∂μ, ‖f x‖ ≤ C) → MeasureTheory.Memℒp f ⊤ μ :=
  by sorry

The theorem `MeasureTheory.memℒp_top_of_bound` states that for any types `α` and `E` with `E` being a normed additive commutative group, and given a measurable space `m0` on `α`, a measure `μ` on `α`, and a function `f` from `α` to `E`, if the function `f` is almost everywhere strongly measurable with respect to the measure `μ`, and there exists a real number `C` such that almost everywhere the norm of `f(x)` is less than or equal to `C`, then `f` belongs to the space `Memℒp` for `p = ∞` with respect to the measure `μ`. In other words, `f` is almost everywhere strongly measurable and its essential supremum is finite.

If a strongly measurable function from a measurable space to a normed additive commutative group is almost everywhere norm-bounded, then it belongs to the space of essentially bounded measurable functions.


theorem eq_top_of_isCompl_bot :
    ∀ {α : Type u_1} [inst : Lattice α] [inst_1 : BoundedOrder α] {x : α}, IsCompl x ⊥ → x = ⊤ := by sorry

This theorem states that for any type `α` equipped with a lattice structure and a bounded order, if an element `x` of this type is complementary to the bottom element (`⊥`), then `x` is the top element (`⊤`). Essentially, it asserts that in such a structure, the only complement of the bottom element is the top element.

In a bounded lattice, the complement of the bottom element is the top element.


theorem sub_right_inj : ∀ {G : Type u_3} [inst : AddGroup G] {a b c : G}, a - b = a - c ↔ b = c := by sorry

The theorem `sub_right_inj` states that for all elements `a`, `b`, and `c` of an additive group `G`, the difference `a - b` equals `a - c` if and only if `b` equals `c`. Essentially, it asserts that subtracting the same value from two equal quantities leaves us with equal results.

For all elements `a`, `b`, and `c` in an additive group `G`, `a - b = a - c` if and only if `b = c`.


theorem CategoryTheory.Limits.prodComparison_fst :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{w, u₂} D]
      (F : CategoryTheory.Functor C D) (A B : C) [inst_2 : CategoryTheory.Limits.HasBinaryProduct A B]
      [inst_3 : CategoryTheory.Limits.HasBinaryProduct (F.obj A) (F.obj B)],
      CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.prodComparison F A B) CategoryTheory.Limits.prod.fst =
        F.map CategoryTheory.Limits.prod.fst :=
  by sorry

This theorem, `CategoryTheory.Limits.prodComparison_fst`, states that for any two types `C` and `D`, that are categories, and a functor `F` from `C` to `D`, if `A` and `B` are objects in the category `C` and both binary products `A x B` in `C` and `F.obj A x F.obj B` in `D` exist, then the composition of the product comparison map `prodComparison F A B` and the projection to the first factor `prod.fst` in `D` is equal to the image under `F` of the projection to the first factor `prod.fst` in `C`. In simpler terms, this theorem asserts a key property about the functoriality of the product in the context of category theory: the mapping of the projection of the product under a functor coincides with the projection of the mapped product.

Given any categories C and D, functor F from C to D, objects A and B in C with existing binary products, the diagram commutes: prodComparison F A B ∘ prod.fst (D) = F ∘ prod.fst (C).


/-- Even if `s` is not measurable, we can bound `map f μ s` from below.
See also `MeasurableEquiv.map_apply`.  -/
theorem MeasureTheory.Measure.le_map_apply :
    ∀ {α : Type u_1} {β : Type u_2} {m0 : MeasurableSpace α} [inst : MeasurableSpace β] {μ : MeasureTheory.Measure α}
      {f : α → β}, AEMeasurable f μ → ∀ (s : Set β), ↑↑μ (f ⁻¹' s) ≤ ↑↑(MeasureTheory.Measure.map f μ) s :=
  by sorry

The theorem `MeasureTheory.Measure.le_map_apply` states that for any measurable space `α` and `β`, measure `μ` on `α`, and a function `f` from `α` to `β` that is almost everywhere measurable, for every set `s` of `β`, the measure of the preimage of `s` under `f` is less than or equal to the measure of `s` under the pushforward of `μ` by `f`. This holds true even if the set `s` is not measurable. In other words, the measure of the set of points in `α` that get mapped into `s` by `f` is always less than or equal to the measure of `s` itself under the pushforward measure.

For any measurable space (α, Σ\_α), measure μ on Σ\_α, almost everywhere measurable function f : α → β, and any set s ∈ Σ\_β, the measure μ(f⁻¹(s)) ≤ μ\_f(s), where μ\_f is the pushforward measure of μ by f.


theorem PartialHomeomorph.IsImage.iff_symm_preimage_eq' :
    ∀ {X : Type u_1} {Y : Type u_3} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y]
      {e : PartialHomeomorph X Y} {s : Set X} {t : Set Y},
      PartialHomeomorph.IsImage e s t ↔ e.target ∩ ↑(PartialHomeomorph.symm e) ⁻¹' (e.source ∩ s) = e.target ∩ t :=
  by sorry

This theorem states that for any partial homeomorphism `e` between two topological spaces `X` and `Y`, and for any two sets `s` in `X` and `t` in `Y`, the set `t` is an image of the set `s` under the partial homeomorphism `e` if and only if the intersection of the target of `e` with the preimage under the inverse of `e` of the intersection of the source of `e` and `s` is equal to the intersection of the target of `e` and `t`. This theorem provides a convenient condition in terms of set operations and inverse images for verifying when a set is an image of another set under a partial homeomorphism.

For a partial homeomorphism between topological spaces, a set is the image of another set if and only if their intersections with the respective preimages under the inverse map have equal intersections.


/-- In a monoid, an element a divides an element b iff all associates of `a` divide `b`. -/
theorem IsUnit.mul_right_dvd : ∀ {α : Type u_1} [inst : Monoid α] {a b u : α}, IsUnit u → (a * u ∣ b ↔ a ∣ b) := by
  sorry

This theorem states that in a monoid, given elements `a`, `b`, and `u`, where `u` is a unit (meaning that it has a two-sided inverse), the product of `a` and `u` divides `b` if and only if `a` divides `b`. In other words, when a monoid element `a` is multiplied by any unit `u`, its divisibility property with respect to another element `b` remains unchanged.

In a monoid with unit `u`, `a` divides `b` if and only if `a * u` divides `b`.


theorem IsLUB.exists_seq_strictMono_tendsto_of_not_mem :
    ∀ {α : Type u} [inst : TopologicalSpace α] [inst_1 : LinearOrder α] [inst_2 : OrderTopology α] {t : Set α} {x : α}
      [inst_3 : Filter.IsCountablyGenerated (nhds x)],
      IsLUB t x →
        x ∉ t →
          Set.Nonempty t →
            ∃ u, StrictMono u ∧ (∀ (n : ℕ), u n < x) ∧ Filter.Tendsto u Filter.atTop (nhds x) ∧ ∀ (n : ℕ), u n ∈ t :=
  by sorry

This theorem states that for any topological linear ordered space `α` with order topology and a neighborhood filter `nhds x` that is countably generated, given a set `t` in `α` and an element `x` in `α` such that `x` is a least upper bound of `t` but does not belong to `t`, and provided that `t` is not empty, there exists a sequence `u` with the following properties:

1. `u` is strictly increasing.
2. Every term `u n` of sequence `u` is less than `x`.
3. `u` tends to `x` as `n` tends to infinity.
4. Every term `u n` of sequence `u` belongs to `t`.

In simpler terms, if you have a non-empty set that's bounded from above by some value that's not in the set, in a certain kind of topological space, you can always find a sequence of values in the set that increases to this upper bound.

In a countably generated topological linear ordered space, given a non-empty, bounded above, and non-containing set, there exists a strictly increasing sequence of elements from the set that converges to the upper bound.


theorem Set.Icc_eq_empty_iff : ∀ {α : Type u_1} [inst : Preorder α] {a b : α}, Set.Icc a b = ∅ ↔ ¬a ≤ b := by sorry

The theorem `Set.Icc_eq_empty_iff` states that for any type `α` that has a preorder, and any two elements `a` and `b` of this type, the interval from `a` to `b` (i.e., the set of all `x` such that `a ≤ x ≤ b`) is empty if and only if `a` is not less than or equal to `b`. In mathematical terms, this says that an interval `[a, b]` is empty if and only if `a > b`.

For any type with a preorder, the interval between two elements is empty if and only if one element is strictly greater than the other.


theorem NormedSpace.expSeries_hasSum_exp_of_mem_ball :
    ∀ {𝕂 : Type u_1} {𝔸 : Type u_2} [inst : NontriviallyNormedField 𝕂] [inst_1 : NormedRing 𝔸]
      [inst_2 : NormedAlgebra 𝕂 𝔸] [inst_3 : CompleteSpace 𝔸],
      ∀ x ∈ EMetric.ball 0 (FormalMultilinearSeries.radius (NormedSpace.expSeries 𝕂 𝔸)),
        HasSum (fun n => (NormedSpace.expSeries 𝕂 𝔸 n) fun x_1 => x) (NormedSpace.exp 𝕂 x) :=
  by sorry

This theorem states that for any non-trivially normed field `𝕂` and a normed ring `𝔸` which is also a normed algebra over `𝕂` and a complete space, for any element `x` that belongs to the `EMetric` ball centered at `0` with radius equal to the radius of the exponential series for `𝕂` and `𝔸`, the series consisting of the `n`-th term of the exponential series applied to `x` converges to the exponential of `𝕂` and `x`. In mathematical terms, if we consider the series ∑ (1/n!) ∏ xᵢ, where xᵢ are the components of `x`, the sum of this series is exp(𝕂, x), where exp is the exponential function.

For any non-trivially normed field `𝕂`, normed ring `𝔸` over `𝕂`, and `x` in the `EMetric` ball of `𝔸` with radius equal to the exponential series' radius, the exponential series ∑ (1/n!) ∏ (𝕂.exp xᵢ) converges to `𝕂.exp x`, where `exp` is the exponential function.


theorem Nat.pow_pos : ∀ {a n : ℕ}, 0 < a → 0 < a ^ n := by sorry

This theorem states that for any natural numbers `a` and `n`, if `a` is greater than 0, then `a` raised to the power of `n` (denoted as `a ^ n`) is also greater than 0. In mathematical terms, it asserts that for any positive natural number `a`, the nth power of `a` is always positive for any natural number `n`.

For any positive natural number `a` and natural number `n`, `a^n` is also a positive natural number.


theorem AddMonoid.exponent_pos_of_exists :
    ∀ {G : Type u} [inst : AddMonoid G] (n : ℕ), 0 < n → (∀ (g : G), n • g = 0) → 0 < AddMonoid.exponent G := by sorry

This theorem states that for any type `G`, which is an instance of an additive monoid, and any positive natural number `n`, if `n` is such that the `n`-fold sum of any element `g` of `G` equals the additive identity (0), then the exponent of the additive monoid `G` is positive. The exponent of an additive monoid is the smallest positive natural number that makes the `n`-fold sum of each element equal to 0, or else it is defined to be 0 by convention if no such number exists.

If a type `G` is an additive monoid and every element `g` in `G` satisfies the property that the sum of `g` with itself `n` times equals the additive identity `0`, then the exponent of `G` is positive.


theorem ENNReal.coe_div : ∀ {r p : NNReal}, r ≠ 0 → ↑(p / r) = ↑p / ↑r := by sorry

This theorem states that for any two non-negative real numbers `r` and `p`, as long as `r` is not zero, the operation of first dividing `p` by `r` and then taking the real number associated to the result is the same as first taking the real numbers associated to `p` and `r`, then performing the division. In other words, the process of division in the set of non-negative real numbers is compatible with the embedding of this set into the real numbers.

For any non-zero real number `r` and non-negative real numbers `p`, the operation `(p : ℝ) / r` equal to `(real_of_num p) / real_of_num r` in the real numbers.


theorem AddSubgroup.characteristic_iff_comap_le :
    ∀ {G : Type u_1} [inst : AddGroup G] {H : AddSubgroup G},
      AddSubgroup.Characteristic H ↔ ∀ (ϕ : G ≃+ G), AddSubgroup.comap (AddEquiv.toAddMonoidHom ϕ) H ≤ H :=
  by sorry

This theorem states that for any additive group `G` and any subgroup `H` of `G`, the subgroup `H` is said to be characteristic if and only if, for all additive equivalences `ϕ` from `G` to itself, the preimage of the subgroup `H` under the additive monoid homomorphism obtained from `ϕ` is a subset (or equal to) the subgroup `H`. In mathematical terms, a subgroup `H` of `G` is characteristic if and only if ∀ϕ : G ≃+ G, ϕ^(-1)(H) ⊆ H.

A subgroup H of an additive group G is characteristic if and only if the preimage of H under any additive group homomorphism from G to itself contains H.


theorem AddGroupFilterBasis.nhds_zero_eq :
    ∀ {G : Type u} [inst : AddGroup G] (B : AddGroupFilterBasis G),
      nhds 0 = FilterBasis.filter AddGroupFilterBasis.toFilterBasis :=
  by sorry

This theorem states that for any additive group `G` and any additive group filter basis `B` of `G`, the neighborhood filter of the element `0` in `G` is equal to the filter associated to the filter basis which converts the additive group filter basis `B` to a filter basis. In other words, in the context of additive groups, the neighborhood filter at the 'zero' element can be constructed by taking the filter associated with the filter basis obtained from an additive group filter basis.

For any additive group G and its filter basis B, the neighborhood filter of 0 in G equals the filter associated to the filter basis obtained from B.


FreeAbelianGroup.lift.ext

/-- See note [partially-applied ext lemmas].  -/
theorem FreeAbelianGroup.lift.ext :
    ∀ {α : Type u} {β : Type v} [inst : AddCommGroup β] (g h : FreeAbelianGroup α →+ β),
      (∀ (x : α), g (FreeAbelianGroup.of x) = h (FreeAbelianGroup.of x)) → g = h :=
  by sorry

This theorem, `FreeAbelianGroup.lift.ext`, states that for any two homomorphisms `g` and `h` from the free abelian group on a type `α` to an additive commutative group `β`, if `g` and `h` agree on the image under the canonical map `FreeAbelianGroup.of` of every element of `α`, then `g` and `h` are equal. In other words, it's saying that to define a group homomorphism out of the free abelian group, it's enough to specify where the generators (the images under `FreeAbelianGroup.of` of elements of `α`) should go, and this definition is uniquely determining the homomorphism.

Given two homomorphisms from a free abelian group to an additive commutative group that agree on the images of generators, they are equal.


theorem Finset.Ioo_insert_left :
    ∀ {α : Type u_2} [inst : PartialOrder α] [inst_1 : LocallyFiniteOrder α] {a b : α} [inst_2 : DecidableEq α],
      a < b → insert a (Finset.Ioo a b) = Finset.Ico a b :=
  by sorry

This theorem states that for any two elements `a` and `b` of a type `α` that has a partial order and locally finite order, where `a` is less than `b`, and `α` has decidable equality, inserting `a` into the open interval `{x | a < x < b}` results in the half-open interval `{x | a ≤ x < b}`. In mathematical terms, for `a, b ∈ α` with `a < b`, it asserts that adding `a` to the set of elements strictly between `a` and `b` (exclusive of `a` and `b`) produces the set of elements including `a` and strictly less than `b`.

For any type `α` with a partial order and locally finite order, if `a < b` are elements of `α` with decidable equality, then `{x | a < x < b} = {x | a ≤ x < b}`.


theorem QuotientGroup.lift_mk' :
    ∀ {G : Type u} [inst : Group G] (N : Subgroup G) [nN : Subgroup.Normal N] {M : Type x} [inst_1 : Monoid M]
      {φ : G →* M} (HN : N ≤ MonoidHom.ker φ) (g : G), (QuotientGroup.lift N φ HN) ↑g = φ g :=
  by sorry

The theorem `QuotientGroup.lift_mk'` states that for any group `G`, normal subgroup `N` of `G`, monoid `M`, and a group homomorphism `φ` from `G` to `M` such that `N` is a subset of the kernel of `φ`, and for any element `g` of `G`, the homomorphism from the quotient group `G/N` to `M` induced by `φ` (denoted as `QuotientGroup.lift N φ HN`) applied to the coset of `g` in `G/N` (denoted as `↑g`) is equal to the image of `g` under `φ`. In mathematical terms, if `φ: G → M` is a group homomorphism and `N` is a normal subgroup of `G` included in the kernel of `φ`, then there exists a unique group homomorphism `ψ: G/N → M` such that `ψ(gN) = φ(g)` for all `g` in `G`, this `ψ` is the lift of `φ`.

For any group homomorphism φ from a group G to a monoid M with normal subgroup N in the kernel, the homomorphism induced by φ from the quotient group G/N to M maps the coset ↑g to φ(g) for all g in G.


theorem Asymptotics.isLittleO_const_iff :
    ∀ {α : Type u_1} {E'' : Type u_9} {F'' : Type u_10} [inst : NormedAddCommGroup E'']
      [inst_1 : NormedAddCommGroup F''] {f'' : α → E''} {l : Filter α} {c : F''},
      c ≠ 0 → ((f'' =o[l] fun _x => c) ↔ Filter.Tendsto f'' l (nhds 0)) :=
  by sorry

The theorem `Asymptotics.isLittleO_const_iff` states that for any type `α`, any normed additive commutative group `E''`, another normed additive commutative group `F''`, a function `f''` from `α` to `E''`, a filter `l` on `α`, and a non-zero constant `c` of type `F''`, the function `f''` is little o of the constant function `c` (under the filter `l`) if and only if the function `f''` tends to the neighborhood of 0 under the filter `l`. In mathematical terms, we could write this as: for a non-zero constant `c`, `f'' = o(c)` as `x` approaches `l` if and only if `f''` tends to 0 as `x` approaches `l`. Here, `f'' = o(c)` means that `f''(x)` is significantly smaller than `c` when `x` is close to the limit `l`.

For any normed additive commutative groups E and F, type α, function f from α to E, filter l on α, and non-zero constant c of type F, the function f is little o of the constant function c under filter l if and only if f tends to 0 under filter l.