theorem Function.Commute.iterate_right :
    ∀ {α : Type u} {f g : α → α}, Function.Commute f g → ∀ (n : ℕ), Function.Commute f g^[n] := by sorry

This theorem states that for any type `α` and any two functions `f` and `g` from `α` to `α` that commute, the function `f` also commutes with the `n`-th iteration of `g` for any natural number `n`. Here, "commutes" means that composing `f` with `g` (i.e., `f(g(x))`) is the same as composing `g` with `f` (i.e., `g(f(x))`) for all `x` in `α`. The `n`-th iteration of `g` is the function obtained by applying `g` `n` times.

For any type `α`, if functions `f` and `g` from `α` to `α` commute, then `f` commutes with the `n`-th power of `g` for all natural numbers `n`. (That is, `f(g^n(x)) = g^n(f(x))` for all `x` in `α`.)


theorem Ordinal.CNF_zero : ∀ (b : Ordinal.{u_1}), Ordinal.CNF b 0 = [] := by sorry

The theorem `Ordinal.CNF_zero` asserts that for all ordinals `b`, the Cantor Normal Form (CNF) of the ordinal `0` with respect to the base `b` is an empty list. In other words, when the ordinal that we are trying to express in Cantor Normal Form is `0`, regardless of what the base ordinal is, the CNF representation will always be an empty list.

For all base ordinals `b`, the Cantor Normal Form of the ordinal `0` is the empty list.


/-- An involution commutes across an equality. Compare to `Function.Injective.eq_iff`.  -/
theorem Function.Involutive.eq_iff :
    ∀ {α : Sort u} {f : α → α}, Function.Involutive f → ∀ {x y : α}, f x = y ↔ x = f y := by sorry

This theorem states that for any type `α` and function `f` from `α` to `α`, if `f` is involutive (i.e., applying `f` twice returns the original value: `f(f(x)) = x`), then for any two elements `x` and `y` of `α`, `f(x) = y` if and only if `x = f(y)`. This means that if function `f` is an involution, it commutes across an equality, which is similar to the property of injective functions where if the outputs are the same, then the inputs are the same.

An involutive function `f` over type `α` satisfies `x = y` if and only if `f(x) = f(y)`.


theorem Prime.dvd_of_dvd_pow :
    ∀ {α : Type u_1} [inst : CommMonoidWithZero α] {p : α}, Prime p → ∀ {a : α} {n : ℕ}, p ∣ a ^ n → p ∣ a := by sorry

The theorem `Prime.dvd_of_dvd_pow` states that for any type `α` that forms a commutative monoid with zero, any prime element `p` of this type and any element `a` of this type, if `p` divides `a` raised to the power of a natural number `n`, then `p` also divides `a`. In other words, if a prime number is a divisor of a power of another number, it must also be a divisor of that number itself.

If a prime number `p` divides the power `a^n` of an element `a` in a commutative monoid with zero, then `p` divides `a`.


theorem Mathlib.Combinatorics.SetFamily.Compression.Down._auxLemma.4 :
    ∀ {α : Type u_1} [inst : DecidableEq α] {𝒜 : Finset (Finset α)} {s : Finset α} {a : α},
      (s ∈ Finset.memberSubfamily a 𝒜) = (insert a s ∈ 𝒜 ∧ a ∉ s) :=
  by sorry

This theorem states that for any type `α` with decidable equality, a given set `𝒜` of finite sets of `α`, a finite set `s` of `α`, and an element `a` of `α`, the set `s` belongs to the subfamily of `𝒜` obtained by removing `a` from its members (as defined by `Finset.memberSubfamily`) if and only if the set `s` with `a` inserted into it belongs to `𝒜` and `a` is not an element of `s`. This highlights a relation between the original family of sets `𝒜` and the derived family where `a` has been removed from each set.

For any decidably equal type `α` and finite set `𝒜` of subsets of `α`, an element `a` in `α` belongs to the subfamily of `𝒜` obtained by removing `a` from its members if and only if the set `a ∪ s` belongs to `𝒜` for some finite `s` in `𝒜` without `a`.


FractionalIdeal.isFractional

theorem FractionalIdeal.isFractional :
    ∀ {R : Type u_1} [inst : CommRing R] {S : Submonoid R} {P : Type u_2} [inst_1 : CommRing P] [inst_2 : Algebra R P]
      (I : FractionalIdeal S P), IsFractional S ↑I :=
  by sorry

This theorem states that for any commutative ring `R`, any submonoid `S` of `R`, any type `P` with a commutative ring structure such that `P` is an `R`-algebra, and any fractional ideal `I` of `P` with respect to `S`, `I` satisfies the property of being a fractional ideal. In other words, there exists a non-zero element `a` in `S` such that the product of `a` and any element of `I` is an integer in the localization of `R` at `S`.

Given a commutative ring `R`, a submonoid `S` of `R`, an `R`-algebra `P`, and a fractional ideal `I` of `P` with respect to `S`, there exists an element `a` in `S` such that `aI` is an ideal in the localization `R_S`.


theorem mem_closure_iff_clusterPt :
    ∀ {X : Type u} {x : X} {s : Set X} [inst : TopologicalSpace X], x ∈ closure s ↔ ClusterPt x (Filter.principal s) :=
  by sorry

This theorem states that for any type `X`, for any point `x` in `X`, and for any set `s` of `X`, given that `X` has a topology, `x` is in the closure of `s` if and only if `x` is a cluster point of the principal filter of `s`. In other words, a point is in the smallest closed set containing a particular set precisely when it is a cluster point, i.e., the point where every open set containing it intersects with the given set, of the collection of all supersets of the given set.

A point in a topological space is in the closure of a set if and only if it is a cluster point of the principal filter generated by the set.


theorem Filter.image2_mem_map₂ :
    ∀ {α : Type u_1} {β : Type u_3} {γ : Type u_5} {m : α → β → γ} {f : Filter α} {g : Filter β} {s : Set α}
      {t : Set β}, s ∈ f → t ∈ g → Set.image2 m s t ∈ Filter.map₂ m f g :=
  by sorry

This theorem states that for any types `α`, `β`, and `γ`, any binary function `m` mapping from `α` and `β` to `γ`, any filters `f` on `α` and `g` on `β`, and any sets `s` of `α` and `t` of `β`, if `s` is in the filter `f` and `t` is in the filter `g`, then the image of the function `m` over sets `s` and `t`, denoted `Set.image2 m s t`, is in the filter `Filter.map₂ m f g`, where `Filter.map₂` is the mapping of the binary function `m` from filters `f` and `g` to a filter on `γ`. This essentially asserts that if `s` and `t` are sets filtered by `f` and `g` respectively, then the set of all values generated by applying `m` to every pair of elements from `s` and `t` is also filtered under the mapping of `m` over `f` and `g`.

Given types `α`, `β`, `γ`, a binary function `m` from `α` and `β` to `γ`, filters `f` on `α` and `g` on `β`, and sets `s` of `α` and `t` of `β` such that `s ∈ f` and `t ∈ g`, then `Set.image2 m s t ∈ Filter.map₂ m f g`.


theorem WithZero.cases_on : ∀ {α : Type u} {P : WithZero α → Prop} (x : WithZero α), P 0 → (∀ (a : α), P ↑a) → P x := by
  sorry

This theorem states that given any type `α`, and a property `P` that applies to elements of the type `WithZero α`, for any element `x` of `WithZero α`, if we can prove that the property `P` holds for `0` and for all the elements in `α` (note that elements in `α` are also in `WithZero α`), then we can conclude that the property `P` holds for `x`.

In other words, this theorem provides a method to prove that a property holds for all elements in `WithZero α`: we just need to prove it for `0` and for all elements in `α`.

If `P` is a property that holds for `0` and all elements in `α` where `α` has a zero element, then `P` holds for every element `x` in `WithZero α` (the type of `α` with an added zero element).


theorem Nat.dvd_prime_pow : ∀ {p : ℕ}, Nat.Prime p → ∀ {m i : ℕ}, i ∣ p ^ m ↔ ∃ k ≤ m, i = p ^ k := by sorry

This theorem states that for any natural number `p` which is prime, and for any natural numbers `m` and `i`, `i` divides `p` raised to the power of `m` if and only if there exists a natural number `k` that is less than or equal to `m` such that `i` is equal to `p` raised to the power of `k`. In mathematical terms, for a prime number $p$ and natural numbers $m$ and $i$, $i$ divides $p^m$ exactly when $i$ is equal to $p^k$ for some $k$ satisfying $k \leq m$.

For a prime number p and natural numbers m and i, i divides p^m if and only if i is p raised to some power k with k <= m.


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

This theorem, `CategoryTheory.IsIso.eq_inv_of_hom_inv_id`, asserts that for any given category `C` which contains objects `X` and `Y`, if there exists an isomorphism `f : X ⟶ Y` and a morphism `g : Y ⟶ X` such that the composition of `f` and `g` is the identity on `X`, then `g` must be the inverse of `f`. In other words, if for an isomorphism `f` we have `f ≫ g = id_X`, then `g` is the inverse of `f`, or `g = f⁻¹` in notations.

If in a category `C` there exists an isomorphism `f : X ⟶ Y` with `id_X = f ∘ g` for some morphism `g : Y ⟶ X`, then `g` is the inverse of `f`.


theorem MeasureTheory.VectorMeasure.m_iUnion :
    ∀ {α : Type u_1} {m : MeasurableSpace α} {M : Type u_3} [inst : AddCommMonoid M] [inst_1 : TopologicalSpace M]
      (v : MeasureTheory.VectorMeasure α M) {f : ℕ → Set α},
      (∀ (i : ℕ), MeasurableSet (f i)) → Pairwise (Disjoint on f) → HasSum (fun i => ↑v (f i)) (↑v (⋃ i, f i)) :=
  by sorry

This theorem, `MeasureTheory.VectorMeasure.m_iUnion`, states that for all measurable spaces `α` and all types `M` where `M` has an additive commutative monoid structure and a topological structure, and given a vector measure `v` over `α` and `M`, and a sequence of sets `f` indexed by natural numbers, if each of the sets `f i` is measurable and the sets are pairwise disjoint, then the sum of the vector measure `v` over each individual set `f i` is equal to the vector measure `v` over the union of all the sets `f i`. In other words, the total measure of a countable collection of disjoint measurable sets is the sum of the measures of each set. This corresponds to the property of σ-additivity in measure theory.

For any measurable space, if a vector measure is defined on a countable collection of pairwise disjoint, measurable sets, then the vector measure of their union equals the sum of the measures of each individual set.


theorem tendsto_nhds_of_tendsto_nhdsWithin :
    ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] {f : β → α} {a : α} {s : Set α} {l : Filter β},
      Filter.Tendsto f l (nhdsWithin a s) → Filter.Tendsto f l (nhds a) :=
  by sorry

This theorem, `tendsto_nhds_of_tendsto_nhdsWithin`, states that for any types `α` and `β`, where `α` is equipped with a topological space structure, and any function `f` from `β` to `α`, any point `a` in `α`, any set `s` in `α`, and any filter `l` on `β`, if `f` tends towards the neighborhood filter of `a` within the set `s` under the filter `l`, then `f` also tends towards the neighborhood filter of `a` under the filter `l`. In other words, if the values of `f` get arbitrarily close to `a` when the input values (from `β`) are taken from `l` and the outputs are within `s`, then `f` will get arbitrarily close to `a` when the input values are just taken from `l`, regardless of whether the outputs are within `s`.

If a function `f` from `β` to `α` (where `α` is a topological space) tends towards the neighborhood filter of `a` in `α` within the set `s` under filter `l` on `β`, then `f` tends towards the neighborhood filter of `a` under filter `l`.


theorem QuotientMap.continuous_iff :
    ∀ {X : Type u_1} {Y : Type u_2} {Z : Type u_3} {f : X → Y} {g : Y → Z} [inst : TopologicalSpace X]
      [inst_1 : TopologicalSpace Y] [inst_2 : TopologicalSpace Z],
      QuotientMap f → (Continuous g ↔ Continuous (g ∘ f)) :=
  by sorry

The theorem `QuotientMap.continuous_iff` states that for any three types `X`, `Y` and `Z`, which have topological space structures, and any two functions `f` from `X` to `Y` and `g` from `Y` to `Z`, if `f` is a quotient map, then the function `g` is continuous if and only if the composition of `g` and `f` (i.e., `g ∘ f`) is continuous. In mathematical terms, under the condition that the function `f: X → Y` is a quotient map, the continuity of the function `g: Y → Z` is equivalent to the continuity of the composed function `(g ∘ f): X → Z`.

A quotient map's composability with a continuous function results in a continuous image function. In other words, if `f: X → Y` is a quotient map and `g: Y → Z` is continuous, then `g ∘ f: X → Z` is continuous.


theorem Set.IsWF.min_le :
    ∀ {α : Type u_2} [inst : LinearOrder α] {s : Set α} {a : α} (hs : Set.IsWF s) (hn : Set.Nonempty s),
      a ∈ s → Set.IsWF.min hs hn ≤ a :=
  by sorry

The theorem `Set.IsWF.min_le` asserts that for any type `α` with a linear order, given any well-founded set `s` of the type `α` which is nonempty, for any element `a` in the set `s`, the minimal element of the set `s`, as determined by the `Set.IsWF.min` function, is less than or equal to `a`. In other words, it confirms that the `Set.IsWF.min` function indeed returns a minimum element of the well-founded set.

For any nonempty well-founded set `s` of a type `α` with a linear order, the minimal element of `s` is less than or equal to every element `a` in `s`.


theorem MeasureTheory.integral_smul_measure :
    ∀ {α : Type u_1} {G : Type u_5} [inst : NormedAddCommGroup G] [inst_1 : NormedSpace ℝ G] {m : MeasurableSpace α}
      {μ : MeasureTheory.Measure α} (f : α → G) (c : ENNReal), ∫ (x : α), f x ∂c • μ = c.toReal • ∫ (x : α), f x ∂μ :=
  by sorry

This theorem, `MeasureTheory.integral_smul_measure`, states that for any type `α`, a normed additively commutative group `G`, a normed space over the reals, a measurable space `m` defined on `α`, a measure `μ` defined on `α`, a function `f : α → G`, and an extended nonnegative real number `c`, the integral of `f` with respect to the measure `c` times `μ` is equal to `c` (converted to a real number) times the integral of `f` with respect to `μ`. This is a key result that ensures the stability of integration under multiplication by an extended nonnegative real number.

For any measurable function `f : α → G`, measure `μ` on `α`, extended nonnegative real number `c`, the integral `∫(c * f dμ)` equals `c * ∫(f dμ)` in the real numbers.


theorem CategoryTheory.Limits.prod.map_map :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {A₁ A₂ A₃ B₁ B₂ B₃ : C}
      [inst_1 : CategoryTheory.Limits.HasBinaryProduct A₁ B₁] [inst_2 : CategoryTheory.Limits.HasBinaryProduct A₂ B₂]
      [inst_3 : CategoryTheory.Limits.HasBinaryProduct A₃ B₃] (f : A₁ ⟶ A₂) (g : B₁ ⟶ B₂) (h : A₂ ⟶ A₃) (k : B₂ ⟶ B₃),
      CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.prod.map f g) (CategoryTheory.Limits.prod.map h k) =
        CategoryTheory.Limits.prod.map (CategoryTheory.CategoryStruct.comp f h)
          (CategoryTheory.CategoryStruct.comp g k) :=
  by sorry

The theorem `CategoryTheory.Limits.prod.map_map` states that for any category `C` and six objects `A₁, A₂, A₃, B₁, B₂, B₃` in this category, given that we have binary products `A₁ x B₁`, `A₂ x B₂`, and `A₃ x B₃` and morphisms `f : A₁ ⟶ A₂`, `g : B₁ ⟶ B₂`, `h : A₂ ⟶ A₃`, and `k : B₂ ⟶ B₃`, the composition of `prod.map f g` and `prod.map h k` is the same as `prod.map` of the compositions `f ≫ h` and `g ≫ k`. In other words, the process of mapping across a product commutes with the process of composition of morphisms.

 For any category C and morphisms f : A₁ ⟶ A₂, g : B₁ ⟶ B₂, h : A₂ ⟶ A₃, and k : B₂ ⟶ B₃, the diagram commutes:

prod.map f g ∘ prod.map h k = prod.map (f ∫ h) (g ∫ k)

Here, ∘ denotes composition of morphisms and ∫ denotes the product construction.


IsClopen.isOpen

theorem IsClopen.isOpen : ∀ {X : Type u} [inst : TopologicalSpace X] {s : Set X}, IsClopen s → IsOpen s := by sorry

This theorem states that for any type `X` and a topological space `inst` over `X`, if a set `s` of type `X` is both closed and open (i.e., it is clopen), then it is open in the context of the ambient topological space. In mathematical terms, if a set is clopen in a given topological space, it implies that the set is open in that space.

If a set is clopen in a topological space, then it is open in that space.


theorem MeasureTheory.lintegral_add_measure :
    ∀ {α : Type u_1} {m : MeasurableSpace α} (f : α → ENNReal) (μ ν : MeasureTheory.Measure α),
      ∫⁻ (a : α), f a ∂(μ + ν) = ∫⁻ (a : α), f a ∂μ + ∫⁻ (a : α), f a ∂ν :=
  by sorry

This theorem, `MeasureTheory.lintegral_add_measure`, states that for any type `α`, a measurable space `m` of type `α`, a function `f` from `α` to the extended nonnegative real numbers (`ENNReal`), and two measures `μ` and `ν` on `α`, the Lebesgue integral of `f` with respect to the measure (`μ + ν`) is equal to the sum of the Lebesgue integral of `f` with respect to `μ` and the Lebesgue integral of `f` with respect to `ν`. In mathematical terms, it says that the integral of `f` over `(μ + ν)` is the same as the integral of `f` over `μ` plus the integral of `f` over `ν`, symbolically expressed as $\int f d(μ + ν) = \int f dμ + \int f dν$.

The Lebesgue integral of a measurable function with respect to the sum of two measures is equal to the sum of the integrals with respect to each measure.


theorem sub_right_comm : ∀ {α : Type u_1} [inst : SubtractionCommMonoid α] (a b c : α), a - b - c = a - c - b := by
  sorry

This theorem, `sub_right_comm`, states for any type `α` that is a commutative monoid under subtraction (that is, subtraction operation is associative and has an identity element, and it's commutative), the order of subtraction for any three elements `a`, `b`, and `c` of the type `α` does not matter when subtracting from the same element `a`. In mathematical terms, this theorem says that for any elements `a`, `b`, and `c` in a subtraction commutative monoid, `a - b - c` is equal to `a - c - b`.

For any commutative monoid `α` under subtraction, the order of subtraction of elements `a, b, c` from `a` is commutative, that is, `a - b - c = a - c - b`.


Filter.HasBasis.prod

theorem Filter.HasBasis.prod :
    ∀ {α : Type u_1} {β : Type u_2} {la : Filter α} {lb : Filter β} {ι : Type u_6} {ι' : Type u_7} {pa : ι → Prop}
      {sa : ι → Set α} {pb : ι' → Prop} {sb : ι' → Set β},
      Filter.HasBasis la pa sa →
        Filter.HasBasis lb pb sb → Filter.HasBasis (la ×ˢ lb) (fun i => pa i.1 ∧ pb i.2) fun i => sa i.1 ×ˢ sb i.2 :=
  by sorry

This theorem states that for any two types `α` and `β`, two filters `la` and `lb` on these types, two types `ι` and `ι'`, two properties `pa` and `pb` dependent on `ι` and `ι'` respectively, and two set-valued functions `sa` and `sb` dependent on `ι` and `ι'` respectively, if `la` has a basis represented by the property-set pair `(pa, sa)` and `lb` has a basis represented by the property-set pair `(pb, sb)`, then the product filter `(la ×ˢ lb)` has a basis represented by the property-set pair `((fun i => pa i.1 ∧ pb i.2), (fun i => sa i.1 ×ˢ sb i.2))`. In other words, the basis of the product of two filters is constructed from the bases of the individual filters by taking the product of their properties and their associated sets.

Given filters `la` and `lb` on types `α` and `β` with property-set basis `(pa, sa)` and `(pb, sb)` respectively, the product filter `la ×ˢ lb` has a basis represented by the property-set `((∧) <$> (pure ∧) <$> [pa, pb], (<*>) <$> sa <*> sb)`.


theorem Real.hasDerivAt_sin : ∀ (x : ℝ), HasDerivAt Real.sin (Real.cos x) x := by sorry

This theorem states that for all real numbers `x`, the function `Real.sin` (representing the real sine function) has its derivative at the point `x`, and this derivative is `Real.cos x` (the real cosine function evaluated at `x`). In mathematical terms, it says that the derivative of the sine function at any point is the cosine function at that point, which is a well-known property in calculus.

The derivative of the real sine function is the real cosine function.


theorem MvPolynomial.map_C :
    ∀ {R : Type u} {S₁ : Type v} {σ : Type u_1} [inst : CommSemiring R] [inst_1 : CommSemiring S₁] (f : R →+* S₁)
      (a : R), (MvPolynomial.map f) (MvPolynomial.C a) = MvPolynomial.C (f a) :=
  by sorry

The `MvPolynomial.map_C` theorem states that for any commutative semirings `R` and `S₁`, and any ring homomorphism `f` from `R` to `S₁`, the operation of mapping a constant polynomial `C a` from `R` to `S₁` using `f` is the same as creating a new constant polynomial in `S₁` with the value `f a`. In other words, applying the map to the constant polynomial is equivalent to applying the homomorphism to the constant value and then creating a constant polynomial with the result.

For any commutative semirings R and S₁, and ring homomorphism f from R to S₁, the map of a constant polynomial C a from R to S₁ using f is equivalent to the constant polynomial in S₁ with value f(a).


theorem interior_Ici :
    ∀ {α : Type u} [inst : TopologicalSpace α] [inst_1 : LinearOrder α] [inst_2 : OrderTopology α]
      [inst_3 : DenselyOrdered α] [inst_4 : NoMinOrder α] {a : α}, interior (Set.Ici a) = Set.Ioi a :=
  by sorry

The theorem `interior_Ici` states that for any type `α`, given that `α` is equipped with a topological space structure, a linear order, an order topology, is densely ordered, and has no minimum element, then for any element `a` of type `α`, the interior of the set of all elements greater than or equal to `a` (`Set.Ici a`) is equal to the set of all elements strictly greater than `a` (`Set.Ioi a`). Loosely, this means that when you consider the "interior" (the largest open subset) of the left-closed right-infinite interval, you get the left-open right-infinite interval.

For a densely ordered topological space without a minimum element `α`, the interior of the set `{x : α | x ≥ a}` is equal to the set `{x : α | x > a}`.


ContinuousLinearMap.hasStrictFDerivAt

theorem ContinuousLinearMap.hasStrictFDerivAt :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F]
      (e : E →L[𝕜] F) {x : E}, HasStrictFDerivAt (⇑e) e x :=
  by sorry

This theorem states that for any continuous linear map `e` from a normed additive commutative group `E` over a nontrivially normed field `𝕜` to another normed additive commutative group `F` over the same field, the map has a strict Frechet derivative at any point `x` in `E`. In other words, it says that the derivative of the continuous linear map at any point is just the map itself.

Given a continuous linear map `e` from a normed additive commutative group `E` over a nontrivially normed field `𝕜` to another normed additive commutative group `F` over the same field, the map has a strict Frechet derivative equal to itself at every point in `E`.


theorem LinearEquiv.toLinearMap_injective :
    ∀ {R : Type u_1} {S : Type u_6} {M : Type u_7} {M₂ : Type u_9} [inst : Semiring R] [inst_1 : Semiring S]
      [inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid M₂] [inst_4 : Module R M] [inst_5 : Module S M₂] {σ : R →+* S}
      {σ' : S →+* R} [inst_6 : RingHomInvPair σ σ'] [inst_7 : RingHomInvPair σ' σ],
      Function.Injective LinearEquiv.toLinearMap :=
  by sorry

The theorem `LinearEquiv.toLinearMap_injective` states that for all semirings `R` and `S`, all additive commutative monoids `M` and `M₂`, and all modules over `R` and `S`, the function `LinearEquiv.toLinearMap` is injective. This implies that if two linear equivalences have the same corresponding linear map, then those two linear equivalences are the same. The injective property ensures uniqueness: it guarantees that we won't have two different linear equivalences that give rise to the same linear map. This works under the conditions that `σ : R →+* S` and `σ' : S →+* R` form a pair of inverse ring homomorphisms.

For every semiring homomorphism `σ : R →+* S` and modules `M` over `R` and `N` over `S`, the induced linear map from a linear equivalence `φ : M ≅ N` is unique.


theorem ge_of_tendsto' :
    ∀ {α : Type u} {β : Type v} [inst : TopologicalSpace α] [inst_1 : Preorder α] [inst_2 : ClosedIciTopology α]
      {f : β → α} {a b : α} {x : Filter β} [inst_3 : Filter.NeBot x],
      Filter.Tendsto f x (nhds a) → (∀ (c : β), b ≤ f c) → b ≤ a :=
  by sorry

This theorem states that given a topological space `α` with a preorder and a topology closed at the upper interval (`ClosedIciTopology`), a function `f` from `β` to `α`, two elements `a` and `b` of `α`, and a non-bottom filter `x` on `β`, if `f` tends to `a` at `x` (i.e., for every neighborhood of `a`, the preimage under `f` of this neighborhood is a neighborhood at `x`) and for every `c` in `β`, `b` is less than or equal to `f(c)`, then `b` is less than or equal to `a`. In other words, if a function's values are always greater than or equal to a certain number and the function tends to a limit, then the limit is at least as large as that number.

If a function `f` from a preordered topological space `β` to a preordered topological space `α` with `ClosedIciTopology`, `f` tends to `a` at a non-bottom filter `x` and `b ≤ f(c)` for all `c` in `β`, then `b ≤ a`.


theorem MeasureTheory.AEFinStronglyMeasurable.ae_eq_mk :
    ∀ {α : Type u_1} {β : Type u_2} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} [inst : TopologicalSpace β]
      {f : α → β} [inst_1 : Zero β] (hf : MeasureTheory.AEFinStronglyMeasurable f μ),
      f =ᶠ[MeasureTheory.Measure.ae μ] MeasureTheory.AEFinStronglyMeasurable.mk f hf :=
  by sorry

The theorem `MeasureTheory.AEFinStronglyMeasurable.ae_eq_mk` states that for any measured space `(α, m)`, measure `μ` on `α`, topological space `β`, a function `f : α → β`, if `f` is almost everywhere (a.e.) finitely strongly measurable with respect to `μ` (denoted as `MeasureTheory.AEFinStronglyMeasurable f μ`), then `f` is almost everywhere equal to the measure-theoretically "reconstructed" version of `f` (denoted as `MeasureTheory.AEFinStronglyMeasurable.mk f hf`).

In other words, under the conditions of the theorem, the original function `f` and its measure-theoretically reconstructed version are equal almost everywhere with respect to measure `μ`.

If `(α, m)` is a measured space, `μ` is a measure on `α`, `β` is a topological space, `f : α → β` is a.e. finitely strongly measurable with respect to `μ`, then `f` is almost everywhere equal to its measure-theoretic reconstruction `MeasureTheory.AEFinStronglyMeasurable.mk f hf` with respect to `μ`.


theorem Polynomial.div_modByMonic_unique :
    ∀ {R : Type u} [inst : Ring R] {f g : Polynomial R} (q r : Polynomial R),
      Polynomial.Monic g → r + g * q = f ∧ Polynomial.degree r < Polynomial.degree g → f /ₘ g = q ∧ f %ₘ g = r :=
  by sorry

The theorem `Polynomial.div_modByMonic_unique` states that for any ring `R` and any polynomials `f`, `g`, `q`, and `r` over `R`, if `g` is a monic polynomial (that is, its leading coefficient is 1), and `r` plus `g` times `q` equals `f` with the degree of `r` being less than the degree of `g`, then the quotient of `f` divided by `g` (using monic division) is `q` and the remainder of `f` divided by `g` (also using monic division) is `r`. This theorem sets a unique condition for the division and remainder calculation in the context of monic polynomials.

If `f`, `g` are polynomials over a ring `R` with `g` monic and of higher degree than `r`, then the quotient of `f` divided by `g` is `q` and the remainder of `f` divided by `g` is `r` if and only if `r` is the remainder of `f` when divided by `g` using monic division.


theorem MeasureTheory.weightedSMul_apply :
    ∀ {α : Type u_1} {F : Type u_3} [inst : NormedAddCommGroup F] [inst_1 : NormedSpace ℝ F] {m : MeasurableSpace α}
      (μ : MeasureTheory.Measure α) (s : Set α) (x : F), (MeasureTheory.weightedSMul μ s) x = (↑↑μ s).toReal • x :=
  by sorry

The theorem `MeasureTheory.weightedSMul_apply` states that for any measurable space `α`, any normed add commutative group `F` that is also a normed space over real numbers, any measure `μ` on `α`, any set `s` of type `α`, and any element `x` of the group `F`, the application of the function `MeasureTheory.weightedSMul μ s` to `x` is equal to the scalar multiplication of `x` by the real-valued measure of the set `s` under measure `μ`. In mathematical terms, if `μ` is a measure on a measurable space and `s` is a set in that space, then, for each `x` in a normed add commutative group that is a normed space over the reals, applying the continuous linear map given by `MeasureTheory.weightedSMul μ s` to `x` results in the same output as scaling `x` by the real value of the measure of `s` under `μ`.

For any measurable space `α`, normed add commutative group `F` over real numbers, measure `μ` on `α`, set `s` of `α`, and `x` in `F`, `MeasureTheory.weightedSMul μ s x = μ(s) * x`.


theorem Multiset.ndinsert_of_not_mem :
    ∀ {α : Type u_1} [inst : DecidableEq α] {a : α} {s : Multiset α}, a ∉ s → Multiset.ndinsert a s = a ::ₘ s := by
  sorry

This theorem states that for any type `α` with a decidable equality and any multiset `s` of this type, if an element `a` of type `α` is not a member of the multiset `s`, then using the `ndinsert` function to insert `a` into `s` will result in a new multiset where `a` is the first element followed by the elements of `s`. In terms of mathematical notation, if `a ∉ s`, then `ndinsert(a, s) = a :: s`. The `∉` symbol represents "not a member of" and `::` represents adding an element at the beginning of a list or a multiset.

For any type `α` with decidable equality and any multiset `s` of type `α`, if `a notin s`, then `ndinsert(a, s) = a :: s`.


theorem Pairwise.set_pairwise : ∀ {α : Type u_1} {r : α → α → Prop}, Pairwise r → ∀ (s : Set α), Set.Pairwise s r := by
  sorry

The theorem `Pairwise.set_pairwise` states that for any type `α` and a given relation `r` that is pairwise, if we have a set `s` of type `α`, then the relation `r` is pairwise on the set `s`. In other words, for any two distinct elements `x` and `y` in the set `s`, the relation `r` holds between `x` and `y`. This implies that if a relation holds pairwise across the entire type, it will also hold pairwise for any subset of that type.

If `r` is a pairwise relation on type `α`, then `r` holds between any two distinct elements in any set `s` of type `α`.


theorem WithTop.some_lt_some : ∀ {α : Type u_1} [inst : LT α] {a b : α}, some a < some b ↔ a < b := by sorry

This theorem states that for all types `α` equiped with a less-than ordering (denoted by `LT α`), given any two elements `a` and `b` from `α`, the wrapped value `some a` is less than `some b` within the `WithTop` type if and only if `a` is less than `b` in the original type `α`. The `WithTop` type is a type construction that adds an element "top" to a given type, usually representing an infinity or a maximum element.

For all types `α` with a less-than ordering and for all `a` and `b` in `α`, `some a < some b` in the `WithTop α` type if and only if `a < b` in `α`.


theorem QuotientGroup.ker_mk' :
    ∀ {G : Type u} [inst : Group G] (N : Subgroup G) [nN : Subgroup.Normal N],
      MonoidHom.ker (QuotientGroup.mk' N) = N :=
  by sorry

This theorem states that for any group `G` and any normal subgroup `N` of `G`, the multiplicative kernel of the group homomorphism from `G` to the quotient group `G/N` is equal to `N`. The multiplicative kernel of a group homomorphism is the subgroup of elements `x` in `G` such that the homomorphism maps `x` to the identity in `G/N`. In other words, the set of elements in `G` that get mapped to the identity in the quotient group `G/N` is exactly the set of elements in the normal subgroup `N`.

The normal subgroup of a group is the multiplicative kernel of the corresponding quotient homomorphism.


Contravariant.flip

theorem Contravariant.flip :
    ∀ {M : Type u_1} {N : Type u_2} {μ : M → N → N} {r : N → N → Prop},
      Contravariant M N μ r → Contravariant M N μ (flip r) :=
  by sorry

The theorem `Contravariant.flip` states that for any types `M` and `N`, a function `μ` from `M` and `N` to `N`, and a relation `r` on `N`, if `μ` is contravariant with respect to `r`, then it is also contravariant with respect to the flipped version of `r`. In other words, if for all `m` in `M` and `n₁`, `n₂` in `N`, `r` applied to `μ(m, n₁)` and `μ(m, n₂)` implies `r(n₁, n₂)`, then the same is true if we swap the arguments of `r` in the implication.

If a function between types is contravariant with respect to a relation, then it is also contravariant with respect to the flipped version of that relation.


theorem mul_left_iterate :
    ∀ {G : Type u_3} [inst : Monoid G] (a : G) (n : ℕ), (fun x => a * x)^[n] = fun x => a ^ n * x := by sorry

This theorem states that for any type `G` that has a Monoid structure, for any element `a` of `G` and for any natural number `n`, iterating the function `(fun x => a * x)` `n` times is the same as the function that multiplies `a` raised to the power of `n` by `x`. This is essentially expressing a property of exponentiation in the context of monoids.

For any monoid `G` and element `a` in `G`, the repeated application of the function `x => a * x` in `G` `n` times is equivalent to the monoid multiplication of `a` raised to the power of `n` and `x`.


theorem Multiset.prod_singleton : ∀ {α : Type u_2} [inst : CommMonoid α] (a : α), Multiset.prod {a} = a := by sorry

This theorem states that for any type `α` that has a commutative monoid structure, the product of a multiset that contains only one element `a` of type `α` (denoted by `Multiset.prod {a}`) is equal to the element `a` itself. In other words, the product of a singleton multiset `{a}` is `a` itself, where `*` is the multiplication operation defined in the commutitive monoid structure on `α`.

For any commutative monoid type `α`, the product of a singleton multiset `{a}` equals the element `a` itself, i.e., `Multiset.prod {a} = a`.


theorem Finset.fold_congr :
    ∀ {α : Type u_1} {β : Type u_2} {op : β → β → β} [hc : Std.Commutative op] [ha : Std.Associative op] {f : α → β}
      {b : β} {s : Finset α} {g : α → β}, (∀ x ∈ s, f x = g x) → Finset.fold op b f s = Finset.fold op b g s :=
  by sorry

The theorem `Finset.fold_congr` states that for any types `α` and `β`, any commutative and associative operation `op` on `β`, any functions `f` and `g` from `α` to `β`, any base value `b` of type `β`, and any finite set `s` of elements of `α`, if for all elements `x` in `s`, `f x` equals `g x`, then the operation `op` folded over the `f`-image of `s` plus `b` equals the operation `op` folded over the `g`-image of `s` plus `b`. In other words, if two functions agree on all elements of a particular finite set, then folding a binary operation (that is commutative and associative) over the images of the set under each function (plus a certain base value) will give the same result.

For any commutative and associative operation `op` on type `β`, functions `f` and `g` from `α` to `β`, base value `b` of type `β`, and finite set `s` of elements of `α`, if `f x = g x` for all `x` in `s`, then `op (∑ i in s, f i) b = op (∑ i in s, g i) b`.


theorem Set.Finite.compl_mem_cofinite : ∀ {α : Type u_2} {s : Set α}, Set.Finite s → sᶜ ∈ Filter.cofinite := by sorry

This theorem states that for any type `α` and any set `s` of type `α`, if the set `s` is finite then the complement of `s` (denoted as `sᶜ`) is a member of the cofinite filter. In other words, the complement of any finite set is a subset of the universe whose complement (the original set) is finite, and thus it belongs to the cofinite filter, which is the filter of subsets with finite complements.

For any type `α` and finite set `s` of type `α`, the complement of `s` belongs to the cofinite filter.


theorem ProbabilityTheory.IsFiniteKernel.bound_lt_top :
    ∀ {α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β}
      (κ : ↥(ProbabilityTheory.kernel α β)) [h : ProbabilityTheory.IsFiniteKernel κ],
      ProbabilityTheory.IsFiniteKernel.bound κ < ⊤ :=
  by sorry

This theorem states that for any probability kernel `κ` from a measurable space `α` to a measurable space `β`, if `κ` is a finite kernel, then the bound of `κ` is strictly less than infinity. A probability kernel is a function that describes the transition probabilities from one random variable to another in a stochastic process. In this context, the 'bound' of a kernel refers to an upper limit on this transition probability. Thus, this theorem is essentially saying that for any finite transition model, the transition probabilities must have an upper limit that is not infinite.

For any finite probability kernel from a measurable space to another, the supreme value of its transition probabilities is strictly less than infinity.


theorem Nat.succ_max_succ : ∀ (x y : ℕ), max (Nat.succ x) (Nat.succ y) = Nat.succ (max x y) := by sorry

This theorem states that for any two natural numbers `x` and `y`, the maximum of their successors (i.e., `x + 1` and `y + 1`) is the successor of the maximum of `x` and `y`. In other words, adding one to both numbers before finding the maximum yields the same result as finding the maximum first and then adding one.

For all natural numbers x and y, (x + 1)max (y + 1) = (x max y) + 1.


theorem PartialEquiv.refl_trans :
    ∀ {α : Type u_1} {β : Type u_2} (e : PartialEquiv α β), PartialEquiv.trans (PartialEquiv.refl α) e = e := by sorry

The theorem `PartialEquiv.refl_trans` states that for any two types `α` and `β` and any partial equivalence `e` between `α` and `β`, the composition of the identity partial equivalence on `α` and `e` is equal to `e`. Here, `PartialEquiv.trans` is a function that composes two partial equivalences, and `PartialEquiv.refl` is a function that returns the identity partial equivalence on a type. The identity partial equivalence is a partial equivalence that does not change any elements.

For any types `α` and `β` and partial equivalence `e` between them, `PartialEquiv.refl α § e = e`, where `§` denotes composition of partial equivalences in Lean.


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

The theorem `mul_nonpos_of_nonpos_of_nonneg` states that for all types `α` with instances of `MulZeroClass`, `Preorder`, and `MulPosMono`, and for all elements `a` and `b` of type `α`, if `a` is less than or equal to 0 and `b` is greater than or equal to 0, then the product of `a` and `b` is less than or equal to 0. In simpler terms, in a context where multiplication and ordering behave as expected, if one factor is nonpositive and the other is nonnegative, their product will be nonpositive.

If `a` is of type `α` with `MulZeroClass`, `Preorder`, and `MulPosMono instances`, and `a ≤ 0` and `b ≥ 0`, then `a * b ≤ 0`.


theorem exists_comm : ∀ {α : Sort u_2} {β : Sort u_1} {p : α → β → Prop}, (∃ a b, p a b) ↔ ∃ b a, p a b := by sorry

This theorem, `exists_comm`, states that for any types `α` and `β`, and for any property `p` that takes an element of `α` and an element of `β`, the existence of a pair `(a, b)` such that `p a b` holds is equivalent to the existence of a pair `(b, a)` such that `p a b` holds. In other words, the order of `a` and `b` in the existential quantification does not matter if `p a b` is true.

For any types `α` and `β` and property `p` : `α → β → Prop`, the existence of `a : α` and `b : β` such that `p a b` holds is equivalent to the existence of `b : β` and `a : α` such that `p a b` holds.


theorem Matrix.mul_adjugate :
    ∀ {n : Type v} {α : Type w} [inst : DecidableEq n] [inst_1 : Fintype n] [inst_2 : CommRing α] (A : Matrix n n α),
      A * Matrix.adjugate A = Matrix.det A • 1 :=
  by sorry

This theorem states that for any square matrix `A` (with elements in a commutative ring `α` and size determined by type `n` which has decidable equality and is finite), the product of `A` and the adjugate of `A` is equal to the determinant of `A` scaled by the identity matrix. The adjugate of a matrix is the transpose of the cofactor matrix, and the identity matrix is a square matrix with ones on the diagonal and zeros elsewhere. The `•` operator in Lean 4 denotes scalar multiplication, where a number multiplies every element of the matrix.

For any square matrix `A` of size `n` over a commutative ring with decidable equality and finite elements, `A * adj_mat A = det A • id`, where `adj_mat A` is the adjugate of `A`, `det A` is the determinant of `A`, and `id` is the identity matrix.


theorem Mathlib.Algebra.Order.Monoid.Lemmas._auxLemma.6 :
    ∀ {α : Type u_1} [inst : Add α] [inst_1 : LT α]
      [inst_2 : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x < x_1]
      [inst_3 : ContravariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x < x_1] (a : α) {b c : α},
      (a + b < a + c) = (b < c) :=
  by sorry

This theorem states that for any type `α` which is equipped with an addition operation and a less-than relation, along with two other conditions (known as CovariantClass and ContravariantClass) related to the interaction of addition and the less-than relation, the inequality between `a + b` and `a + c` is equivalent to the inequality between `b` and `c`. In other words, if `a`, `b`, and `c` are elements of type `α`, then `a + b` is less than `a + c` if and only if `b` is less than `c`. This theorem encapsulates the principle of monotonicity of addition in ordered additive monoids.

For any additive monoid with a total order, the addition operation is monotonic with respect to the order relation. That is, for all `a, b, c` in the monoid, `a + b` is less than `a + c` if and only if `b` is less than `c`.


theorem AddSubgroup.index_top : ∀ {G : Type u_1} [inst : AddGroup G], AddSubgroup.index ⊤ = 1 := by sorry

The theorem `AddSubgroup.index_top` states that for any type `G` that has an additive group structure, the index of the entire set (denoted by `⊤`) as a subgroup of itself is 1. In mathematical terms, if `G` is an additive group, then the index (or the number of distinct cosets) of `G` as a subgroup of `G` is one.

For any additive group G, the index of G as a subgroup of itself is equal to 1.


theorem IsMaxFilter.bicomp_mono :
    ∀ {α : Type u} {β : Type v} {γ : Type w} {δ : Type x} [inst : Preorder β] [inst_1 : Preorder γ] {f : α → β}
      {l : Filter α} {a : α} [inst_2 : Preorder δ] {op : β → γ → δ},
      ((fun x x_1 => x ≤ x_1) ⇒ (fun x x_1 => x ≤ x_1) ⇒ fun x x_1 => x ≤ x_1) op op →
        IsMaxFilter f l a → ∀ {g : α → γ}, IsMaxFilter g l a → IsMaxFilter (fun x => op (f x) (g x)) l a :=
  by sorry

The theorem `IsMaxFilter.bicomp_mono` states that for all types `α`, `β`, `γ`, and `δ` that are preordered, given a function `f` from `α` to `β`, a filter `l` on `α`, and an element `a` of `α`, if there exists an operator `op` from `β` and `γ` to `δ` such that this operator is monotonic with respect to both its arguments, and if `f` and another function `g` from `α` to `γ` are both maximum filters at `a` with respect to the filter `l`, then the function that maps `x` to `op (f x) (g x)` is also a maximum filter at `a` with respect to the filter `l`. In simpler terms, under these conditions, taking the `op` of the values of `f` and `g` at any point in a neighborhood of `a` will always be less than or equal to the `op` of the values of `f` and `g` at `a` itself.

If `f` and `g` are maximum filters at `a` with respect to a filter `l` on types `α`, `β`, `γ`, and `δ` preordered by `≤`, and there exists a monotonic operator `op` from `β` and `γ` to `δ`, then the function `x ↦ op (f x) (g x)` is also a maximum filter at `a` with respect to `l`.


theorem Mathlib.Order.Basic._auxLemma.26 :
    ∀ {α : Type u} [inst : LT α] {p : α → Prop} {x y : α} {hx : p x} {hy : p y},
      ({ val := x, property := hx } < { val := y, property := hy }) = (x < y) :=
  by sorry

This theorem, `Mathlib.Order.Basic._auxLemma.26`, states that for any type `α` with a less-than (`<`) operation, given a predicate `p` on `α` and two elements `x` and `y` of `α` for which the predicate `p` holds (i.e., `p x` and `p y` are both true), the inequality `{ val := x, property := hx } < { val := y, property := hy }` is equivalent to `x < y`. Here, `{ val := x, property := hx }` and `{ val := y, property := hy }` represent subtypes of `α` for which the predicate `p` holds.

For any type `α` with a total order `<` and for all `x` and `y` in `α` such that `p(x)` and `p(y)` hold, `x < y` if and only if `{x : α | p(x)} < {y : α | p(y)}`.


theorem inf_le_of_right_le : ∀ {α : Type u} [inst : SemilatticeInf α] {a b c : α}, b ≤ c → a ⊓ b ≤ c := by sorry

This theorem states that for any type `α` that forms a semilattice with an infimum (or greatest lower bound), given three elements `a`, `b`, and `c` of this type, if `b` is less than or equal to `c`, then the infimum of `a` and `b` is also less than or equal to `c`. In mathematical terms, if `b ≤ c`, then `a ⊓ b ≤ c` where `⊓` represents the infimum operation.

For any semilattice `α` with an infimum, if `b` is less than or equal to `c` in `α`, then the infimum of `a` and `b` is less than or equal to `c`: `a ⊓ b ≤ c`.


theorem AddMonoidHom.range_eq_map :
    ∀ {G : Type u_1} [inst : AddGroup G] {N : Type u_5} [inst_1 : AddGroup N] (f : G →+ N),
      AddMonoidHom.range f = AddSubgroup.map f ⊤ :=
  by sorry

This theorem states that for any addition group homomorphism `f` from an additive group `G` to another additive group `N`, the range of `f` is equal to the image of the entire group `G` (denoted as `⊤` for the top element in lattice theory, representing the whole set in this context) under the map `f`. Essentially, this expresses the fact that the range of a group homomorphism is the same as the set of all elements in the codomain that are hit by the map when applied to every element in the domain.

For any additive group homomorphism from group G to group N, the range of the homomorphism is equal to the image of G under the map.


theorem MeasureTheory.measure_union :
    ∀ {α : Type u_1} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} {s₁ s₂ : Set α},
      Disjoint s₁ s₂ → MeasurableSet s₂ → ↑↑μ (s₁ ∪ s₂) = ↑↑μ s₁ + ↑↑μ s₂ :=
  by sorry

This theorem states that for any two sets `s₁` and `s₂` in a measurable space `α` with a measure `μ`, if `s₁` and `s₂` are disjoint and `s₂` is a measurable set, then the measure of the union of `s₁` and `s₂` is equal to the sum of the measures of `s₁` and `s₂`. In other words, the measure of the union of two disjoint measurable sets is the sum of their individual measures, which is a fundamental property in measure theory.

Given measurable sets `s₁` and `s₂` in a measurable space `α` with measure `μ`, if `s₁ ∩ s₂ = ∅` then `μ(s₁ ∪ s₂) = μ(s₁) + μ(s₂)`.


theorem Set.uIoc_eq_union : ∀ {α : Type u_1} [inst : LinearOrder α] {a b : α}, Ι a b = Set.Ioc a b ∪ Set.Ioc b a := by
  sorry

The theorem `Set.uIoc_eq_union` states that for any type `α` with a linear order, and any two elements `a` and `b` of `α`, the unordered interval `Ι a b` is equal to the union of the left-open right-closed interval from `a` to `b`, denoted `Set.Ioc a b`, and the left-open right-closed interval from `b` to `a`, denoted `Set.Ioc b a`. In mathematical terms, this means that any element in the unordered interval between `a` and `b` is either greater than `a` and less than or equal to `b`, or greater than `b` and less than or equal to `a`.

For any type with a linear order, the unordered interval between two elements is equal to the union of the left-open right-closed intervals from each element to the other.


List.IsInfix.sublist

theorem List.IsInfix.sublist : ∀ {α : Type u_1} {l₁ l₂ : List α}, l₁ <:+: l₂ → List.Sublist l₁ l₂ := by sorry

This theorem states that for any type `α` and any lists `l₁` and `l₂` of type `α`, if `l₁` is an infix of `l₂` (expressed by the notation `l₁ <:+: l₂`), then `l₁` is also a sublist of `l₂` (expressed by `List.Sublist l₁ l₂`). In other words, if one list appears contiguously within another, then it can be derived from the second list by deleting zero or more elements, not necessarily from the ends.

If `α` is a type and `l₁` is an infix sublist of `l₂` (`l₁ <:+: l₂`), then `l₁` is a sublist of `l₂` (`List.Sublist l₁ l₂`).


Equiv.Perm.Disjoint.symm

theorem Equiv.Perm.Disjoint.symm :
    ∀ {α : Type u_1} {f g : Equiv.Perm α}, Equiv.Perm.Disjoint f g → Equiv.Perm.Disjoint g f := by sorry

The theorem `Equiv.Perm.Disjoint.symm` states that for any type `α` and any pair of permutations `f` and `g` over this type, if `f` and `g` are `Disjoint` (i.e., their supports are disjoint so that every element is either fixed by `f` or by `g`), then `g` and `f` are also `Disjoint`. This is a property of symmetry in the sense that the order of permutations in the `Disjoint` relation doesn't matter.

For any type `α` and permutations `f` and `g` over it, if `f` and `g` are disjoint (i.e., their supports are disjoint), then `g` and `f` are also disjoint. (The symmetry property implies that the order of the permutations does not matter in the disjointness relation.)


theorem MvPowerSeries.coeff_monomial :
    ∀ {σ : Type u_1} {R : Type u_2} [inst : Semiring R] [inst_1 : DecidableEq σ] (m n : σ →₀ ℕ) (a : R),
      (MvPowerSeries.coeff R m) ((MvPowerSeries.monomial R n) a) = if m = n then a else 0 :=
  by sorry

The theorem `MvPowerSeries.coeff_monomial` states that for any types `σ` and `R`, where `R` is a semiring and `σ` has decidable equality, for any multivariate indices `m` and `n` (which are functions from `σ` to `ℕ`), and for any element `a` from `R`, the `m`th coefficient of the `n`th monomial of the multivariate formal power series, scaled by `a`, equals `a` if `m` equals `n` and zero otherwise. In other words, it expresses that in a multivariate power series, the coefficient of a particular monomial is the scaling factor if the indices match, and is zero for all other monomials.

For any semiring `R` and type `σ` with decidable equality, the `m`th coefficient of the `n`th monomial in a multivariate formal power series over `R` scaled by an element `a` from `R` is equal to `a` if `m` equals `n`, and zero otherwise.


Covariant.flip

theorem Covariant.flip :
    ∀ {M : Type u_1} {N : Type u_2} {μ : M → N → N} {r : N → N → Prop}, Covariant M N μ r → Covariant M N μ (flip r) :=
  by sorry

The theorem `Covariant.flip` states that for all types `M` and `N`, a function `μ : M → N → N`, and a relation `r` on `N`, if `μ` is covariant with respect to `r`, then `μ` is also covariant with respect to the flipped relation of `r`. Here, a function is called covariant with respect to a relation if applying the function to two elements does not change the relation between them. The flip of a relation is a new relation where the order of arguments is reversed. In other words, if `μ` preserves the relation `r` between two elements of `N`, then it also preserves the relation `r` when the order of these elements is reversed.

If a function `μ : M → N → N` is covariant with respect to a relation `r` on `N`, then it is also covariant with respect to the flipped relation of `r`.


theorem AlgHom.coe_ringHom_injective :
    ∀ {R : Type u} {A : Type v} {B : Type w} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Semiring B]
      [inst_3 : Algebra R A] [inst_4 : Algebra R B], Function.Injective RingHomClass.toRingHom :=
  by sorry

The theorem `AlgHom.coe_ringHom_injective` states that for any commutative semiring `R`, semirings `A` and `B`, and algebraic structures over `R` on `A` and `B`, the function `RingHomClass.toRingHom` is injective. This injectiveness means that if two elements of the type `F` satisfying `RingHomClass F α β` are mapped to the same ring homomorphism by `RingHomClass.toRingHom`, then those two elements were the same to begin with.

The `RingHomClass.toRingHom` function maps distinct ring homomorphisms from a commutative semiring `R` to algebraic structures over `R` in `A` and `B` to distinct homomorphisms.


theorem OnePoint.openEmbedding_coe : ∀ {X : Type u_1} [inst : TopologicalSpace X], OpenEmbedding OnePoint.some := by
  sorry

This theorem states that for any type `X` equipped with a topological space structure, the function `OnePoint.some`, which coerces an element of `X` into an element of `OnePoint X`, is an open embedding. In the context of topology, an open embedding is a type of continuous function between topological spaces that not only maps open sets to open sets, but also has the property that the image of the function is a topological space with the subspace topology inherited from the codomain.

The `OnePoint.some` function, which maps an element of a topological space `X` to the one-point topological space on it, is a continuous open embedding.


theorem IntermediateField.toSubalgebra_injective :
    ∀ {K : Type u_1} {L : Type u_2} [inst : Field K] [inst_1 : Field L] [inst_2 : Algebra K L],
      Function.Injective IntermediateField.toSubalgebra :=
  by sorry

The theorem `IntermediateField.toSubalgebra_injective` states that for any types `K` and `L` that are fields with `K` being an algebra over `L`, the function `IntermediateField.toSubalgebra`, which reinterprets an `IntermediateField` as a `Subalgebra`, is injective. This means that if two different intermediate fields of `K` over `L` are transformed into the same subalgebra via `IntermediateField.toSubalgebra`, they must have originally been the same intermediate field. In essence, no information is lost when converting from an `IntermediateField` to a `Subalgebra`.

The function `IntermediateField.toSubalgebra` maps distinct intermediate fields of `K` over `L` to distinct subalgebras.


theorem Set.dual_Ioo :
    ∀ {α : Type u_1} [inst : Preorder α] {a b : α},
      Set.Ioo (OrderDual.toDual a) (OrderDual.toDual b) = ⇑OrderDual.ofDual ⁻¹' Set.Ioo b a :=
  by sorry

The theorem `Set.dual_Ioo` states that for any type `α` with a preorder relation, and any two elements `a` and `b` of this type, the left-open right-open interval in the dual order between `a` and `b` (that is, the set of elements `x` such that `a < x < b` under the dual order) is the preimage under the function `OrderDual.ofDual` of the left-open right-open interval between `b` and `a` in the original order. In other words, if we reverse the order of `a` and `b` and then apply `ofDual` to each element, we get the original interval between `a` and `b`.

The dual order interval `(a, b)` in a preordered type equals the preimage of the original order interval `(b, a)` under the `OrderDual.ofDual` function.


theorem Set.dual_Ioc :
    ∀ {α : Type u_1} [inst : Preorder α] {a b : α},
      Set.Ioc (OrderDual.toDual a) (OrderDual.toDual b) = ⇑OrderDual.ofDual ⁻¹' Set.Ico b a :=
  by sorry

This theorem states that for any preorder set `α` and any two elements `a` and `b` of `α`, the left-open right-closed interval (denoted as `Set.Ioc`) between `a` and `b` under the dual order is equivalent to the preimage of the left-closed right-open interval (denoted as `Set.Ico`) between `b` and `a` under the original order. This theorem essentially expresses the dual relationship between the open-closed and closed-open intervals in a given order and its dual order.

For any preorder set `α` and elements `a` and `b` of `α`, the left-open right-closed interval `Set.Ioc a b` under the dual order is equivalent to the preimage of the left-closed right-open interval `Set.Ico b a` under the original order.


theorem GaloisInsertion.l_inf_u :
    ∀ {α : Type u} {β : Type v} {l : α → β} {u : β → α} [inst : SemilatticeInf α] [inst_1 : SemilatticeInf β],
      GaloisInsertion l u → ∀ (a b : β), l (u a ⊓ u b) = a ⊓ b :=
  by sorry

This theorem states that for any two types `α` and `β`, and any two functions `l : α → β` and `u : β → α`, if `l` and `u` form a Galois Insertion and the SemilatticeInf structure exists on both `α` and `β`, then for any elements `a` and `b` of type `β`, the result of applying `l` to the infimum of `u a` and `u b` is equal to the infimum of `a` and `b`. In terms of order theory, this basically asserts that the lower adjoint `l` of a Galois insertion preserves infimums.

For any Galois insertions `l : α → β` and `u : β → α` between semilattically ordered types `α` and `β`, the lower adjoint `l` preserves infima, that is, `l (inf  (u a) (u b)) = inf  a b`.


theorem LocalizedModule.mk_eq :
    ∀ {R : Type u} [inst : CommSemiring R] {S : Submonoid R} {M : Type v} [inst_1 : AddCommMonoid M]
      [inst_2 : Module R M] {m m' : M} {s s' : ↥S},
      LocalizedModule.mk m s = LocalizedModule.mk m' s' ↔ ∃ u, u • s' • m = u • s • m' :=
  by sorry

The theorem `LocalizedModule.mk_eq` states that for any commutative semiring `R`, any submonoid `S` of `R`, any additive commutative monoid `M` that is also an `R`-module, and any elements `m, m'` of `M` and `s, s'` of the submonoid `S`, the localized module elements `m/s` and `m'/s'` are equal if and only if there exists an element `u` in the submonoid `S` such that `u` multiplied by `s'` and then by `m` equals `u` multiplied by `s` and then by `m'`. In other words, if two fractions `m/s` and `m'/s'` in the localized module are equal, then there's a 'scaling factor' `u` that links `m` and `s'` with `m'` and `s`.

For any commutative semiring R, submonoid S of R, additive commutative monoid M an R-module, and elements m, m' of M and s, s' of S, the localized module elements m/s and m'/s' are equal if and only if there exists u in S such that us = sm and um' = s'm'.


theorem grade_strictMono :
    ∀ {𝕆 : Type u_1} {α : Type u_3} [inst : Preorder 𝕆] [inst_1 : Preorder α] [inst_2 : GradeOrder 𝕆 α],
      StrictMono (grade 𝕆) :=
  by sorry

The theorem `grade_strictMono` states that for any types `𝕆` and `α`, with `𝕆` and `α` being preordered and `𝕆` being a graded order over `α`, the `grade` function, which assigns to each element of `α` its grade in `𝕆`, is strictly monotone. This means that if `a` and `b` are elements of `α` and `a < b`, then `grade 𝕆 a < grade 𝕆 b`. In other words, if one element in `α` is less than another, its grade, i.e., the number of elements you need to go down by to get to the bottom, is also less.

For any preordered type `α` with a graded order `𝕆`, the grade function strictly increases along `<`-chains in `α`.


theorem Nat.Coprime.mul_dvd_of_dvd_of_dvd : ∀ {m n a : ℕ}, Nat.Coprime m n → m ∣ a → n ∣ a → m * n ∣ a := by sorry

The theorem `Nat.Coprime.mul_dvd_of_dvd_of_dvd` states that for any three natural numbers `m`, `n`, and `a`, if `m` and `n` are coprime (i.e., the greatest common divisor of `m` and `n` is 1), and both `m` and `n` divide `a`, then the product of `m` and `n` also divides `a`. This theorem provides a condition under which the product of two numbers is a divisor of another number.

If natural numbers `m` and `n` are coprime, and both `m` and `n` divide `a`, then `m * n` divides `a`.


theorem MeasurableEquiv.map_ae :
    ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] [inst_1 : MeasurableSpace β] (f : α ≃ᵐ β)
      (μ : MeasureTheory.Measure α),
      Filter.map (⇑f) (MeasureTheory.Measure.ae μ) = MeasureTheory.Measure.ae (MeasureTheory.Measure.map (⇑f) μ) :=
  by sorry

This theorem, `MeasurableEquiv.map_ae`, states that for any types `α` and `β` each equipped with a `MeasurableSpace` structure, for any measurable equivalence `f` between `α` and `β`, and any measure `μ` on `α`, the forward map of the filter of the "almost everywhere" filter of `μ` under `f` is equal to the "almost everywhere" filter of the pushforward measure under `f`. This illustrates how the "almost everywhere" property and the pushforward measure interact with each other under a measurable equivalence.

For any measurable spaces `(α, Σα)` and `(β, Σβ)`, measurable equivalence `f : α ≃ β`, and measure `μ : MeasurableDistribution Σα`, the forward image of `μ`'s almost everywhere filter under `f` equals the almost everywhere filter of the pushforward measure `f_# μ`.


theorem antitone_nat_of_succ_le :
    ∀ {α : Type u} [inst : Preorder α] {f : ℕ → α}, (∀ (n : ℕ), f (n + 1) ≤ f n) → Antitone f := by sorry

The theorem `antitone_nat_of_succ_le` states that for any type `α` that has a preorder, and any function `f` from natural numbers to `α`, if for all natural number `n`, `f(n + 1)` is less than or equal to `f(n)`, then the function `f` is antitone. In other words, if a function `f` decreases or remains the same at each step when moving from `n` to `n+1`, then `f` is defined as antitone, meaning that it preserves the order when the order of arguments is reversed.

If a function from natural numbers to a preordered type decreases or is constant at each successor step, then it is antitone.


Ordinal.IsNormal.monotone

theorem Ordinal.IsNormal.monotone : ∀ {f : Ordinal.{u_4} → Ordinal.{u_5}}, Ordinal.IsNormal f → Monotone f := by sorry

The theorem `Ordinal.IsNormal.monotone` states that for any function `f` from an ordinal to another ordinal, if `f` is a normal ordinal function, then `f` is monotone. In other words, if `f` is strictly increasing and order-continuous (the image of a limit ordinal is the supremum of the images of ordinals less than it), then `f` preserves the order, i.e., if `a` is less than or equal to `b`, then `f(a)` is less than or equal to `f(b)`.

If `f` is a normal function from an ordinal to another ordinal, then `f` is monotone.


theorem CategoryTheory.GrothendieckTopology.transitive :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X : C} {S : CategoryTheory.Sieve X}
      (J : CategoryTheory.GrothendieckTopology C),
      S ∈ J.sieves X →
        ∀ (R : CategoryTheory.Sieve X),
          (∀ ⦃Y : C⦄ ⦃f : Y ⟶ X⦄, S.arrows f → CategoryTheory.Sieve.pullback f R ∈ J.sieves Y) → R ∈ J.sieves X :=
  by sorry

The `CategoryTheory.GrothendieckTopology.transitive` theorem states that, for a given category `C`, an object `X` in `C`, a sieve `S` on `X`, and a Grothendieck topology `J` on `C`, if `S` belongs to the set of sieves associated with `X` in the topology `J`, then for any other sieve `R` on `X`, if for all objects `Y` in `C` and morphisms `f` from `Y` to `X` such that `f` is in the arrows of `S`, the pullback of `f` under `R` is in the sieves associated with `Y` in the topology `J`, then `R` is also in the sieves associated with `X` in the topology `J`. In other words, this is the transitivity property of Grothendieck topologies, which ensures that if a sieve `R` covers all arrows in `S` that are covered by the topology `J`, then `R` is also covered by `J`.

Given a category `C`, an object `X` in `C`, a Grothendieck topology `J` on `C`, and a sieve `S` on `X` belonging to the topology `J`, if for all sieves `R` on `X` such that `S` is contained in `R` and every arrow `f` from an object `Y` to `X` in `S` has a pullback in `R` also belonging to `J`, then `R` is also in the topology `J`.


theorem TopologicalSpace.countable_countableBasis :
    ∀ (α : Type u) [t : TopologicalSpace α] [inst : SecondCountableTopology α],
      Set.Countable (TopologicalSpace.countableBasis α) :=
  by sorry

The theorem `TopologicalSpace.countable_countableBasis` states that for any type `α` and any given topological space `t` on `α` that has a second-countable topology (denoted by `inst`), the topological basis of `α` is countable. In other words, there exists an injective map from the set of basis elements to the set of natural numbers. This is essentially saying that in a second-countable topological space, the basis, which is the set of all possible open sets, can be listed in a sequence (or equivalently, enumerated), reflecting the property of second-countability.

In a second-countable topological space, its topological basis is a countable set.


/-- Product of a multiset of elements in a submonoid of a `CommMonoid` is in the submonoid.  -/
theorem multiset_prod_mem :
    ∀ {B : Type u_3} {S : B} {M : Type u_4} [inst : CommMonoid M] [inst_1 : SetLike B M] [inst_2 : SubmonoidClass B M]
      (m : Multiset M), (∀ a ∈ m, a ∈ S) → Multiset.prod m ∈ S :=
  by sorry

The theorem `multiset_prod_mem` states that for any type `B`, a submonoid `S` of type `B`, a type `M` with a `CommMonoid` structure, and a multiset `m` of elements from `M`, if every element `a` in the multiset `m` is also in the submonoid `S`, then the product of all elements in the multiset `m` (calculated with the `Multiset.prod` function) will also be in the submonoid `S`. This theorem relies on the idea that the product of elements in a submonoid will still be in the submonoid, given a commutative monoid structure on `M`.

If `S` is a submonoid of commutative monoid `M`, and all elements in a multiset `m` of `M` belong to `S`, then the multiset product of `m` (as defined in Lean's `Multiset.prod`) is also an element of `S`.


theorem CategoryTheory.Limits.colimit.ι_pre :
    ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] {K : Type u₂}
      [inst_1 : CategoryTheory.Category.{v₂, u₂} K] {C : Type u} [inst_2 : CategoryTheory.Category.{v, u} C]
      (F : CategoryTheory.Functor J C) [inst_3 : CategoryTheory.Limits.HasColimit F] (E : CategoryTheory.Functor K J)
      [inst_4 : CategoryTheory.Limits.HasColimit (CategoryTheory.Functor.comp E F)] (k : K),
      CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.colimit.ι (CategoryTheory.Functor.comp E F) k)
          (CategoryTheory.Limits.colimit.pre F E) =
        CategoryTheory.Limits.colimit.ι F (E.obj k) :=
  by sorry

The theorem `CategoryTheory.Limits.colimit.ι_pre` states that for any categories `J`, `K`, and `C`, a functor `F` from `J` to `C`, a functor `E` from `K` to `J`, and an object `k` in `K`, the composition of the coprojection from the colimit of the composite functor `E` followed by `F` at `k` and the colimit precomposition `F` with `E` is equal to the coprojection from the colimit of `F` at `E.obj k`. This means that the diagram involving these coprojections and the colimit precomposition commutes. This is a fundamental property in the theory of colimits in category theory.

For any functors F from J to C, E from K to J, object k in K, the diagram commutes between the coprojection from the colimit of F at E.obj k, the colimit precomposition F with E at k, and the coprojection from the colimit of the composite functor E then F.


theorem lp.normedAddCommGroup.proof_3 :
    ∀ {α : Type u_1} {E : α → Type u_2} {p : ENNReal} [inst : (i : α) → NormedAddCommGroup (E i)] ⦃f : ↥(lp E p)⦄,
      ‖-f‖ = ‖f‖ :=
  by sorry

This theorem states that for any type `α`, any function `E` from `α` to another type, any extended nonnegative real number `p`, and any norm on `E`, if `f` is an element of the `lp` space constructed from `E` and `p`, then the norm of the negation of `f` is equal to the norm of `f`. In mathematical terms, this asserts that the `lp` space is an instance of a normed vector space where the norm satisfies the property ‖-f‖ = ‖f‖ for all `f` in the space, a property frequently known as the "absolute homogeneity" property of norms.

For any normed vector space (α, E, ‖·‖) and any element f ∈ Lp(α, E, p), the norm of the negation of f is equal to the norm of f, i.e., ‖-f‖ = ‖f‖.


theorem lp.normedAddCommGroup.proof_2 :
    ∀ {α : Type u_1} {E : α → Type u_2} {p : ENNReal} [inst : (i : α) → NormedAddCommGroup (E i)] [hp : Fact (1 ≤ p)]
      (f g : ↥(lp E p)), ‖f + g‖ ≤ ‖f‖ + ‖g‖ :=
  by sorry

This theorem states that for any type `α`, a function `E` from `α` to some type, a nonnegative extended real number `p`, and given that each `E i` forms a normed add commutative group, and `p` is greater than or equal to 1, for any two elements `f` and `g` in the lp space defined by `E` and `p`, the norm of the sum of `f` and `g` is less than or equal to the sum of their norms. This property is generally known in mathematics as the triangle inequality in the context of normed spaces.

For any normed add commutative group `(α, E)` and `p ≥ 1`, the triangle inequality holds: `‖f + g‖≤‖f‖ + ‖g‖` for all `f, g ∈ α`.


theorem lp.normedAddCommGroup.proof_4 :
    ∀ {α : Type u_1} {E : α → Type u_2} {p : ENNReal} [inst : (i : α) → NormedAddCommGroup (E i)] (f : ↥(lp E p)),
      ‖f‖ = 0 → f = 0 :=
  by sorry

This theorem states that for any type `α`, any function `E` from `α` to another type, any extended nonnegative real number `p`, and given that for each element of type `α`, `E i` forms a normed additive commutative group, if we have a function `f` which lies in the `lp` space associated with `E` and `p`, then if the norm of `f` is zero, `f` must be the zero function. In other words, it asserts that in this particular `lp` space, the only function with a zero norm is the zero function itself.

If `α` is a type, `E : α →* X` is a normed additive commutative group, `p : ℝ > 0`, and `f : α → X` is a function in the `lp(p)` space with respect to `E` and `p`, then `∥f∥ₗₗₗ(p) = 0` implies `f = 0`.


theorem lp.normedAddCommGroup.proof_1 :
    ∀ {α : Type u_1} {E : α → Type u_2} {p : ENNReal} [inst : (i : α) → NormedAddCommGroup (E i)], ‖0‖ = 0 := by sorry

This theorem states that for any type `α`, any function `E` from `α` to another type, and any extended nonnegative real number `p`, given an instance of `NormedAddCommGroup` for `E i` for all `i` in `α`, the norm of the zero element in this normed additive commutative group is zero. The norm here could be thought of as the "length" or "size" of the element, and this theorem is asserting the common mathematical principle that the size of the zero element is zero.

For any normed additive commutative group `(E : α →* X)` with `α` being any type, the norm of the zero element is zero.


theorem Asymptotics.IsLittleO.congr_left :
    ∀ {α : Type u_1} {E : Type u_3} {F : Type u_4} [inst : Norm E] [inst_1 : Norm F] {g : α → F} {l : Filter α}
      {f₁ f₂ : α → E}, f₁ =o[l] g → (∀ (x : α), f₁ x = f₂ x) → f₂ =o[l] g :=
  by sorry

This theorem states that in the context of asymptotic notation, if a function `f₁` is little-o of another function `g` (which is represented as `f₁ =o[l] g`), and every output of `f₁` is equal to the corresponding output of another function `f₂` (expressed as `∀ (x : α), f₁ x = f₂ x`), then `f₂` is also little-o of `g` (expressed as `f₂ =o[l] g`). Essentially, it shows that the little-o property is preserved under pointwise equality.

If `f₁ =o[l] g` and `∀ (x : α), f₁ x = f₂ x`, then `f₂ =o[l] g`.


theorem CompHaus.epi_iff_surjective : ∀ {X Y : CompHaus} (f : X ⟶ Y), CategoryTheory.Epi f ↔ Function.Surjective ⇑f :=
  by sorry

The theorem `CompHaus.epi_iff_surjective` states that for any two compact Hausdorff spaces `X` and `Y`, and a morphism `f` from `X` to `Y`, `f` is an epimorphism in the category of compact Hausdorff spaces if and only if the function represented by `f` is surjective. In other words, `f` is an epimorphism (i.e., splitting monomorphism or every parallel pair of morphisms `g, h : Y → Z` such that `g ∘ f = h ∘ f` implies `g = h`) if and only if for every element `b` in `Y`, there exists an element `a` in `X` such that `f(a) = b`.

A morphism between compact Hausdorff spaces is an epimorphism if and only if it is surjective.


theorem Finset.toFinset_coe : ∀ {α : Type u_1} (s : Finset α) [inst : Fintype ↑↑s], Set.toFinset ↑s = s := by sorry

The theorem `Finset.toFinset_coe` states that for any type `α` and any finite set `s` of type `α`, the operation of transforming the set `s` into a finset (finite set) using the `Set.toFinset` function will simply return `s` itself. This holds for all `s` such that `s` is itself a finset and there is a `Fintype` instance for the double coercion `↑↑s`. Essentially, this theorem states that the `Set.toFinset` operation on a finset is the identity function.

For any finite set `s` of type `α` that is also a finset and has a `Fintype` instance for its double coercion, `Set.toFinset s = s`.


theorem hasFDerivAt_id :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] (x : E), HasFDerivAt id (ContinuousLinearMap.id 𝕜 E) x :=
  by sorry

The theorem `hasFDerivAt_id` states that for any type `𝕜` that is a nontrivially normed field and any type `E` that is a normed space over `𝕜`, the identity function has its derivative at any point `x` in `E`, which is the identity map itself as a continuous linear map. In mathematical terms, it says that the derivative of the identity function at any point is still the identity function.

For any nontrivially normed field `𝕜` and normed space `E` over `𝕜`, the identity function on `E` is its own derivative as a continuous linear map.


theorem mul_eq_one_iff_eq_inv : ∀ {G : Type u_3} [inst : Group G] {a b : G}, a * b = 1 ↔ a = b⁻¹ := by sorry

This theorem states that for any type `G` that has a group structure, and for any elements `a` and `b` of this type, the product `a * b` equals the identity element `1` if and only if `a` equals the inverse of `b`, denoted by `b⁻¹`. In other words, in a group, the only way the product of two elements can be the identity is if one is the inverse of the other.

In a group, for all elements `a` and `b`, `a * b = 1` if and only if `a = b⁻¹`.


theorem Nat.pair_unpair : ∀ (n : ℕ), Nat.pair (Nat.unpair n).1 (Nat.unpair n).2 = n := by sorry

The theorem `Nat.pair_unpair` states that for all natural numbers `n`, if we first unpair `n` into a pair of natural numbers and then pair these numbers again using the defined pairing function `Nat.pair`, we will obtain the original number `n` back. In other words, the functions `Nat.pair` and `Nat.unpair` are inverses of each other with respect to this operation.

For all natural numbers `n`, `Nat.pair (Nat.unpair n) = n` and `Nat.unpair (Nat.pair x y) = x + y`, where `x` and `y` are the components of the pair `Nat.pair x y`.


theorem Mathlib.CategoryTheory.Iso._auxLemma.4 :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z : C} (α : X ⟶ Y) [inst_1 : CategoryTheory.IsIso α]
      {f : X ⟶ Z} {g : Y ⟶ Z},
      (g = CategoryTheory.CategoryStruct.comp (CategoryTheory.inv α) f) =
        (CategoryTheory.CategoryStruct.comp α g = f) :=
  by sorry

This theorem states that for any category `C` and objects `X`, `Y`, `Z` in `C`, given an isomorphism `α` from `X` to `Y`, and morphisms `f` from `X` to `Z` and `g` from `Y` to `Z`, the equality `g = CategoryTheory.CategoryStruct.comp (CategoryTheory.inv α) f` is equivalent to `CategoryTheory.CategoryStruct.comp α g = f`. In simpler terms, this theorem states that if you compose the inverse of isomorphism `α` with the morphism `f` and get `g`, it is same as composing `α` with `g` to get `f`. This captures a fundamental property of isomorphisms in category theory: they can be "undone" or "reversed" using their inverse.

For any category `C` and isomorphisms `α:` `X ↔ Y` in `C`, morphisms `f:` `X → Z`, and `g:` `Y → Z`, the equality `g = α⁻¹ ∘ f` is equivalent to `α ∘ g = f`.


Turing.BlankExtends.refl

theorem Turing.BlankExtends.refl : ∀ {Γ : Type u_1} [inst : Inhabited Γ] (l : List Γ), Turing.BlankExtends l l := by
  sorry

The theorem `Turing.BlankExtends.refl` states that, for any type `Γ` that has an inhabited instance and any list `l` of type `List Γ`, the `Turing.BlankExtends` partial order holds between `l` and itself. In other words, any list `l` can be viewed as being obtained by adding zero blanks to the end of itself.

For any type `Γ` with an inhabited instance and any list `l` of type `List Γ`, `l` is related to itself under the `Turing.BlankExtends` partial order.


theorem Filter.map_map₂_distrib :
    ∀ {α : Type u_1} {α' : Type u_2} {β : Type u_3} {β' : Type u_4} {γ : Type u_5} {δ : Type u_7} {m : α → β → γ}
      {f : Filter α} {g : Filter β} {n : γ → δ} {m' : α' → β' → δ} {n₁ : α → α'} {n₂ : β → β'},
      (∀ (a : α) (b : β), n (m a b) = m' (n₁ a) (n₂ b)) →
        Filter.map n (Filter.map₂ m f g) = Filter.map₂ m' (Filter.map n₁ f) (Filter.map n₂ g) :=
  by sorry

This theorem, `Filter.map_map₂_distrib`, states that for all types `α`, `α'`, `β`, `β'`, `γ`, and `δ`, and for all functions `m` mapping from `α` and `β` to `γ`, `n` mapping from `γ` to `δ`, `m'` mapping from `α'` and `β'` to `δ`, and `n₁` and `n₂` mapping from `α` to `α'` and `β` to `β'` respectively, if for every `a` in `α` and `b` in `β`, applying `n` to `m(a, b)` is equal to applying `m'` to `n₁(a)` and `n₂(b)`, then the image of the function `n` under the filter `m` composed with `f` and `g` is equal to the image of the function `m'` under the filter `n₁` composed with `f` and `n₂` composed with `g`.

In mathematical terms, this theorem reflects the distributivity of function mapping over binary function mapping under certain conditions, when applied to filters on sets.

If for all `a` in `α` and `b` in `β`, `n(m(a, b)) = m'(n₁(a), n₂(b))`, then `(filter m . f . g) . n = filter (λ a b, m'(n₁ a, n₂ b)) . f . g`.


theorem ENNReal.Tendsto.const_mul :
    ∀ {α : Type u_1} {f : Filter α} {m : α → ENNReal} {a b : ENNReal},
      Filter.Tendsto m f (nhds b) → b ≠ 0 ∨ a ≠ ⊤ → Filter.Tendsto (fun b => a * m b) f (nhds (a * b)) :=
  by sorry

The theorem `ENNReal.Tendsto.const_mul` states that for all types `α`, filters `f` on `α`, functions `m` from `α` to the extended nonnegative real numbers `ENNReal`, and extended nonnegative real numbers `a` and `b`, if the function `m` tends to `b` as `f` tends to the neighborhood filter at `b` (expressed as `Filter.Tendsto m f (nhds b)`), and either `b` is not zero or `a` is not infinity, then the function that multiplies `a` with the image of `m` (`fun b => a * m b`) also tends to `a * b` as `f` tends to the neighborhood filter at `a * b` (expressed as `Filter.Tendsto (fun b => a * m b) f (nhds (a * b))`). In simpler terms, this theorem states that the limit of the product of a constant and a function, under certain conditions, is the product of the constant and the limit of the function.

If a function `m` tends to `b` as filter `f` approaches `b`, and either `b` is nonzero or `a` is finite, then the function `a * m` tends to `a * b` as filter `f` approaches `a * b`.


theorem CategoryTheory.Limits.colimit.isoColimitCocone_ι_inv :
    ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] {C : Type u} [inst_1 : CategoryTheory.Category.{v, u} C]
      {F : CategoryTheory.Functor J C} [inst_2 : CategoryTheory.Limits.HasColimit F]
      (t : CategoryTheory.Limits.ColimitCocone F) (j : J),
      CategoryTheory.CategoryStruct.comp (t.cocone.ι.app j) (CategoryTheory.Limits.colimit.isoColimitCocone t).inv =
        CategoryTheory.Limits.colimit.ι F j :=
  by sorry

This theorem states that for any category `J` of type `u₁`, category `C` of type `u`, and functor `F` from `J` to `C` that has a colimit, given any `j` from `J` and a co-limit cocone `t` of `F`, the composition of the morphism from `j` to the cocone's apex with the inverse of the isomorphism from the colimit to the cocone's apex is the same as the co-projection from the object `j` under the functor `F` to the colimit of the functor `F`. This result is a key part of the universal property defining colimits in a category.

For any functor F from category J to C with a colimit, the inverse of the unique isomorphism from F's colimit to the cocone's apex equals the co-projection of the object under F from J to the colimit.


theorem LinearEquiv.map_smul :
    ∀ {R₁ : Type u_2} {N₁ : Type u_11} {N₂ : Type u_12} [inst : Semiring R₁] [inst_1 : AddCommMonoid N₁]
      [inst_2 : AddCommMonoid N₂] {module_N₁ : Module R₁ N₁} {module_N₂ : Module R₁ N₂} (e : N₁ ≃ₗ[R₁] N₂) (c : R₁)
      (x : N₁), e (c • x) = c • e x :=
  by sorry

This theorem asserts that for any semiring `R₁`, and additive commutative monoids `N₁` and `N₂`, where `N₁` and `N₂` are `R₁`-modules, a linear equivalence `e` between `N₁` and `N₂` will preserve scalar multiplication. Specifically, for any scalar `c` in `R₁` and vector `x` in `N₁`, applying `e` to the result of scaling `x` by `c` (`e (c • x)`) is the same as scaling the result of applying `e` to `x` by `c` (`c • e x`). This property is a key characteristic of linear transformations.

Given any semiring `R₁`, additive commutative monoids `N₁` and `N₂` as `R₁`-modules, and a linear equivalence `e` between `N₁` and `N₂`, for all `c in R₁` and `x in N₁`, we have `e (c • x) = c • e x`.


theorem mul_tsub :
    ∀ {α : Type u} [inst : CanonicallyOrderedCommSemiring α] [inst_1 : Sub α] [inst_2 : OrderedSub α]
      [inst_3 : IsTotal α fun x x_1 => x ≤ x_1]
      [inst_4 : ContravariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] (a b c : α),
      a * (b - c) = a * b - a * c :=
  by sorry

This theorem states that for any type `α` that is a canonically ordered commutative semiring with subtraction (denoted by `-`), following an ordered subtraction law, total order (`≤`) and contravariant class with respect to addition (`+`) and total order (`≤`), the distributive property of multiplication over subtraction holds. In other words, for any three elements `a`, `b`, and `c` of the type `α`, the product of `a` and the difference of `b` and `c` (i.e., `a * (b - c)`) is equal to the difference of the product of `a` and `b` and the product of `a` and `c` (i.e., `a * b - a * c`).

For any commutative semiring `α` with subtraction and order `≤` satisfying the ordered subtraction and contravariance properties, the distributive property of multiplication over subtraction holds: `a * (b - c) = a * b - a * c` for all `a, b, c` in `α`.


theorem Multiset.forall_mem_map_iff :
    ∀ {α : Type u_1} {β : Type v} {f : α → β} {p : β → Prop} {s : Multiset α},
      (∀ y ∈ Multiset.map f s, p y) ↔ ∀ x ∈ s, p (f x) :=
  by sorry

This theorem states that for any type `α` and `β`, a function `f` from `α` to `β`, a predicate `p` on `β`, and a multiset `s` of type `α`, the property that every element `y` in the multiset obtained by mapping `f` over `s` satisfies the predicate `p` is equivalent to the property that for every element `x` in `s`, `p` is satisfied by `f x`. In other words, the predicate `p` holds for all elements in the image of `s` under `f` if and only if `p` holds for all images under `f` of elements in `s`.

For any function $f: \alpha \to \beta$, predicate $p \subseteq \beta$, multiset $s \subseteq \alpha$, the property that for all $y \in \text{image}(f, s)$, $p(y)$ holds if and only if for all $x \in s$, $p(f(x))$ holds.


theorem BoundedContinuousFunction.coe_zero :
    ∀ {α : Type u} {β : Type v} [inst : TopologicalSpace α] [inst_1 : PseudoMetricSpace β] [inst_2 : Zero β], ⇑0 = 0 :=
  by sorry

This theorem states that for any types `α` and `β`, where `α` is a topological space and `β` is a pseudo metric space with a defined zero, the function that applies the zero constant function (denoted by `0` here) is equivalent to the zero function. In other words, in this particular setting, applying the zero constant to any input yields the zero value of the space.

For any topological space `α` and pseudo metric space `β` with defined zero, the constant function `0 : α → β` equals the zero function.


theorem Fin.pred_succ : ∀ {n : ℕ} (i : Fin n) {h : Fin.succ i ≠ 0}, Fin.pred (Fin.succ i) h = i := by sorry

The theorem `Fin.pred_succ` states that for every natural number `n` and every `i` in `Fin n`, when the successor of `i` is not zero, its predecessor is `i` itself. This essentially formalizes a property about how incrementing (`Fin.succ`) and decrementing (`Fin.pred`) interact in the context of the type `Fin n`, which represents the set `{0, 1, ..., n-1}`.

For all natural numbers `n` and `i` in `Fin n` with `Fin.succ i ≠ 0`, `Fin.pred (Fin.succ i) = i`.


theorem or_imp : ∀ {a b c : Prop}, a ∨ b → c ↔ (a → c) ∧ (b → c) := by sorry

This theorem, named `or_imp`, states that for any three propositions `a`, `b`, and `c`, the implication that either `a` or `b` implies `c` is logically equivalent to both `a` implies `c` and `b` implies `c`. In other words, if `c` follows from either `a` or `b`, then `c` must follow from `a` and must also follow from `b`.

The theorem `or_imp` asserts that for all propositions `a`, `b`, and `c`, `(a → c) ∧ (b → c)` is logically equivalent to `(a ∨ b) → c`.


theorem Real.Angle.coe_add : ∀ (x y : ℝ), ↑(x + y) = ↑x + ↑y := by sorry

This theorem, `Real.Angle.coe_add`, states that for any two real numbers `x` and `y`, the angle of their sum is equal to the sum of their angles. In other words, it asserts that the operation of taking the angle is compatible with addition in the real numbers. Written in mathematical notation, this would be: for all real numbers `x` and `y`, the angle of `(x + y)` is equal to the angle of `x` plus the angle of `y`.

For all real numbers x and y, the angle of (x + y) is equal to the sum of the angles of x and y.


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

This theorem, `tsub_le_tsub`, states that for any preorder type `α` that is also an additive commutative semigroup and has subtraction, and is ordered with respect to subtraction, if `a ≤ b` and `c ≤ d`, then `a - d ≤ b - c`. In the context of the theorem, `a`, `b`, `c`, and `d` are elements of the type `α`, and `CovariantClass` is a class that expresses that addition `(fun x x_1 => x + x_1)` is monotonic with respect to the preorder `(fun x x_1 => x ≤ x_1)` on `α`. In simpler words, if `a` is less than or equal to `b`, and `c` is less than or equal to `d`, then the difference of `a` and `d` is less than or equal to the difference of `b` and `c`.

If `α` is a preorder type that is an additive commutative semigroup with subtraction and is ordered with respect to subtraction, then for all `a ≤ b` and `c ≤ d` in `α`, we have `a - d ≤ b - c`.


theorem Nat.gcd_one_right : ∀ (n : ℕ), Nat.gcd n 1 = 1 := by sorry

This theorem, `Nat.gcd_one_right`, states that for any natural number `n`, the greatest common divisor (GCD) of `n` and `1` is `1`. In other words, the greatest common divisor of any natural number and `1` is always `1` itself. This aligns with the general mathematical understanding that `1` is a divisor of every natural number.

The greatest common divisor of any natural number and 1 is 1.


theorem List.getLast_eq_get :
    ∀ {α : Type u_1} (l : List α) (h : l ≠ []), List.getLast l h = List.get l { val := List.length l - 1, isLt := ⋯ } :=
  by sorry

The theorem `List.getLast_eq_get` states that for any non-empty list `l` of elements of an arbitrary type `α`, the last element of `l` obtained using `List.getLast` is the same as the element obtained using `List.get` at the index `List.length l - 1`. Here, `List.length l - 1` is the index of the last element of the list, and we use a proof `isLt` that this index is indeed a valid index in the list.

For any non-empty list `l` of length `n` over an arbitrary type `α`, `List.getLast l` equals `List.get l (n - 1)`.


theorem Set.encard_singleton : ∀ {α : Type u_1} (e : α), Set.encard {e} = 1 := by sorry

This theorem states that for any element `e` of any type `α`, the cardinality of the set containing just that element (`{e}`) is 1. In mathematical terms, if we have a singleton set (a set containing exactly one element), the cardinality of that set is always 1, regardless of what the element is or its type. The function `Set.encard` is used to determine this cardinality.

For any type `α` and any element `e` of type `α`, the singleton set `{e}` has cardinality 1.


theorem Filter.map_comap_of_mem :
    ∀ {α : Type u} {β : Type v} {f : Filter β} {m : α → β}, Set.range m ∈ f → Filter.map m (Filter.comap m f) = f := by
  sorry

The theorem `Filter.map_comap_of_mem` states that for any types `α` and `β`, any filter `f` on `β`, and any function `m` from `α` to `β`, if the range of the function `m` is a member of the filter `f`, then mapping the function `m` over the comap of `m` and `f` is equal to the original filter `f`. In other words, this theorem shows a kind of 'undoing' property of the mapping and comapping operations: if the range of the mapping function is in the filter, then comapping and mapping in sequence effectively recovers the original filter.

For any filter `f` on type `β`, function `m` from `α` to `β`, and element `x` of `β` such that `m(x) ∈ f`, we have `m '' f = f`.


theorem div_mul_div_cancel' : ∀ {G : Type u_3} [inst : Group G] (a b c : G), a / b * (b / c) = a / c := by sorry

This theorem states that for any group `G` and any elements `a`, `b`, and `c` of `G`, the result of dividing `a` by `b`, and then multiplying that by the result of dividing `b` by `c`, is equal to the result of dividing `a` by `c`. This can be thought of as a type of "cancellation" rule for division and multiplication in groups. The theorem holds for any group, under the assumption that the group operation behaves as division does in the field of real numbers.

For any group `G` and elements `a`, `b`, and `c` in `G`, `(a / b) * (b / c) = a / c`.


theorem MeasureTheory.snorm_measure_zero :
    ∀ {α : Type u_1} {F : Type u_3} {p : ENNReal} [inst : NormedAddCommGroup F] [inst_1 : MeasurableSpace α]
      {f : α → F}, MeasureTheory.snorm f p 0 = 0 :=
  by sorry

This theorem states that for any type `α`, any normed additive commutative group `F`, and any extended nonnegative real number `p`, if we have a function `f` from `α` to `F`, then the `ℒp` seminorm of `f` with respect to the measure `0` is always `0`. In other words, if the measure of the space is zero, then the seminorm of any function on that space is also zero, regardless of the value of `p`.

For any type `α`, normed additive commutative group `F`, and extended nonnegative real number `p`, the `ℒp` seminorm of any function from `α` to `F` is zero when the measure of the domain is zero.


theorem measurable_iSup :
    ∀ {α : Type u_1} {δ : Type u_5} [inst : TopologicalSpace α] [inst_1 : MeasurableSpace α] [inst_2 : BorelSpace α]
      [inst_3 : MeasurableSpace δ] [inst_4 : ConditionallyCompleteLinearOrder α] [inst_5 : OrderTopology α]
      [inst : SecondCountableTopology α] {ι : Sort u_6} [inst : Countable ι] {f : ι → δ → α},
      (∀ (i : ι), Measurable (f i)) → Measurable fun b => ⨆ i, f i b :=
  by sorry

The theorem `measurable_iSup` states that for any type `α` that is a topological space and measurable space, given that `α` also has a Borel space, a conditionally complete linear order, an order topology, and a second countable topology, and for any type `δ` that is a measurable space, and for any sort `ι` that is countable, if we have a family of functions `f : ι → δ → α`, where each function in the family is measurable, then the function that maps each `b` in `δ` to the supremum (expressed as `⨆ i, f i b`) of the set of values of `f i b` as `i` ranges over `ι` is also measurable. This means the preimage of every measurable set under this supremum function is measurable.

Given a topological space and measurable space `α` with a Borel space, a conditionally complete linear order, an order topology, and a second countable topology, and a countable family `f` of measurable functions from `δ` to `α`, the function mapping each `b` in `δ` to the supremum of `f i b` as `i` ranges over `ι` is measurable.


theorem Measurable.mul_const :
    ∀ {M : Type u_2} {α : Type u_3} [inst : MeasurableSpace M] [inst_1 : Mul M] {m : MeasurableSpace α} {f : α → M}
      [inst_2 : MeasurableMul M], Measurable f → ∀ (c : M), Measurable fun x => f x * c :=
  by sorry

The theorem `Measurable.mul_const` states that for any type `M` with a multiplication operation, any measurable space `M` and `α`, any measure preserving function `f` from `α` to `M`, and any constant `c` of type `M`, the function that sends `x` to the product of `f(x)` and `c` is also a measure preserving function. In other words, the multiplication of a measurable function by a constant maintains the measurability of the function.

If `f` is a measure-preserving function from a measurable space `(α, Σ, μ)` to a type `M` with multiplication, and `c` is a constant of type `M`, then the function `x ↦ f(x) * c` is also measure-preserving.


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

This theorem states that for any types `R` and `A`, given a commutative semiring structure on `R`, a semiring structure on `A`, and an algebra structure between `R` and `A`, if `S` is a subalgebra of `R` in `A`, then the product of any two elements `x` and `y` in `S` is also in `S`. In other words, the subalgebra `S` is closed under multiplication.

For any commutative semirings `R` and `A`, and an algebra homomorphism from `R` to `A`, if `S` is a subalgebra of `R` in `A`, then `S` is closed under multiplication.


theorem ENNReal.one_rpow : ∀ (x : ℝ), 1 ^ x = 1 := by sorry

This theorem states that for any real number `x`, the power of `1` raised to `x` is always `1`. In mathematical notation, if `x` is any real number, then `1^x = 1`. This is a basic theorem in the field of real number algebra, demonstrating that any power of `1` remains `1`.


theorem Set.diff_empty : ∀ {α : Type u} {s : Set α}, s \ ∅ = s := by sorry

This theorem states that for any set `s` of any type `α`, the difference of `s` with the empty set is `s` itself. In other words, if you subtract nothing (empty set) from a set, you get the original set back. Symbolically, this can be represented as `s \ ∅ = s` for any set `s`.

For any set `s` of type `α`, the set difference `s \ ∅` equals `s`.


theorem Filter.tendsto_iInf :
    ∀ {α : Type u} {β : Type v} {ι : Sort x} {f : α → β} {x : Filter α} {y : ι → Filter β},
      Filter.Tendsto f x (⨅ i, y i) ↔ ∀ (i : ι), Filter.Tendsto f x (y i) :=
  by sorry

The theorem `Filter.tendsto_iInf` states that for any types `α` and `β`, index type `ι`, function `f` from `α` to `β`, a filter `x` on `α`, and a indexed collection of filters `y` on `β`, the function `f` has the property of tending towards the infimum of the filters `y` (denoted by `(⨅ i, y i)`) if and only if it tends towards each individual filter in the collection `y`. In other words, the function `f` has the limit at each filter of the collection `y` if it has the limit at the infimum of these filters.

For any types `α` and `β`, index type `ι`, function `f` from `α` to `β`, filter `x` on `α`, and indexed collection of filters `y` on `β`, `f` tends towards the infimum of `y` if and only if it tends towards each `y_i`.


theorem Set.Ioc_subset_Ioi_self : ∀ {α : Type u_1} [inst : Preorder α] {a b : α}, Set.Ioc a b ⊆ Set.Ioi a := by sorry

This theorem states that for all types `α` equipped with a preorder, and for all elements `a` and `b` of type `α`, the left-open right-closed interval from `a` to `b` (denoted as `Set.Ioc a b`) is included in the left-open right-infinite interval starting from `a` (denoted as `Set.Ioi a`). In other words, any element `x` that is strictly greater than `a` and less than or equal to `b` is also strictly greater than `a` with no upper bound, hence the interval `(a, b]` is a subset of the interval `(a, ∞)`.

For all types `α` with a preorder and all `a : α` and `b : α` with `a < b`, the left-open right-closed interval `Set.Ioc a b` is a subset of the left-open right-infinite interval `Set.Ioi a`.


theorem Mathlib.Algebra.Order.Group.Abs._auxLemma.15 :
    ∀ {α : Type u_1} [inst : LinearOrderedAddCommGroup α] {a : α}, (|a| = a) = (0 ≤ a) := by sorry

This theorem, from the `Mathlib.Algebra.Order.Group` library in Lean 4, states that for any arbitrary type `α` which is a `LinearOrderedAddCommGroup` - a group structure on addition with an order that is both linear and compatible with the addition operation, the absolute value of an element `a` from `α` is equal to `a` itself if and only if `a` is greater than or equal to zero. In mathematical terms, it states that for any `a` in `α`, `|a| = a` if and only if `a ≥ 0`.

For any type `α` being a `LinearOrderedAddCommGroup`, the absolute value of an element `a` equals `a` if and only if `a` is non-negative.


theorem CategoryTheory.Adjunction.unit_naturality :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂}
      [inst_1 : CategoryTheory.Category.{v₂, u₂} D] {F : CategoryTheory.Functor C D} {G : CategoryTheory.Functor D C}
      (adj : F ⊣ G) {X Y : C} (f : X ⟶ Y),
      CategoryTheory.CategoryStruct.comp (adj.unit.app X) (G.map (F.map f)) =
        CategoryTheory.CategoryStruct.comp f (adj.unit.app Y) :=
  by sorry

This theorem, `CategoryTheory.Adjunction.unit_naturality`, states that for any two categories `C` and `D`, with functors `F` from `C` to `D` and `G` from `D` to `C` forming an adjunction denoted by `adj`, and for any two objects `X` and `Y` in category `C` with a morphism `f` from `X` to `Y`, the composition of the unit of the adjunction at `X` and the map from `G` applied to the map from `F` applied to `f`, is equal to the composition of `f` and the unit of the adjunction at `Y`.

In simpler terms, it shows the naturality of the unit of an adjunction in the context of category theory.

For any adjunction between categories `C` and `D` given by functors `F: C -> D` and `G: D -> C`, and for any objects `X, Y in C` and morphism `f: X -> Y`, the units `ηx: X -> F(X)` and `ηy: Y -> G(Y)` satisfy `F(f) ∘ ηx = ηy ∘ f`.


/-- By definition, the uniformity of `α →ᵤ β` admits the family `{(f, g) | ∀ x, (f x, g x) ∈ V}`
for `V ∈ 𝓤 β` as a filter basis.  -/
theorem UniformFun.hasBasis_uniformity :
    ∀ (α : Type u_1) (β : Type u_2) [inst : UniformSpace β],
      Filter.HasBasis (uniformity (UniformFun α β)) (fun x => x ∈ uniformity β) (UniformFun.gen α β) :=
  by sorry

This theorem states that for any types `α` and `β`, where `β` is a uniform space, the uniformity of the function type `α →ᵤ β` has a filter basis. This filter basis is characterized by sets of pairs `(f, g)` of functions from `α` to `β`, such that for every `x` in `α`, the pair `(f x, g x)` belongs to a given set `V`. Here, `V` is drawn from the uniformity of `β`. In simpler terms, it establishes a uniform convergence structure on the space of functions from `α` to `β`, with convergence being measured with respect to the uniform structure on `β`.

For any type `α` and uniform space `β`, the uniformity of the function type `α → β` has a filter basis characterized by sets of pairs of functions `(f, g)` such that `(fx, gx)` belongs to some set in the uniformity of `β` for all `x` in `α`.