theorem MvPolynomial.degreeOf_def :
    ∀ {R : Type u} {σ : Type u_1} [inst : CommSemiring R] [inst_1 : DecidableEq σ] (n : σ) (p : MvPolynomial σ R),
      MvPolynomial.degreeOf n p = Multiset.count n (MvPolynomial.degrees p) :=
  by sorry

The theorem `MvPolynomial.degreeOf_def` states that for any commutative semiring `R`, any type `σ`, any element `n` of type `σ`, and any multivariate polynomial `p` with variables of type `σ` and coefficients in `R`, the degree of the variable `n` in `p` is equal to the count of `n` in the multiset of degrees of `p`. In mathematical terms, if `p` is a multivariate polynomial over a commutative semiring, the highest degree of a variable `n` in `p` is the same as the multiplicity of `n` in the multiset of all degrees of `p`.

For any multivariate polynomial `p` over a commutative semiring, the degree of a variable `n` in `p` equals the multiplicity of `n` in the multiset of degrees of `p`.


theorem Finsupp.support_zero : ∀ {α : Type u_1} {M : Type u_5} [inst : Zero M], 0.support = ∅ := by sorry

This theorem states that for any type `α` and `M`, where `M` has a zero element, the support of the zero function (represented as 0) is an empty set. In other words, there are no elements `α` for which the zero function gives a non-zero value in `M`.

For any type `α` and additive monoid `M` with zero element, the zero function maps all elements of `α` to the zero element in `M`, implying its support is the empty set.


theorem Ordinal.sup_eq_bsup :
    ∀ {o : Ordinal.{u}} (f : (a : Ordinal.{u}) → a < o → Ordinal.{max u v}),
      Ordinal.sup (Ordinal.familyOfBFamily o f) = Ordinal.bsup o f :=
  by sorry

The theorem `Ordinal.sup_eq_bsup` states that for any ordinal `o` and any function `f` from ordinals less than `o` to ordinals, the supremum of the family of ordinals obtained by applying `f` to the elements of the well-ordered set corresponding to `o` (obtained via `Ordinal.familyOfBFamily`) is equal to the supremum of the family of ordinals indexed by the set of ordinals less than `o` (obtained via `Ordinal.bsup`). In other words, the result of applying the supremum operation to the family of ordinals indexed by a well-ordered set is the same as applying the supremum operation to the family of ordinals indexed by the ordinals less than a given ordinal. This shows an equivalence between two ways of computing a supremum over a family of ordinals.

For any ordinal `o` and function `f` from ordinals less than `o` to ordinals, the supremum of `Ordinal.familyOfBFamily o f` equals `Ordinal.bsup (range o) (map f (range (O < o)))`.


theorem associated_mul_unit_right : ∀ {β : Type u_5} [inst : Monoid β] (a u : β), IsUnit u → Associated a (a * u) := by
  sorry

The theorem `associated_mul_unit_right` states that for any type `β` that has a `Monoid` structure, and for any elements `a` and `u` of `β`, if `u` is a unit (meaning it has a two-sided inverse), then `a` is `Associated` with `a * u`. In mathematical terms, this means there exists some unit `u` such that `a * u` equals to `a`, hence `a` is associated with `a * u`. This essentially says that the multiplication of any element by a unit doesn't change its association class in the monoid.

For any monoid `β` and elements `a` and `u` in `β` with `u` being a unit, `a` is associated with `a * u`.


theorem Mathlib.Data.Int.ModEq._auxLemma.2 : ∀ {m n k : ℤ}, (m % n = k % n) = ((m - k) % n = 0) := by sorry

This is a theorem about modular arithmetic for integers. It states that for any three integers `m`, `n`, and `k`, `m` is congruent to `k` modulo `n` (that is, `m` and `k` have the same remainder when divided by `n`) if and only if the difference `m - k` is divisible by `n` (that is, `m - k` modulo `n` is zero). This theorem is a key result in number theory and serves as a fundamental concept in modular arithmetic.

For integers m, n, and k, m is congruent to k modulo n if and only if m - k is divisible by n.


theorem Mathlib.Data.Int.ModEq._auxLemma.3 : ∀ (a b : ℤ), (a ∣ b) = (b % a = 0) := by sorry

This theorem states that for any two integers `a` and `b`, `a` divides `b` if and only if the remainder of the division of `b` by `a` is zero. In other words, if `b` divided by `a` leaves no remainder (i.e., `b % a = 0`), then `a` is a factor of `b`. Conversely, if `a` is a factor of `b`, then `b` divided by `a` will leave no remainder.

For integers `a` and `b`, `a` divides `b` if and only if the remainder of `b` divided by `a` is zero.


theorem List.nthLe_of_mem :
    ∀ {α : Type u} {a : α} {l : List α}, a ∈ l → ∃ n, ∃ (h : n < List.length l), List.nthLe l n h = a := by sorry

This theorem states that for any list `l` of elements of some type `α`, and any element `a` of the same type, if `a` is an element of `l` (denoted as `a ∈ l`), then there exists an index `n` such that `n` is less than the length of the list, and the `n`-th element of the list (obtained using the `List.nthLe` function) is `a`. In essence, the theorem provides a guarantee that if an element is in the list, then we can find its position within the list.

For any list `l` of length `n+1` over type `α`, and any `a ∈ α`, there exists an index `i` < `n` such that `l.get! i = a`. (Here, `get!` is the function provided by Lean's standard library to access an element of a list by index.)


theorem Mathlib.Data.ZMod.Basic._auxLemma.7 : ∀ {m n k : ℕ}, (Nat.lcm m n ∣ k) = (m ∣ k ∧ n ∣ k) := by sorry

The theorem `Mathlib.Data.ZMod.Basic._auxLemma.7` states that for all natural numbers `m`, `n`, and `k`, the least common multiple (lcm) of `m` and `n` divides `k` if and only if both `m` and `n` divide `k`. In other words, the lcm of two numbers `m` and `n` is a divisor of a number `k` precisely when both `m` and `n` are divisors of `k`.

The least common multiple of natural numbers $m$ and $n$ is a divisor of a natural number $k$ if and only if both $m$ and $n$ are divisors of $k$.


theorem ContinuousWithinAt.tendsto_nhdsWithin_image :
    ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] {f : α → β} {x : α}
      {s : Set α}, ContinuousWithinAt f s x → Filter.Tendsto f (nhdsWithin x s) (nhdsWithin (f x) (f '' s)) :=
  by sorry

The theorem `ContinuousWithinAt.tendsto_nhdsWithin_image` states that for all types `α` and `β` that are topological spaces, given a function `f` from `α` to `β`, a point `x` in `α`, and a subset `s` of `α`, if `f` is continuous at `x` within `s`, then `f` has the property that for every neighborhood of `f(x)` that intersects with the image of `s` under `f`, the pre-image of this neighborhood under `f` is a neighborhood of `x` within `s`. In other words, as `x` tends to `f(x)` while staying within `s`, `f(x)` tends to `f` of the image of `s`. This is a formalization in Lean 4 of the standard mathematical concept of a function being continuous at a point within a subset.

If a function between topological spaces is continuous at a point within a subset, then for every neighborhood of the image of that point intersecting the image of the subset, the pre-image under the function is a neighborhood of the original point within the subset.


theorem Mathlib.Data.PEquiv._auxLemma.5 : ∀ {α : Type u_1} {a : α} {b : Option α}, (a ∈ b) = (b = some a) := by sorry

This theorem, `Mathlib.Data.PEquiv._auxLemma.5`, asserts that for any type `α` and any element `a` of that type, as well as any `Option` of `α` named `b`, the statement "a is in b" is equivalent to the statement "b is equal to `some a`". In other words, an element `a` is contained in an `Option` `b` if and only if `b` is `some a` in the context of optional values in the type `α`.

For any type `α` and `a : α`, the option `b : Option α` contains `a` if and only if `b` is `some a`.


theorem Set.preimage_const_add_Ici :
    ∀ {α : Type u_1} [inst : OrderedAddCommGroup α] (a b : α), (fun x => a + x) ⁻¹' Set.Ici b = Set.Ici (b - a) := by
  sorry

This theorem states that for any ordered additive commutative group `α` and any elements `a` and `b` of `α`, the preimage of the set of all elements `x` in `α` such that `b` is less than or equal to `a + x` under the function that maps `x` to `a + x` is the set of all elements `x` in `α` such that `b - a` is less than or equal to `x`. In more mathematical terms, for any `a` and `b` in some ordered additive commutative group, the preimage of the interval `[b, ∞)` under the function `f(x) = a + x` is the interval `[b - a, ∞)`.

For any ordered additive commutative group `α` and elements `a, b` in `α`, the preimage of the interval `[b, ∞)` under the function `x mapsto a + x` is the interval `[b - a, ∞)`.


theorem Basis.groupSMul_span_eq_top :
    ∀ {ι : Type u_1} {R : Type u_3} {M : Type u_6} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M]
      {G : Type u_10} [inst_3 : Group G] [inst_4 : DistribMulAction G R] [inst_5 : DistribMulAction G M]
      [inst_6 : IsScalarTower G R M] {v : ι → M},
      Submodule.span R (Set.range v) = ⊤ → ∀ {w : ι → G}, Submodule.span R (Set.range (w • v)) = ⊤ :=
  by sorry

The theorem `Basis.groupSMul_span_eq_top` states that for any types `ι`, `R`, `M`, and `G` where `R` is a ring, `M` is an additive commutative group and is a module over `R`, `G` is a group which acts distributively on `R` and `M`, and where the action of `G` on `R` is extendable to `M`, given a function `v : ι → M` such that the span of the range of `v` covers the whole space (`⊤`), then for any function `w : ι → G`, the span of the range of the scalar multiplication `w • v` also covers the whole space (`⊤`). In other words, if the vectors obtained by the function `v` span the whole space, then the vectors obtained by scalarly multiplying the vectors obtained from `v` by the elements from function `w` also span the whole space.

If `v : ι → M` spans `M`, then for any `w : ι → G` where `G` acts linearly on `M` over a ring `R`, the scalars `{w x | x ∈ ι}` together with the span of `v` span the whole of `M`.


theorem Function.mulSupport_const :
    ∀ {α : Type u_1} {M : Type u_5} [inst : One M] {c : M}, c ≠ 1 → (Function.mulSupport fun x => c) = Set.univ := by
  sorry

The theorem `Function.mulSupport_const` states that for any types `α` and `M` with `M` having an instance of the `One` typeclass, and any element `c` of `M` that is not equal to `1`, the `mulSupport` of a constant function `f` that always returns `c` is equivalent to the universal set over `α`. In other words, every element `x` of type `α` is such that `f(x)` (which is always `c`) is not equal to `1`.

For any type `α` and constant function `f : α → M` with `M` being an instance of `One` and `c ≠ 1` in `M`, the support of `f` (as a function from `α` to `{1, ≠1}`) equals the universal set `α`.


theorem isClosed_tsupport :
    ∀ {X : Type u_1} {α : Type u_2} [inst : Zero α] [inst_1 : TopologicalSpace X] (f : X → α), IsClosed (tsupport f) :=
  by sorry

The theorem `isClosed_tsupport` states that for any type `X` endowed with a topological space structure, and for any type `α` that has a zero element, the topological support (i.e., the closure of the set of all points where the function is nonzero) of any function `f` from `X` to `α` is a closed set in `X`. In other words, if you have a function that maps points in a topological space to values which include a concept of 'zero', the set of points where the function isn't 'zero' and all of its limit points make up a closed set.

For any function $f$ from a topological space $X$ to a type with a zero element, the topological support of $f$ is a closed set in $X$.


theorem Nat.mul_add_mod : ∀ (m x y : ℕ), (m * x + y) % m = y % m := by sorry

This theorem states that for any three natural numbers `m`, `x`, and `y`, the modulus of the sum of `m` multiplied by `x` and `y` with respect to `m` is equal to the modulus of `y` with respect to `m`. In other words, the remainder of dividing `(m * x + y)` by `m` is the same as the remainder of dividing `y` by `m`. This is an important property of modular arithmetic.

For any natural numbers `m`, `x`, and `y`, `(m * x + y) % m = y % m`.


theorem LinearMap.map_smul₂ :
    ∀ {R : Type u_1} [inst : Semiring R] {S : Type u_2} [inst_1 : Semiring S] {S₂ : Type u_4} [inst_2 : Semiring S₂]
      {M₂ : Type u_8} {N₂ : Type u_9} {P₂ : Type u_10} [inst_3 : AddCommMonoid M₂] [inst_4 : AddCommMonoid N₂]
      [inst_5 : AddCommMonoid P₂] [inst_6 : Module R M₂] [inst_7 : Module S N₂] [inst_8 : Module R P₂]
      [inst_9 : Module S₂ P₂] [inst_10 : SMulCommClass S₂ R P₂] {σ₁₂ : S →+* S₂} (f : M₂ →ₗ[R] N₂ →ₛₗ[σ₁₂] P₂) (r : R)
      (x : M₂) (y : N₂), (f (r • x)) y = r • (f x) y :=
  by sorry

This theorem, named `LinearMap.map_smul₂`, states that for any semirings `R`, `S`, and `S₂`, types `M₂`, `N₂`, and `P₂` that are additively commutative monoids and modules over `R`, `S`, or `S₂` respectively, and a smul commutative class of `S₂`, `R` and `P₂`, given a certain linear map `f` from `M₂` to a function from `N₂` to `P₂`, a scalar `r` from `R`, and elements `x` from `M₂` and `y` from `N₂`, the result of applying `f` to the scalar multiplication of `r` and `x` and then applying the result to `y` is equal to the scalar multiplication of `r` and the result of applying `f` to `x` and then applying the result to `y`. This is essentially a property of linear maps related to scalar multiplication.

For linear maps `f` from an additively commutative monoid `M₂` to the function space from an additively commutative monoid `N₂` to a module `P₂` over a semiring `R`, and for any scalars `r` in `R` and elements `x` in `M₂` and `y` in `N₂`, the law of scalar multiplication holds: `f(rx)(y) = r(fx)(y)`.


theorem MeasureTheory.ae_restrict_biUnion_eq :
    ∀ {α : Type u_2} {ι : Type u_6} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} (s : ι → Set α) {t : Set ι},
      Set.Countable t →
        MeasureTheory.Measure.ae (μ.restrict (⋃ i ∈ t, s i)) = ⨆ i ∈ t, MeasureTheory.Measure.ae (μ.restrict (s i)) :=
  by sorry

This theorem, `MeasureTheory.ae_restrict_biUnion_eq`, states that for any type `α`, any index type `ι`, any measurable space `m0` over `α`, any measure `μ` on `α`, and any function `s` from `ι` to sets of `α`, if we have a countable set `t` of `ι`, then the almost everywhere filter of the measure restricted to the union of sets `s i` for `i` in `t` is equal to the supremum of the almost everywhere filters of the measures restricted to each `s i` for `i` in `t`.

In other words, considering "almost everywhere" in the context of a measure restricted to a countable union of sets is the same as considering it separately for each set in the union and then taking the supremum of the results.

For any measurable space `(α, Σ, m)`, measure `μ`, countable index set `ι`, and function `s : ι → Σ`, the almost everywhere filter of `μ` restricted to the countable union of `s i` equals the supremum of the almost everywhere filters of `μ` restricted to each `s i`.


theorem Finset.extract_gcd :
    ∀ {α : Type u_1} {β : Type u_2} [inst : CancelCommMonoidWithZero α] [inst_1 : NormalizedGCDMonoid α] {s : Finset β}
      (f : β → α), s.Nonempty → ∃ g, (∀ b ∈ s, f b = Finset.gcd s f * g b) ∧ Finset.gcd s g = 1 :=
  by sorry

The theorem `Finset.extract_gcd` states that for any nonempty finite set `s` of elements of type `β` and a function `f` from `β` to `α`, where `α` is a type with the structure of a cancel commutative monoid with zero and a normalized greatest common divisor (GCD) monoid, there exists a function `g` such that for all elements `b` in `s`, `f(b)` equals the GCD of the set `s` (with respect to the function `f`) times `g(b)`, and the GCD of the set `s` with respect to the function `g` is 1. This theorem essentially says that we can always extract a factor that turns the GCD of the original function to 1, essentially "normalizing" the function `f` by this factor.

Given a nonempty finite set `s` of elements from a type `β` and a function `f` from `β` to a cancellative commutative monoid `α` with a normalized greatest common divisor, there exists a function `g` such that for all `b` in `s`, `f(b)` equals the GCD of `s` with respect to `f` times `g(b)`, and the GCD of `s` with respect to `g` is 1.


theorem Matrix.J_squared :
    ∀ (l : Type u_1) (R : Type u_2) [inst : DecidableEq l] [inst_1 : CommRing R] [inst_2 : Fintype l],
      Matrix.J l R * Matrix.J l R = -1 :=
  by sorry

The theorem `Matrix.J_squared` states that for any type `l`, any type `R` which is a commutative ring, when `l` has decidable equality and is finite, the square of the matrix `J` (which is defined as the canonical skew-symmetric bilinear form) is equal to `-1`. Here, `Matrix.J l R` is a matrix whose elements are of type `R`, and the matrix is defined using the direct sum of type `l`. The multiplication `*` represents the matrix multiplication. The result `-1` is an element of the commutative ring `R`.

For any finite, decidably equal commutative ring `R` and finite type `l`, the square of the canonical skew-symmetric matrix `J : Matrix R l` is equal to the negative identity matrix `-1 : Matrix R l`.


theorem List.rdropWhile_concat :
    ∀ {α : Type u_1} (p : α → Bool) (l : List α) (x : α),
      List.rdropWhile p (l ++ [x]) = if p x = true then List.rdropWhile p l else l ++ [x] :=
  by sorry

The theorem `List.rdropWhile_concat` states that, for any type `α`, a predicate function `p` from `α` to `Bool`, a list `l` of elements of type `α`, and an element `x` of type `α`, the function `List.rdropWhile` applied to the list obtained by concatenating `l` and a singleton list containing `x` is equal to: if the predicate `p` applied to `x` is `true`, then `List.rdropWhile p l`, otherwise the list obtained by concatenating `l` and the singleton list containing `x`. In essence, it says that if the last element of the list satisfies the predicate, it will be dropped, otherwise the list remains the same after applying `List.rdropWhile`.

For any type `α`, list `l` of length `n+1` in `α`, predicate `p : α → Bool`, and `x ∈ α`, if `p(x)` then `List.rdropWhile p (l ++ [x]) = List.rdropWhile p l`, otherwise `List.rdropWhile p (l ++ [x]) = l ++ [x]`.


theorem Set.preimage_const_add_Iio :
    ∀ {α : Type u_1} [inst : OrderedAddCommGroup α] (a b : α), (fun x => a + x) ⁻¹' Set.Iio b = Set.Iio (b - a) := by
  sorry

This theorem states that for any ordered additive commutative group `α`, and any two elements 'a' and 'b' of this group, the preimage of the set of elements less than 'b' under the function that adds 'a' to each element is the set of elements less than 'b - a'. In other words, if we shift each element of 'α' by 'a' to the right, the elements that were less than 'b' before the shift are precisely those that are less than 'b - a' after the shift.

For any ordered additive commutative group `α` and elements `a, b` of `α`, the set `{x : α | x < b}` is equal to the set `{x : α | x + a < b}`.


theorem zpow_inj :
    ∀ {α : Type u_1} [inst : LinearOrderedSemifield α] {a : α} {m n : ℤ}, 0 < a → a ≠ 1 → (a ^ m = a ^ n ↔ m = n) := by
  sorry

This theorem states that for any linearly ordered semiring `α` and any two integers `m` and `n`, if `a` is a positive element of `α` which is not equal to 1, then `a` raised to the power of `m` is equal to `a` raised to the power of `n` if and only if `m` is equal to `n`. In mathematical terms, given $a \in \alpha$, $a > 0$, $a \neq 1$, and any two integers $m$ and $n$, it holds that $a^m = a^n$ if and only if $m = n$.

For any linearly ordered semiring `α` and positive element `a ≠ 1` in `α`, the power `a^m` equals `a^n` if and only if integers `m` and `n` are equal.


theorem Set.preimage_const_add_Iic :
    ∀ {α : Type u_1} [inst : OrderedAddCommGroup α] (a b : α), (fun x => a + x) ⁻¹' Set.Iic b = Set.Iic (b - a) := by
  sorry

The theorem `Set.preimage_const_add_Iic` states that for any ordered additive commutative group `α` and any elements `a` and `b` of `α`, the preimage of the left-infinite right-closed interval ending at `b` under the function that adds `a` to its input is the left-infinite right-closed interval ending at `b - a`. In other words, shifting all points in the interval down by `a` has the effect of moving the endpoint of the interval from `b` to `b - a`.

For any ordered additive commutative group (α, +) and elements a, b of α, the preimage of the left-infinite right-closed interval Ic[b] under the function x ↦ x + a is equal to Ic[b - a].


/-- If there is a homomorphism `f : α →+* β` and `β` is nontrivial, then `α` is nontrivial.  -/
theorem RingHom.domain_nontrivial :
    ∀ {α : Type u_2} {β : Type u_3} {x : NonAssocSemiring α} {x_1 : NonAssocSemiring β},
      (α →+* β) → ∀ [inst : Nontrivial β], Nontrivial α :=
  by sorry

This theorem states that if there exists a ring homomorphism, denoted by `f`, from a type `α` to a type `β` and `β` is nontrivial (i.e., it contains at least two distinct elements), then `α` must also be nontrivial. In other words, you cannot have a homomorphism from a trivial ring to a nontrivial one. Here, `α` and `β` are types with a Non-Associative Semiring structure, which is a mathematical structure that includes operations like addition and multiplication but does not require the multiplication to be associative.

If `α` is a Non-Associative Semiring and there exists a homomorphism from `α` to a nontrivial `β` (Non-Associative Semiring), then `α` is also nontrivial.


theorem Filter.map_comm :
    ∀ {α : Type u} {β : Type v} {γ : Type w} {δ : Type u_1} {φ : α → β} {θ : α → γ} {ψ : β → δ} {ρ : γ → δ},
      ψ ∘ φ = ρ ∘ θ → ∀ (F : Filter α), Filter.map ψ (Filter.map φ F) = Filter.map ρ (Filter.map θ F) :=
  by sorry

This theorem states that for any types `α`, `β`, `γ`, and `δ`, and any functions `φ` from `α` to `β`, `θ` from `α` to `γ`, `ψ` from `β` to `δ`, and `ρ` from `γ` to `δ`, if the composition of `ψ` and `φ` is equal to the composition of `ρ` and `θ`, then for any filter `F` on `α`, the result of mapping `F` through `φ` and then `ψ` is the same as the result of mapping `F` through `θ` and then `ρ`. In other words, if two pairs of functions are equivalent when composed, they induce the same transformation on filters.

If for functions `φ: α → β`, `θ: α → γ`, `ψ: β → δ`, and `ρ: γ → δ` hold that `ψ ∘ φ = ρ ∘ θ`, then for any filter `F` on `α`, `map (φ ∘ ψ) F = map (θ ∘ ρ) F`.


theorem Mathlib.Data.Set.Image._auxLemma.2 : ∀ {α : Sort u_1} {a b : α}, (a = b) = (b = a) := by sorry

This theorem states that for any type `α` and any two entities `a` and `b` of type `α`, the proposition that `a` equals `b` is equivalent to the proposition that `b` equals `a`. This is a fundamental property of equality, which asserts that equality is a symmetric relation. In other words, if `a` equals `b`, then `b` also equals `a`.

For any type `α` and any `a, b : α`, `a = b` is equivalent to `b = a`.


theorem Finset.set_biUnion_insert :
    ∀ {α : Type u_2} {β : Type u_3} [inst : DecidableEq α] (a : α) (s : Finset α) (t : α → Set β),
      ⋃ x ∈ insert a s, t x = t a ∪ ⋃ x ∈ s, t x :=
  by sorry

This theorem states that for any type `α` and `β` with `α` having decidable equality, given an element `a` of type `α`, a finite set `s` of `α`, and a function `t` mapping elements of `α` to sets of `β`, the union over all elements in the set obtained by inserting `a` into `s` under the function `t` is equivalent to the union of the set under the function `t` at `a` and the union over all elements in `s` under the function `t`. In other words, the process of union over a set doesn't change if we extract one element and perform the union separately.

For any type `α` with decidable equality, given an element `a` of type `α`, a finite set `s` of `α`, and a function `t` mapping elements of `α` to sets of `β`, the set `(s.insert a).map t |>.union <| t a |>.union s.map t` equals `t a |>.union (s.map t)`.


theorem Set.preimage_const_add_Ioi :
    ∀ {α : Type u_1} [inst : OrderedAddCommGroup α] (a b : α), (fun x => a + x) ⁻¹' Set.Ioi b = Set.Ioi (b - a) := by
  sorry

The theorem `Set.preimage_const_add_Ioi` states that for any ordered additive commutative group `α` and any elements `a` and `b` in `α`, the preimage of the set of all elements greater than `b` under the function `x => a + x` is equal to the set of all elements greater than `b - a`. In simpler terms, if you add a constant `a` to every element in the group and then take all the elements greater than `b`, it's the same as if you just took all the group elements greater than `b - a` to begin with.

For any ordered additive commutative group `α` and elements `a, b` in `α`, `(a +)⁻¹'{x : α | x > b} = {x : α | x > b - a}`.


theorem MvPowerSeries.coeff_X :
    ∀ {σ : Type u_1} {R : Type u_2} [inst : Semiring R] [inst_1 : DecidableEq σ] (n : σ →₀ ℕ) (s : σ),
      (MvPowerSeries.coeff R n) (MvPowerSeries.X s) = if n = fun₀ | s => 1 then 1 else 0 :=
  by sorry

This theorem states that for any semiring `R` and type `σ`, with decidable equality on `σ`, and any given multivariate formal power series coefficient function `n` and a variable `s` of the power series, the `n`th coefficient of the variable `s` in the multivariate formal power series is 1 if `n` matches the function that returns 1 for `s` and 0 otherwise. In other words, it specifies the coefficients of the variables in a multivariate formal power series over a semiring.

For any semiring `R` with decidable equality and type `σ`, the multivariate formal power series coefficient function `n` of a variable `s` equals 1 in `R` if `n` is the function that returns 1 for `s`, and 0 otherwise.


theorem Set.Icc.coe_pow : ∀ {α : Type u_1} [inst : OrderedSemiring α] (x : ↑(Set.Icc 0 1)) (n : ℕ), ↑(x ^ n) = ↑x ^ n :=
  by sorry

This theorem states that for any type `α` which is an ordered semiring, and any element `x` in the closed interval from 0 to 1 of type `α`, the `n`-th power of `x` (where `n` is a natural number) is equal to `x` raised to the power `n`. Note that the elements `x` and `x^n` are both in the interval from 0 to 1, evidenced by the fact that they are taken as elements of the set `Set.Icc 0 1`. The `↑` symbol in the theorem denotes the coercion from the set `Set.Icc 0 1` to the type `α`.

For any ordered semiring type `α` and element `x` in the closed interval `[0, 1]` of type `α`, the `n`-th power of `x` equals `x` raised to the power `n`.


theorem Polynomial.degree_X_le : ∀ {R : Type u} [inst : Semiring R], Polynomial.degree Polynomial.X ≤ 1 := by sorry

The theorem `Polynomial.degree_X_le` states that for any semiring `R`, the degree of the polynomial `Polynomial.X` is less than or equal to 1. In essence, this theorem asserts that the degree of the polynomial variable, denoted as `X`, is always 1 or less in any given semiring. Here, `Polynomial.X` represents a polynomial with a single term of degree 1, which is why its degree cannot be more than 1.

For any semiring R, the degree of the polynomial variable X in the context of the Polynomial type is at most 1.


/-- For any multiplicative function `f` with `f 1 = 1` and any `n ≠ 0`,
we can evaluate `f n` by evaluating `f` at `p ^ k` over the factorization of `n`  -/
theorem Nat.multiplicative_factorization :
    ∀ {β : Type u_1} [inst : CommMonoid β] (f : ℕ → β),
      (∀ (x y : ℕ), Nat.Coprime x y → f (x * y) = f x * f y) →
        f 1 = 1 → ∀ {n : ℕ}, n ≠ 0 → f n = Finsupp.prod (Nat.factorization n) fun p k => f (p ^ k) :=
  by sorry

The theorem `Nat.multiplicative_factorization` states that for a given multiplicative function `f` which satisfies `f 1 = 1`, and for any natural number `n` not equal to zero, the value of `f n` can be computed by evaluating `f` at `p ^ k` over the factorization of `n`. Here, `p ^ k` represents the prime factors of `n` raised to their corresponding multiplicities in `n`. This is true provided that `f` satisfies the condition that for any two numbers `x` and `y` that are coprime, `f (x * y)` equals `f x * f y`. This theorem essentially describes how a multiplicative function behaves with respect to the prime factorization of a number.

For any multiplicative function $f$ with $f(1) = 1$ and natural number $n \neq 0$, $f(n) = \prod\_{p \mid n} f(p)^{k\_p}$, where $p$ ranges over prime factors of $n$ and $k\_p$ is their multiplicity. Given $f(x) = f(y)$ for coprime $x, y$, this expression holds.


theorem Real.log_le_log : ∀ {x y : ℝ}, 0 < x → x ≤ y → Real.log x ≤ Real.log y := by sorry

This theorem states that for any two real numbers `x` and `y`, if `x` is positive and `x` is less than or equal to `y`, then the logarithm of `x` is less than or equal to the logarithm of `y`. In other words, the real logarithm function `Real.log` is non-decreasing for positive inputs.

For all real numbers `x` and `y` with `x > 0`, if `x <= y`, then `Real.log x <= Real.log y`.


theorem connectedComponent_eq_singleton :
    ∀ {α : Type u} [inst : TopologicalSpace α] [inst_1 : TotallyDisconnectedSpace α] (x : α),
      connectedComponent x = {x} :=
  by sorry

This theorem states that for any point `x` in a totally disconnected topological space, the connected component of `x` is just the singleton set containing `x` itself. In other words, in a totally disconnected space, each point forms its own separate connected component, as there are no connections between different points.

In a totally disconnected topological space, each point is the connected component of itself.


theorem Mathlib.Topology.ContinuousFunction.Ideals._auxLemma.1 :
    ∀ {X : Type u_1} {R : Type u_2} [inst : TopologicalSpace X] [inst_1 : Semiring R] [inst_2 : TopologicalSpace R]
      [inst_3 : TopologicalSemiring R] {s : Set X} {f : C(X, R)},
      (f ∈ ContinuousMap.idealOfSet R s) = ∀ ⦃x : X⦄, x ∈ sᶜ → f x = 0 :=
  by sorry

The theorem states that for any topological space `X`, semiring `R` where `R` is also a topological space and a topological semiring, and for any set `s` of `X`, a function `f` from `X` to `R` is in the ideal of continuous functions that vanish on the complement of `s` if and only if for every element `x` in the complement of `s`, the value of `f` at `x` is zero. In other words, this theorem characterizes the membership of a function in the ideal of functions that vanish outside a given set in terms of the function's behavior on the complement of the set.

A function from a topological space to a topological semiring is in the ideal of continuous functions that vanish on the complement of a set if and only if it maps every point in the complement to zero.


theorem MeasureTheory.Submartingale.sum_mul_sub :
    ∀ {Ω : Type u_1} {m0 : MeasurableSpace Ω} {μ : MeasureTheory.Measure Ω} {𝒢 : MeasureTheory.Filtration ℕ m0}
      [inst : MeasureTheory.IsFiniteMeasure μ] {R : ℝ} {ξ f : ℕ → Ω → ℝ},
      MeasureTheory.Submartingale f 𝒢 μ →
        MeasureTheory.Adapted 𝒢 ξ →
          (∀ (n : ℕ) (ω : Ω), ξ n ω ≤ R) →
            (∀ (n : ℕ) (ω : Ω), 0 ≤ ξ n ω) →
              MeasureTheory.Submartingale (fun n => Finset.sum (Finset.range n) fun k => ξ k * (f (k + 1) - f k)) 𝒢 μ :=
  by sorry

This theorem states that for any measurable space `Ω`, filtration `𝒢` indexed by natural numbers on `Ω`, finite measure `μ` on `Ω`, and real number `R`, if a sequence of functions `f` is a submartingale with respect to `𝒢` and `μ`, and another sequence of functions `ξ` is adapted to `𝒢`, with each `ξ n ω` being nonnegative and less than or equal to `R`, then the sequence of functions defined by the sum (over `k` ranging from 0 to `n-1`) of the product of `ξ k` and the difference `f (k + 1) - f k` is also a submartingale with respect to `𝒢` and `μ`. In mathematical terms, this is saying that a weighted sum of differences of a submartingale is also a submartingale.

If `{f}` is a submartingale, `{ξ}` is an adapted sequence of nonnegative functions with `ξ n ω ≤ R` for all `n` and `ω`, then the sequence `{g_n}` defined by `g_n = ∑ⁱ₋₁ i=0 (ξ_i * (f_(i+1) - f_i))` is also a submartingale.


theorem Finset.prod_ite :
    ∀ {α : Type u_3} {β : Type u_4} [inst : CommMonoid β] {s : Finset α} {p : α → Prop} {hp : DecidablePred p}
      (f g : α → β),
      (Finset.prod s fun x => if p x then f x else g x) =
        (Finset.prod (Finset.filter p s) fun x => f x) * Finset.prod (Finset.filter (fun x => ¬p x) s) fun x => g x :=
  by sorry

The theorem `Finset.prod_ite` states that for any type `α` and a commutative monoid `β`, given a finite set `s` of type `α`, a decidable predicate `p`, and two functions `f, g` from `α` to `β`, the product of the set `s` where each element `x` is mapped to `f x` if `p x` is true and `g x` if `p x` is false, is equal to the product of the elements of the set that satisfy `p` mapped to `f x` times the product of the elements that do not satisfy `p` mapped to `g x`. In mathematical terms, we have $\prod_{x \in s} (if\ p(x)\ then\ f(x)\ else\ g(x)) = \prod_{x \in s,\ p(x)} f(x) * \prod_{x \in s,\ ¬p(x)} g(x)$.

For any commutative monoid β and finite set s of type α with a decidable predicate p and functions f, g from α to β, the product of s mapped to f using p is equal to the product of elements of s satisfying p mapped to f multiplied by the product of elements of s not satisfying p mapped to g: $\prod\_{x \in s} (if\ p(x)\ then\ f(x)\ else\ g(x)) = \prod\_{x \in s,\ p(x)} f(x) * \prod\_{x \in s,\ ¬p(x)} g(x)$.


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

This theorem states that for any given type `G` that forms an additive group, and for any subgroup `H` of this group, the index of `H` is equal to one if and only if `H` is a top element. In mathematical terms, it means that if the quotient space formed by the group `G` and its subgroup `H` has just one element (i.e., the index of `H` in `G` is one), then `H` must be the whole group `G` itself. Conversely, if `H` is the whole group `G`, then the index of `H` in `G` is one.

For an additive group `G` and its subgroup `H`, the index of `H` in `G` equals 1 if and only if `H` is the whole group `G`.


theorem PNat.XgcdType.reduce_b :
    ∀ {u : PNat.XgcdType},
      PNat.XgcdType.r u ≠ 0 →
        PNat.XgcdType.reduce u = PNat.XgcdType.flip (PNat.XgcdType.reduce (PNat.XgcdType.step u)) :=
  by sorry

The theorem `PNat.XgcdType.reduce_b` states that for any positive natural number type `u`, if the remainder `r` of `u` (computed as `(u.ap + 1) % (u.bp + 1)`) is not zero, then the result of the function `PNat.XgcdType.reduce` on `u` is equivalent to flipping (`PNat.XgcdType.flip`) the result of `PNat.XgcdType.reduce` on the next step (`PNat.XgcdType.step u`) of the Euclidean algorithm. This encapsulates one of the key steps in the Euclidean algorithm for finding the greatest common divisor, namely that when the remainder is not zero, the algorithm proceeds by reducing the larger number by the remainder and then switching the roles of the two numbers.

If the remainder of the Euclidean algorithm for positive natural numbers `u` is non-zero, then `PNat.XgcdType.reduce u` is equivalent to `PNat.XgcdType.flip (PNat.XgcdType.reduce (PNat.XgcdType.step u))`.


theorem PNat.XgcdType.reduce_a :
    ∀ {u : PNat.XgcdType}, PNat.XgcdType.r u = 0 → PNat.XgcdType.reduce u = PNat.XgcdType.finish u := by sorry

The theorem `PNat.XgcdType.reduce_a` states that for any positive natural number `u` of the type `PNat.XgcdType`, if the remainder function `PNat.XgcdType.r u` equals to zero, implying that `(u.ap + 1)` is divisible by `(u.bp + 1)`, then the `reduce` operation on `u` is equivalent to the `finish` operation on `u`. This theorem is essentially a rule about the relationship between the `reduce` and `finish` operations in the context of the Euclidean algorithm for positive natural numbers.

If `u` is a positive natural number with `PNat.XgcdType.r u = 0` implying `(u.ap + 1)` divides `(u.bp + 1)`, then `PNat.XgcdType.reduce u = PNat.XgcdType.finish u`.


theorem Finset.disjoint_filter_filter' :
    ∀ {α : Type u_1} (s t : Finset α) {p q : α → Prop} [inst : DecidablePred p] [inst_1 : DecidablePred q],
      Disjoint p q → Disjoint (Finset.filter p s) (Finset.filter q t) :=
  by sorry

This theorem states that for any two sets `s` and `t` of any type `α`, and any two decidable predicates `p` and `q`, if `p` and `q` are disjoint (meaning that their intersection is empty), then the sets obtained by filtering `s` and `t` with `p` and `q` respectively, are also disjoint. In other words, if no element of `α` satisfies both `p` and `q`, then no element of the filtered sets will either. The predicates are considered decidable, meaning that there exists a procedure to determine whether `p` or `q` is true for any given element of `α`.

If sets `s` and `t` of type `α` have disjoint decidable predicates `p` and `q`, then the filtered sets `s | p` and `t | q` are also disjoint.


theorem Real.cos_pos_of_mem_Ioo : ∀ {x : ℝ}, x ∈ Set.Ioo (-(Real.pi / 2)) (Real.pi / 2) → 0 < Real.cos x := by sorry

The theorem `Real.cos_pos_of_mem_Ioo` states that for any real number `x`, if `x` belongs to the open interval from negative half pi to positive half pi (i.e., `x` is strictly greater than `-π/2` and strictly less than `π/2`), then the cosine of `x` is strictly greater than zero. This corresponds to the well-known fact from trigonometry that the cosine function is positive in the first and fourth quadrants of the unit circle, which correspond to the described interval in radians.

If `x` is in the open interval `(-π/2, π/2)`, then `cos x > 0`.


theorem Mathlib.Data.Set.Finite._auxLemma.29 :
    ∀ {α : Type u} (a : α) {s : Set α}, Set.Finite s → Set.Finite (insert a s) = True := by sorry

This theorem states that for any type `α`, any element `a` of type `α`, and any set `s` of type `α`, if the set `s` is finite, then the set resulting from inserting the element `a` into `s` is also finite. Thus, adding an element to a finite set maintains the finiteness of the set.

If `α` is a type, `a : α`, and `s : set α` is finite, then `a ∈ s` implies `s.insert a` is finite.


theorem AffineSubspace.map_id :
    ∀ {k : Type u_1} {V₁ : Type u_2} {P₁ : Type u_3} [inst : Ring k] [inst_1 : AddCommGroup V₁] [inst_2 : Module k V₁]
      [inst_3 : AddTorsor V₁ P₁] (s : AffineSubspace k P₁), AffineSubspace.map (AffineMap.id k P₁) s = s :=
  by sorry

This theorem states that for every type `k` with a ring structure, type `V1` forming an additive commutative group and a `k`-module, type `P1` forming a torsor under `V1`, and any affine subspace `s` of `P1`, the result of mapping `s` through the identity affine map (which maps every point to itself) is `s` itself. In other words, applying the identity affine map to an affine subspace doesn't change the subspace.

For every ring `k`, additive commutative group `V1` with `k`-module structure, and torsor `P1` under `V1`, the application of the identity affine map to an affine subspace of `P1` results in the same subspace.


theorem Nat.ceil_mono :
    ∀ {α : Type u_2} [inst : LinearOrderedSemiring α] [inst_1 : FloorSemiring α], Monotone Nat.ceil := by sorry

This theorem states that for any type `α` that is a linear ordered semiring (a structure with two operations satisfying certain properties, such as the distributivity of one operation over the other, and the existence of a total ordering compatible with the operations) and a floor semiring (a structure that allows us to round elements down to the nearest integer), the function `Nat.ceil` is monotone. In other words, if `a ≤ b` for any `a` and `b` of type `α`, then `⌈a⌉₊ ≤ ⌈b⌉₊`, where `⌈x⌉₊` denotes the least natural number `n` such that `x ≤ n`.

For any linear ordered semiring `α` and floor semiring `α`, the monotonicity function `x ↦ ⌈x⌉₊` is increasing on `α`.


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

This theorem states that for any two Lie subalgebras `L₁'` and `L₂'` of a Lie algebra `L` over a commutative ring `R`, the condition of their corresponding submodules being equal is equivalent to the Lie subalgebras themselves being equal. In other words, two Lie subalgebras are identical if and only if their submodules are identical. This theorem is a fundamental result in the theory of Lie algebras, linking the structure of Lie subalgebras with their underlying module structure.

Two Lie subalgebras of a Lie algebra over a commutative ring are equal if and only if their submodules are equal.


theorem Set.mem_Icc_of_Ico : ∀ {α : Type u_1} [inst : Preorder α] {a b x : α}, x ∈ Set.Ico a b → x ∈ Set.Icc a b := by
  sorry

The theorem `Set.mem_Icc_of_Ico` states that for any type `α` that has a preorder relation (`≤`), and any three elements `a`, `b`, and `x` of type `α`, if `x` belongs to the left-closed right-open interval from `a` to `b` (denoted `Set.Ico a b`), then `x` also belongs to the left-closed right-closed interval from `a` to `b` (denoted `Set.Icc a b`). In mathematical terms, if `a ≤ x < b`, then it's also true that `a ≤ x ≤ b`.

If `a ≤ x` and `x < b` hold in a preordered type `α`, then `a ≤ x ≤ b`. In other words, every left-closed right-open interval is a subset of the corresponding left-closed right-closed interval.


/-- **Rearrangement Inequality**: Pointwise scalar multiplication of `f` and `g` is minimized when
`f` and `g` antivary together. Stated by permuting the entries of `f`.  -/
theorem AntivaryOn.sum_smul_le_sum_comp_perm_smul :
    ∀ {ι : Type u_1} {α : Type u_2} {β : Type u_3} [inst : LinearOrderedRing α] [inst_1 : LinearOrderedAddCommGroup β]
      [inst_2 : Module α β] [inst_3 : OrderedSMul α β] {s : Finset ι} {σ : Equiv.Perm ι} {f : ι → α} {g : ι → β},
      AntivaryOn f g ↑s →
        {x | σ x ≠ x} ⊆ ↑s → (Finset.sum s fun i => f i • g i) ≤ Finset.sum s fun i => f (σ i) • g i :=
  by sorry

This theorem is a statement of the **Rearrangement Inequality** in the context of summing scalar multiplications of two functions over a finite set. More specifically, for any finite set `s`, permutation `σ`, and functions `f : ι → α` and `g : ι → β` that antivary on `s` (i.e., if `g i < g j` then `f j ≤ f i` for all `i` and `j` in `s`), the sum of the scalar products `f i • g i` over `s` is less than or equal to the sum of the scalar products `f (σ i) • g i` over `s`. This is under the condition that any `x` for which `σ x ≠ x` is within `s`. Here, `•` denotes the scalar multiplication operation, `α` is a linear ordered ring, `β` is a linear ordered additive commutative group, and `α` is a module over `β`. The inequality is preserved when the values of `f` are permuted according to `σ`.

For any finite set `s`, permutation `σ`, and functions `f : ι → α` and `g : ι → β` that antivary on `s`, the sum of the scalar products `f i • g i` over `s` is less than or equal to the sum of the scalar products `f (σ i) • g i` over `s`, provided any `x` for which `σ x neq x` is in `s`.


/-- **Alias** of the reverse direction of `lipschitzOnWith_iff_dist_le_mul`. -/
theorem LipschitzOnWith.of_dist_le_mul :
    ∀ {α : Type u} {β : Type v} [inst : PseudoMetricSpace α] [inst_1 : PseudoMetricSpace β] {K : NNReal} {s : Set α}
      {f : α → β}, (∀ x ∈ s, ∀ y ∈ s, dist (f x) (f y) ≤ ↑K * dist x y) → LipschitzOnWith K f s :=
  by sorry

This theorem, referred to as an alias of the reverse direction of `lipschitzOnWith_iff_dist_le_mul`, states that for any two types `α` and `β` with a `PseudoMetricSpace` structure, a nonnegative real number `K`, a set `s` of elements from `α`, and a function `f` from `α` to `β`, if for every pair of elements `x` and `y` from the set `s`, the distance between `f(x)` and `f(y)` is less than or equal to `K` times the distance between `x` and `y`, then the function `f` is Lipschitz continuous with constant `K` on the set `s`. In mathematical terms, a function is Lipschitz continuous on a set if there exists a nonnegative real number such that for every pair of points in the set, the distance between the images of the points under the function is less than or equal to that number times the distance between the points themselves.

If for all x, y in a set S of a PseudoMetricSpace (α), the distance between f(x) and f(y) is less than or equal to K times the distance between x and y, then f is Lipschitz continuous on S with constant K.


theorem Mathlib.MeasureTheory.Measure.Regular._auxLemma.3 :
    ∀ {α : Type u_1} {ι : Sort u_5} [inst : CompleteLinearOrder α] {a : α} {f : ι → α}, (iInf f < a) = ∃ i, f i < a :=
  by sorry

This theorem, `Mathlib.MeasureTheory.Measure.Regular._auxLemma.3`, states that for any type `α` equipped with a complete linear order, a given element `a` of type `α`, and a function `f` from some index set `ι` to `α`, the inequality `iInf f < a` holds if and only if there exists an index `i` such that `f(i) < a`. Here `iInf f` denotes the indexed infimum of the function `f`, which is the smallest element in the range of `f` in the given complete linear order.

For a complete linear order on type `α`, an element `a` in `α`, and a function `f` from an index set `ι` to `α`, `iInf f < a` if and only if there exists an index `i` such that `f(i) < a`.


theorem Mathlib.Data.Finset.Card._auxLemma.16 :
    ∀ {α : Type u_1} {s : Finset α}, (1 < s.card) = ∃ a b, a ∈ s ∧ b ∈ s ∧ a ≠ b := by sorry

This theorem is stating that for any type `α` and any finite set `s` of that type, the cardinality (or size) of `s` being greater than 1 is equivalent to the existence of two distinct elements `a` and `b` in `s`. In other words, if a finite set has more than one element, then there must be at least two different elements in that set.

For any finite type `α` and non-empty set `s` of type `α`, the cardinality of `s` being greater than 1 if and only if there exist distinct elements `a` and `b` in `s`.


theorem Real.abs_rpow_le_abs_rpow : ∀ (x y : ℝ), |x ^ y| ≤ |x| ^ y := by sorry

This theorem states that for any two real numbers `x` and `y`, the absolute value of `x` raised to the power of `y` is less than or equal to the absolute value of `x` raised to the power of `y`. In LaTeX notation, it can be represented as for all $x, y \in \mathbb{R}$, $|x^y| \leq |x|^y$.

For all real numbers x and y, the absolute value of x raised to the power of y is less than or equal to the absolute value of x raised to the power of y (i.e., |x^y| ≤ |x|^y).


theorem List.Sublist.eq_of_length_le :
    ∀ {α : Type u_1} {l₁ l₂ : List α}, List.Sublist l₁ l₂ → List.length l₂ ≤ List.length l₁ → l₁ = l₂ := by sorry

The theorem `List.Sublist.eq_of_length_le` states that for any type `α`, and any two lists `l₁` and `l₂` of type `α`, if `l₁` is a sublist of `l₂` and the length of `l₂` is less than or equal to the length of `l₁`, then `l₁` must be equal to `l₂`. Essentially, this means that if a list is a sublist of another, and they have the same length, they must be the same list.

If `l₁` is a sublist of `l₂` and the length of `l₁` is less than or equal to the length of `l₂`, then `l₁` equals `l₂`.


theorem CategoryTheory.Functor.mapIso_inv :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
      (F : CategoryTheory.Functor C D) {X Y : C} (i : X ≅ Y), (F.mapIso i).inv = F.map i.inv :=
  by sorry

This theorem states that for any category `C`, its corresponding category `D`, and a functor `F` that maps from `C` to `D`, if `X` and `Y` are objects in `C` that are isomorphic (denoted by `X ≅ Y`), then the inverse of the functor's map applied to the isomorphism (`(F.mapIso i).inv`) is equal to the functor's map applied to the inverse isomorphism (`F.map i.inv`). This means that the functor preserves the isomorphism structure between objects in the underlying categories.

Given any category `C`, functor `F` from `C` to another category `D`, and isomorphisms `i : X ≅ Y` in `C`, the inverse of `F.mapIso i` is equal to `F.map (i.inv)`.


theorem CategoryTheory.Limits.PreservesCokernel.iso_inv :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
      {D : Type u₂} [inst_2 : CategoryTheory.Category.{v₂, u₂} D] [inst_3 : CategoryTheory.Limits.HasZeroMorphisms D]
      (G : CategoryTheory.Functor C D) [inst_4 : CategoryTheory.Functor.PreservesZeroMorphisms G] {X Y : C} (f : X ⟶ Y)
      [inst_5 : CategoryTheory.Limits.HasCokernel f] [inst_6 : CategoryTheory.Limits.HasCokernel (G.map f)]
      [inst_7 : CategoryTheory.Limits.PreservesColimit (CategoryTheory.Limits.parallelPair f 0) G],
      (CategoryTheory.Limits.PreservesCokernel.iso G f).inv = CategoryTheory.Limits.cokernelComparison f G :=
  by sorry

The theorem `CategoryTheory.Limits.PreservesCokernel.iso_inv` states that for any categories `C` and `D` with zero morphisms, and a functor `G` from `C` to `D` that preserves zero morphisms, given objects `X` and `Y` in `C` and a morphism `f` from `X` to `Y` that has a cokernel in both `C` and `D`, and assuming the functor `G` preserves the colimit of the parallel pair consisting of `f` and the zero morphism, then the inverse of the preserving cokernel isomorphism of `G` mapping `f` is equal to the cokernel comparison of `f` with `G`. In simpler terms, it states that under certain conditions, we can relate the inverse of a certain isomorphism involving cokernels to a notion called cokernel comparison.

Given functors between zero-morphism categories `G: C -> D` that preserve zero morphisms, if `f: X -> Y` in `C` has cokernels `K` in both `C` and `D` and `G` preserves the colimit of `(f, 0_on_X)`, then `iso_inv(G.mapCokernel f) = cokernelComparison f G`.


theorem Dioph.ex1_dioph : ∀ {α : Type u} {S : Set (Option α → ℕ)}, Dioph S → Dioph {v | ∃ x, Option.elim' x v ∈ S} := by
  sorry

This theorem states that for any type `α` and any set `S` of functions from "Option of `α`" to `ℕ` (natural numbers), if `S` is Diophantine, then the set of functions `v` such that there exists an `x` of Option `α` for which `Option.elim' x v` is in `S` is also Diophantine. Here, a set is Diophantine if there exists a polynomial such that a function `v` is in the set if and only if there exists a tuple `t` of natural numbers such that the polynomial evaluated at `(v, t)` is zero. In the theorem, `Option.elim'` is a function that given an option value `x` and a function `v`, applies `v` to the value inside `x` if `x` is "some value", or returns a default value if `x` is "none".

If `S` is a Diophantine set of functions from Option `α` to `ℕ`, then the set of functions `v` such that there exists an `x` of Option `α` with Option.elim' `x` `v` in `S` is also Diophantine.


theorem Valuation.Integers.dvd_of_le :
    ∀ {F : Type u} {Γ₀ : Type v} [inst : Field F] [inst_1 : LinearOrderedCommGroupWithZero Γ₀] {v : Valuation F Γ₀}
      {O : Type w} [inst_2 : CommRing O] [inst_3 : Algebra O F],
      Valuation.Integers v O → ∀ {x y : O}, v ((algebraMap O F) x) ≤ v ((algebraMap O F) y) → y ∣ x :=
  by sorry

The theorem `Valuation.Integers.dvd_of_le` states that for any Field `F`, any Linear Ordered Commutative Group With Zero `Γ₀`, any Valuation `v` of `F` with values in `Γ₀`, any Commutative Ring `O`, and any Algebra structure of `O` over `F`, if `O` is the ring of integers in `F` with respect to `v`, then for any elements `x` and `y` in `O`, if the valuation of the image of `x` under the algebra structure map from `O` to `F` is less than or equal to the valuation of the image of `y` under the same map, then `y` divides `x`. In mathematical terms, it asserts that if $v(\phi(x)) \leq v(\phi(y))$ for $x, y \in O$ where $\phi: O \to F$ is the algebra structure map, then $y$ divides $x$ in the ring `O`.

If `v` is a valuation of a field `F` with values in a linearly ordered commutative group `Γ₀`, and `O` is the ring of integers in `F` with respect to `v`, then for all `x, y ∈ O`, `y` divides `x` in `O` if and only if the valuation of `x` under the algebra structure map is less than or equal to the valuation of `y` under the same map.


theorem lcm_same :
    ∀ {α : Type u_1} [inst : CancelCommMonoidWithZero α] [inst_1 : NormalizedGCDMonoid α] (a : α),
      lcm a a = normalize a :=
  by sorry

The theorem `lcm_same` states that for any type `α` that is a cancel commutative monoid with zero and a normalized GCD monoid, and for any element `a` of type `α`, the least common multiple (LCM) of `a` and `a` is equal to the normalized value of `a`. In other words, when the two inputs to the LCM function are the same, the output is simply the input multiplied by the norm unit of the input.

For any cancel commutative monoid with zero and normalized GCD monoid type `α`, the LCM of an element `a` equals the normalized value of `a`. That is, LCM(a, a) = norm a.


theorem Finsupp.support_mapRange :
    ∀ {α : Type u_1} {M : Type u_5} {N : Type u_7} [inst : Zero M] [inst_1 : Zero N] {f : M → N} {hf : f 0 = 0}
      {g : α →₀ M}, (Finsupp.mapRange f hf g).support ⊆ g.support :=
  by sorry

This theorem states that for any types `α`, `M`, and `N`, and for any function `f : M → N` that maps zero to zero, and any function `g : α →₀ M` (which is a function from `α` to `M` with finite support; in other words, `g` is zero for all but finitely many elements of `α`), the support of the result of mapping the range of `g` using `f` is a subset of the support of `g`. This essentially means that applying `f` to the range of `g` doesn't introduce any new non-zero values. The "support" of a function is the set of points where the function is non-zero.

For functions `f : M → N` mapping zero to zero, `g : α →₀ M` with finite support, the support of `f ∘ g` is contained in the support of `g`.


theorem AffineEquiv.image_symm :
    ∀ {k : Type u_1} {P₁ : Type u_2} {P₂ : Type u_3} {V₁ : Type u_6} {V₂ : Type u_7} [inst : Ring k]
      [inst_1 : AddCommGroup V₁] [inst_2 : Module k V₁] [inst_3 : AddTorsor V₁ P₁] [inst_4 : AddCommGroup V₂]
      [inst_5 : Module k V₂] [inst_6 : AddTorsor V₂ P₂] (f : P₁ ≃ᵃ[k] P₂) (s : Set P₂),
      ⇑(AffineEquiv.symm f) '' s = ⇑f ⁻¹' s :=
  by sorry

This theorem states that for any given ring `k`, additive commutative groups `V₁` and `V₂`, and affine spaces `P₁` and `P₂` over `V₁` and `V₂` respectively, and an affine equivalence `f` from `P₁` to `P₂`, the image of a set `s` in `P₂` under the inverse of `f` is the same as the preimage of `s` under `f`. In simpler terms, applying `f` inverse and then `f` to a set `s` will just give you back the set `s`.

For any affine equivalence `f` between affine spaces `P₁` and `P₂` over additive commutative groups `V₁` and `V₂`, and any set `s` in `P₂`, we have `f⁻¹(s) = {x : P₁ | f(x) ∈ s}`.


/-- A nonempty separable space admits a sequence with dense range. Instead of running `cases` on the
conclusion of this lemma, you might want to use `TopologicalSpace.denseSeq` and
`TopologicalSpace.denseRange_denseSeq`.

If `α` might be empty, then `TopologicalSpace.exists_countable_dense` is the main way to use
separability of `α`.  -/
theorem TopologicalSpace.exists_dense_seq :
    ∀ (α : Type u) [t : TopologicalSpace α] [inst : TopologicalSpace.SeparableSpace α] [inst : Nonempty α],
      ∃ u, DenseRange u :=
  by sorry

This theorem states that for any nonempty separable topological space `α`, there exists a sequence `u` that has a dense range in `α`. In other words, it is always possible to find a sequence in `α` such that its range (or image) is a dense subset of `α`. The theorem suggests using `TopologicalSpace.denseSeq` and `TopologicalSpace.denseRange_denseSeq` instead of `cases` on its conclusion, and if `α` might be empty, `TopologicalSpace.exists_countable_dense` should be used.

In mathematical terms, a space is called separable if it contains a countable, dense subset. A set is called dense if every point of the space is either in the set or is a limit point of the set. A sequence is said to have a dense range if its image under some function forms a dense set.

Every nonempty separable topological space has a dense sequence.


theorem AddMonoidAlgebra.modOf_apply_self_add :
    ∀ {k : Type u_1} {G : Type u_2} [inst : Semiring k] [inst_1 : AddCancelCommMonoid G] (x : AddMonoidAlgebra k G)
      (g d : G), (AddMonoidAlgebra.modOf x g) (g + d) = 0 :=
  by sorry

This theorem states that for any semiring `k`, any additive cancel commutative monoid `G`, any element `x` of the monoid algebra of `G` over `k`, and any elements `g` and `d` of `G`, the value at `g + d` of the monoid algebra element obtained by reducing `x` modulo `g` is zero. In other words, when you take an element of the monoid algebra, reduce it modulo another element of the monoid, and then evaluate this at the sum of the original element and another element, the result is always zero. This essentially captures a property of the modulo operation in the context of monoid algebras.

For any semiring `k`, additive cancel commutative monoid `G`, and elements `x` in the monoid algebra of `G` over `k`, `g`, `d` in `G`, the evaluation of `x` reduced modulo `g` at `g + d` is equal to zero.


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

The theorem `Polynomial.degree_le_mul_left` states that for any non-zero polynomial `q`, from a semiring `R` that does not allow zero divisors, the degree of any polynomial `p` is less than or equal to the degree of the product of `p` and `q`. This means that multiplying a polynomial by a non-zero polynomial cannot decrease the degree, it can only increase or keep it the same.

For any non-zero polynomial $p$ in a semiring $R$ without zero divisors, the degree of $p$ is less than or equal to the degree of $p \cdot q$.


theorem PowerBasis.minpolyGen_eq :
    ∀ {S : Type u_2} [inst : Ring S] {A : Type u_4} [inst_1 : CommRing A] [inst_2 : Algebra A S] (pb : PowerBasis A S),
      PowerBasis.minpolyGen pb = minpoly A pb.gen :=
  by sorry

This theorem states that for any power basis 'pb' of type `PowerBasis A S`, where 'A' is a commutative ring and 'S' is a ring with an algebra structure over 'A', the minimal polynomial of the power basis generator, `pb.gen`, is equal to the result of the function `PowerBasis.minpolyGen` applied to 'pb'. In other words, the minimal polynomial of the power basis generator can be computed as the difference between `Polynomial.X` raised to the power of the dimension of the power basis and the sum (over all elements in the universe) of the product of the coefficient at index 'i' in the representation (under `pb.basis.repr`) of `pb.gen` to the power of the power basis dimension and `Polynomial.X` raised to the power of 'i'.

The minimal polynomial of a power basis generator equals the polynomial generated by applying `PowerBasis.minpolyGen` to the power basis.


theorem Prod.snd_iInf :
    ∀ {α : Type u_1} {β : Type u_2} {ι : Sort u_5} [inst : InfSet α] [inst_1 : InfSet β] (f : ι → α × β),
      (iInf f).2 = ⨅ i, (f i).2 :=
  by sorry

The theorem `Prod.snd_iInf` states that for any types `α`, `β`, and `ι`, given an infimum set structure on `α` and `β`, and a function `f : ι → α × β` (i.e., a function that maps elements from `ι` to pairs of elements in `α` and `β`), the second component of the infimum of the function `f` (that is, `(iInf f).2`) is equal to the infimum over all `i` of the second component of `f(i)` (which is represented by `⨅ i, (f i).2`). In other words, it extracts the infimum of the second components of the pairs generated by the function `f` over the index set `ι`.

For any functions `f : ι → α × β`, the second component of the infimum of `f` equals the infimum of the second components of `f(i)` for all `i` in the index set.


theorem Nat.Prime.factors_pow : ∀ {p : ℕ}, Nat.Prime p → ∀ (n : ℕ), Nat.factors (p ^ n) = List.replicate n p := by sorry

The theorem `Nat.Prime.factors_pow` states that for any natural number `p` which is a prime number, for all natural number `n`, the prime factorization of `p` raised to the power `n` is a list composed of `n` copies of `p`. In other words, if `p` is a prime number, then the prime factorization of `p^n` always consists of `p` repeated `n` times.

For any prime number p and natural number n, the prime factorization of p^n is a list of n copies of p. (Equivalently, the prime factorization of p raised to the power n is p^n.)


theorem Set.Icc.coe_mul : ∀ {α : Type u_1} [inst : OrderedSemiring α] (x y : ↑(Set.Icc 0 1)), ↑(x * y) = ↑x * ↑y := by
  sorry

The theorem `Set.Icc.coe_mul` states that for any ordered semiring `α`, and for any `x` and `y` in the closed interval from 0 to 1 denoted by `Set.Icc 0 1`, the product of `x` and `y` is equal to the product of the values `x` and `y` point to. This is an equality in the context of using the coe function (↑) to remove or upgrade the type of `x`, `y` and their product from the interval `Set.Icc 0 1` to the underlying type `α`. In mathematical terms, given an ordered semiring, the product of any two elements in the closed interval [0,1] remains the same when considered in the broader context of the semiring.

For any ordered semiring α, the product of two elements in the closed interval [0,1] equals their pointwise product in α.


theorem SimpleGraph.incidence_other_prop :
    ∀ {V : Type u} (G : SimpleGraph V) [inst : DecidableEq V] {v : V} {e : Sym2 V}
      (h : e ∈ SimpleGraph.incidenceSet G v), SimpleGraph.otherVertexOfIncident G h ∈ SimpleGraph.neighborSet G v :=
  by sorry

This theorem states that for any given vertex `v` in a simple graph `G` of vertex type `V` where `V` has a decidable equality, and for any edge `e` in the incidence set of `v` (i.e., `e` is an edge incident to `v`), the other vertex of the edge `e` (that is not `v`) is in the neighbor set of `v`. In other words, if an edge is incident to a vertex, the other vertex of that edge is indeed a neighbor of the given vertex.

For any simple graph with decidable vertex equality, if vertex `v` has an incident edge `e`, then the vertex at the other end of `e` is in `v`'s neighbor set.


theorem LowerSet.coe_iSup₂ :
    ∀ {α : Type u_1} {ι : Sort u_4} {κ : ι → Sort u_5} [inst : LE α] (f : (i : ι) → κ i → LowerSet α),
      ↑(⨆ i, ⨆ j, f i j) = ⋃ i, ⋃ j, ↑(f i j) :=
  by sorry

This theorem, `LowerSet.coe_iSup₂`, states that for any type `α`, any `ι`-indexed type `κ` and any function `f` that maps an index `i : ι` and value `j : κ i` to a `LowerSet` of `α`, the supremum (least upper bound) of the double-indexed family of `LowerSet`s, coerced to a set, is equal to the union over all `i` and `j` of the sets given by coercing each `LowerSet (f i j)`. In simple terms, it says that the set-theoretic union of these lower sets corresponds to their supremum in the order-theoretic sense.

For any type `α`, `ι-indexed` type `κ` and function `f : ι × κ → LowerSet α`, the coercion of the supremum of `{coe (f i j) | i ∈ ι, j ∈ κ}` to a set equals the union of `{coe (f i j) | i ∈ ι, j ∈ κ}`.


theorem MeasureTheory.Iio_ae_eq_Iic :
    ∀ {α : Type u_1} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} [inst : MeasureTheory.NoAtoms μ]
      [inst : PartialOrder α] {a : α}, Set.Iio a =ᶠ[MeasureTheory.Measure.ae μ] Set.Iic a :=
  by sorry

This theorem states that for any type `α`, a measurable space `m0` over `α`, a measure `μ` on the measurable space that has no atoms, and a partial order on `α`, for any element `a` of `α`, the left-infinite right-open interval (Set.Iio a) is 'almost everywhere' equal to the left-infinite right-closed interval (Set.Iic a) under the measure `μ`. Here, 'almost everywhere' means that the set difference of these two intervals has measure zero. In other words, except possibly on a set of measure zero, every element that is strictly less than `a` (from Set.Iio a) is also less than or equal to `a` (from Set.Iic a).

For any measurable space `(α, m0)`, measure `μ` with no atoms, and partial order on `α`, the left-infinite right-open and left-infinite right-closed intervals of any element `a` in `α` have measure-theoretic equality (i.e., their symmetric difference has measure zero).


theorem Primrec₂.ofNat_iff :
    ∀ {α : Type u_4} {β : Type u_5} {σ : Type u_6} [inst : Denumerable α] [inst_1 : Denumerable β]
      [inst_2 : Primcodable σ] {f : α → β → σ},
      Primrec₂ f ↔ Primrec₂ fun m n => f (Denumerable.ofNat α m) (Denumerable.ofNat β n) :=
  by sorry

This theorem `Primrec₂.ofNat_iff` states that for all types `α`, `β`, and `σ`, wherein `α` and `β` are denumerable and `σ` is primcodable, and for a binary function `f` from `α` and `β` to `σ`, the function `f` is primitive recursive if and only if the function that maps two natural numbers `m` and `n` to `f` applied to the `m`-th element of `α` and the `n`-th element of `β` is also primitive recursive. In other words, a binary function `f` is primitive recursive exactly when its corresponding function in the natural numbers domain, that uses denumerable indexing, is primitive recursive.

A binary function between two denumerable types is primitive recursive if and only if the function that maps natural numbers to applications of the binary function to the corresponding elements in each type is primitive recursive.


theorem Stream'.Seq.map_id : ∀ {α : Type u} (s : Stream'.Seq α), Stream'.Seq.map id s = s := by sorry

This theorem, called `Stream'.Seq.map_id`, states that for any sequence of elements of any type `α`, mapping the identity function over this sequence leaves the sequence unchanged. In other words, for all sequences `s` of type `α`, the operation of mapping the identity function on `s` (denoted by `Stream'.Seq.map id s`) gives us the same sequence `s` again. This axiom formalizes the intuition that applying the identity function doesn't change the elements of the sequence.

For any sequence `s` of type `α`, the operation `Stream'.Seq.map id s` equals the sequence `s`.


theorem PadicInt.appr_spec :
    ∀ {p : ℕ} [hp_prime : Fact (Nat.Prime p)] (n : ℕ) (x : ℤ_[p]), x - ↑(PadicInt.appr x n) ∈ Ideal.span {↑p ^ n} := by
  sorry

The theorem `PadicInt.appr_spec` states that for every natural number `p` which is a prime number, for every natural number `n`, and for every p-adic integer `x`, the difference between `x` and the approximation of `x` at `n` belongs to the ideal generated by the set containing `p` to the power of `n`. In other words, if we subtract the `n`th approximation of a p-adic integer `x` from `x` itself, the result will be a member of the ideal whose generators are the powers of the prime `p` up to the `n`th power.

For every prime number p, natural number n, and p-adic integer x, the difference between x and its n-th approximation belongs to the ideal generated by {p^i | i <= n}.


Filter.HasBasis.tendstoIxxClass

theorem Filter.HasBasis.tendstoIxxClass :
    ∀ {α : Type u_1} {ι : Type u_3} {p : ι → Prop} {s : ι → Set α} {l : Filter α},
      Filter.HasBasis l p s →
        ∀ {Ixx : α → α → Set α},
          (∀ (i : ι), p i → ∀ x ∈ s i, ∀ y ∈ s i, Ixx x y ⊆ s i) → Filter.TendstoIxxClass Ixx l l :=
  by sorry

The theorem `Filter.HasBasis.tendstoIxxClass` states that for any type `α` and an index type `ι`, given a predicate `p` on `ι`, a map `s` from `ι` to a set of `α`, and a filter `l` on `α`, if the filter `l` has a basis characterized by the predicate `p` and the map `s`, then for any index set function `Ixx`, if for every `i` in `ι` where the predicate `p` holds, every pair of elements `x` and `y` from the set `s i` satisfies that `Ixx x y` is a subset of `s i`, then the filter `l` tends to the Ixx class defined by `Ixx`. In simpler words, it describes a condition under which a filter has a certain "tendency" property with respect to an index set function.

If a filter on a set, indexed by a type, has a basis characterized by a predicate and a map, and the map images satisfy a certain condition with respect to an index set function, then the filter tends to the Ixx class defined by the function.


ProbabilityTheory.IdentDistrib.symm

theorem ProbabilityTheory.IdentDistrib.symm :
    ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : MeasurableSpace α] [inst_1 : MeasurableSpace β]
      [inst_2 : MeasurableSpace γ] {μ : MeasureTheory.Measure α} {ν : MeasureTheory.Measure β} {f : α → γ} {g : β → γ},
      ProbabilityTheory.IdentDistrib f g μ ν → ProbabilityTheory.IdentDistrib g f ν μ :=
  by sorry

This theorem, `ProbabilityTheory.IdentDistrib.symm`, states that for any three Types `α`, `β`, and `γ`, and given measurable spaces over `α`, `β`, and `γ`, as well as measures `μ` over `α` and `ν` over `β`, and functions `f : α → γ` and `g : β → γ`, if the identity distribution law holds for `f`, `g`, `μ`, and `ν`, then it also holds for `g`, `f`, `ν`, and `μ`. In other words, the identity distribution law is symmetric with respect to the input functions and measures.

If functions `f : α → γ` and `g : β → γ` preserve measures `μ` over `α` and `ν` over `β`, respectively, and the identity distribution law holds for `(f, g, μ, ν)`, then it also holds for `(g, f, ν, μ)`.


theorem Filter.Tendsto.zpow₀ :
    ∀ {α : Type u_1} {G₀ : Type u_3} [inst : GroupWithZero G₀] [inst_1 : TopologicalSpace G₀]
      [inst_2 : HasContinuousInv₀ G₀] [inst_3 : ContinuousMul G₀] {f : α → G₀} {l : Filter α} {a : G₀},
      Filter.Tendsto f l (nhds a) → ∀ (m : ℤ), a ≠ 0 ∨ 0 ≤ m → Filter.Tendsto (fun x => f x ^ m) l (nhds (a ^ m)) :=
  by sorry

This theorem states that for any type `α` and a type `G₀` equipped with a group structure with zero, a topology, continuous inversion, and continuous multiplication, given a function `f` from `α` to `G₀`, and a filter `l` on `α`, and an element `a` of `G₀`, if `f` tends towards `a` with respect to the filter `l` and the neighborhood filter at `a`, then for any integer `m`, if `a` is not zero or `m` is nonnegative, the function that raises `f` to the power of `m` also tends towards `a` raised to the power of `m` with respect to the filter `l` and the neighborhood filter at `a^m`.

In mathematical terms, it states that if \(\lim_{x\to l} f(x) = a\), either `a` is nonzero or `m` is nonnegative, then \(\lim_{x\to l} f(x)^m = a^m\). This theorem is basically saying that the limit of a power is the power of the limit, under certain conditions.

If `f` is a continuous function from a topological space `α` to a group `G₀` with zero and multiplication, and `a` is a nonzero limit of `f` with respect to filter `l`, then `a^m` is the limit of `f^m` with respect to `l` for any nonnegative integer `m`.


theorem bit0_add : ∀ {M : Type u} [inst : AddCommSemigroup M] (a b : M), bit0 (a + b) = bit0 a + bit0 b := by sorry

This theorem, named "bit0_add", is a statement about addition in an additive commutative semigroup. Specifically, it says that for every type `M` equipped with an addition operation that forms a commutative semigroup, and for every two elements `a` and `b` of `M`, the operation of doubling (`bit0`) the sum of `a` and `b` is the same as the sum of the doubles of `a` and `b`. In mathematical terms, it is saying that for any `a` and `b` in `M`, 2*(a + b) = 2*a + 2*b, where '*' represents the operation of multiplication by 2 (or "doubling"), '+' is the addition operation in `M`, and '2' represents the double operation.

For every commutative semigroup `M` with addition `+` and multiplication `*` by 2 (bit0), it holds that 2*(a + b) = 2*a + 2*b for all `a, b` in `M`.


theorem Commute.pow_dvd_pow_of_sub_pow_eq_zero :
    ∀ {R : Type u_1} {x y : R} {n m p : ℕ},
      n + m ≤ p + 1 → ∀ [inst : Ring R], Commute x y → (x - y) ^ n = 0 → x ^ m ∣ y ^ p :=
  by sorry

The theorem `Commute.pow_dvd_pow_of_sub_pow_eq_zero` states that for any given ring `R` and elements `x`, `y` of `R`, and any natural numbers `n`, `m`, `p` such that `n + m` is less than or equal to `p + 1`, if `x` and `y` commute (i.e., `x * y = y * x`) and `(x - y) ^ n` equals zero, then `x ^ m` divides `y ^ p`. In terms of number theory, it means that if two numbers commute and the `n`-th power of their difference is zero, then the `m`-th power of the first number is a divisor of the `p`-th power of the second number, given that the sum of `n` and `m` does not exceed `p + 1`.

If `x` and `y` are commuting elements in a ring, and `(x - y)^n = 0` for some natural number `n`, then `x^m` divides `y^(n+m)` for any natural number `m` with `n+m <= p+1`.


theorem Finset.sum_const_nat :
    ∀ {α : Type u_3} {s : Finset α} {m : ℕ} {f : α → ℕ},
      (∀ x ∈ s, f x = m) → (Finset.sum s fun x => f x) = s.card * m :=
  by sorry

The theorem `Finset.sum_const_nat` states that for any type `α`, any finite set `s` of type `α`, any natural number `m`, and any function `f` from `α` to `ℕ` (natural numbers), if every element `x` in `s` maps to `m` under `f` (i.e., `f(x) = m` for all `x` in `s`), then the sum of `f(x)` as `x` ranges over the elements of the finite set `s` is equal to the cardinality of `s` (number of elements in `s`) multiplied by `m`.

For any type `α`, finite set `s` of type `α`, natural number `m`, and function `f` from `α` to `ℕ` with `f(x) = m` for all `x` in `s`, we have `∑ x in s, f x = |s| * m`, where `|s|` denotes the cardinality of `s`.


theorem HahnSeries.add_coeff :
    ∀ {Γ : Type u_1} {R : Type u_2} [inst : PartialOrder Γ] [inst_1 : AddMonoid R] {x y : HahnSeries Γ R} {a : Γ},
      (x + y).coeff a = x.coeff a + y.coeff a :=
  by sorry

This theorem is about Hahn series. It states that for any two Hahn series `x` and `y` over a partially ordered set `Γ` and an additive monoid `R`, the coefficient of a term with index `a` in the sum of `x` and `y` is equal to the sum of the coefficients of the term with index `a` in `x` and `y`. Formally, `(x + y).coeff a = x.coeff a + y.coeff a`. It essentially describes the distributive property of addition over the coefficients of Hahn Series.

For Hahn series x and y over a partially ordered set Γ and an additive monoid R, the coefficient of index a in their sum is equal to the sum of the coefficients of index a in x and y: (x + y).coeff a = x.coeff a + y.coeff a.


theorem LinearOrderedField.coe_lt_inducedMap_iff :
    ∀ {α : Type u_2} {β : Type u_3} [inst : LinearOrderedField α] [inst_1 : ConditionallyCompleteLinearOrderedField β]
      [inst_2 : Archimedean α] {a : α} {q : ℚ}, ↑q < LinearOrderedField.inducedMap α β a ↔ ↑q < a :=
  by sorry

This theorem states that for all types `α` and `β`, where `α` is a linear ordered field and `β` is a conditionally complete linear ordered field, and where `α` is also Archimedean, for any element `a` of type `α` and any rational number `q`, the condition that the rational `q` is less than the image of `a` under the induced order preserving function from `α` to `β` is equivalent to `q` being less than `a`. In mathematical terms, the theorem asserts that for an arbitrary real number `a` and rational `q`, the inequality $q < \sup\{r \in \mathbb{Q} : r < a\}$ holds if and only if $q < a$.

For any Archimedean linear ordered field `α` and conditionally complete linear ordered field `β`, the image of an element `a` from `α` under the order-preserving function to `β` is equal to the supreme element in the set of rationals strictly less than `a`. That is, for all `a` in `α` and rational `q`, `q < a` if and only if `q < sup {r : ℚ | r < a}`.


theorem MonotoneOn.reflect_lt :
    ∀ {α : Type u} {β : Type v} [inst : LinearOrder α] [inst_1 : Preorder β] {f : α → β} {s : Set α},
      MonotoneOn f s → ∀ {a b : α}, a ∈ s → b ∈ s → f a < f b → a < b :=
  by sorry

This theorem, `MonotoneOn.reflect_lt`, states that for any types `α` and `β` where `α` is a linear order and `β` is a preorder, if a function `f` from `α` to `β` is monotone on a set `s` of `α`, then for any two elements `a` and `b` in `s`, if `f(a)` is less than `f(b)`, it must be the case that `a` is less than `b`. Essentially, it asserts that the ordering of the function values reflects the ordering of the inputs for any two elements in the set where the function is monotone.

If `f` is a monotone function from a linearly ordered type `α` to a preordered type `β`, and `a` and `b` are in `α` with `a` less than `b` and `f(a)` less than `f(b)`, then `a` is less than `b` in `α`.


theorem Rat.divInt_neg' : ∀ (num den : ℤ), Rat.divInt num (-den) = Rat.divInt (-num) den := by sorry

This theorem, `Rat.divInt_neg'`, states that for any two integers `num` and `den`, the quotient of `num` divided by the negative of `den` is equal to the quotient of the negative of `num` divided by `den`. In other words, it confirms the mathematical rule that the division of a number by a negative number is the same as dividing the negative of that number by the positive counterpart. This is typically expressed in mathematical notation as $\frac{num}{-den} = \frac{-num}{den}$.

The theorem `Rat.divInt_neg'` asserts that for all integers `num` and `den`, `num / (-den) = -(num / den)`.


theorem Polynomial.le_trailingDegree_monomial :
    ∀ {R : Type u} {a : R} {n : ℕ} [inst : Semiring R], ↑n ≤ Polynomial.trailingDegree ((Polynomial.monomial n) a) := by
  sorry

The theorem `Polynomial.le_trailingDegree_monomial` states that for any type `R`, any element `a` of `R`, and any natural number `n`, if `R` is a semiring, then the natural number `n`, when considered as an element of extended natural numbers, is less than or equal to the trailing degree of the polynomial formed by `a * X^n`. In other words, the smallest power of X that appears in the monomial `a * X^n` is `n` itself, or a lesser power if `a` is zero.

For any semiring R, any element a in R, and natural number n, the trailing degree of the polynomial a * X^n is at least n.


/-- Let `f` be a function continuous on a convex (or, equivalently, connected) subset `D`
of the real line. If `f` is differentiable on the interior of `D` and `f'` is nonpositive, then
`f` is an antitone function on `D`.  -/
theorem antitoneOn_of_deriv_nonpos :
    ∀ {D : Set ℝ},
      Convex ℝ D →
        ∀ {f : ℝ → ℝ},
          ContinuousOn f D → DifferentiableOn ℝ f (interior D) → (∀ x ∈ interior D, deriv f x ≤ 0) → AntitoneOn f D :=
  by sorry

The theorem `antitoneOn_of_deriv_nonpos` states that, given a function `f` that is continuous on a convex (or equivalently, connected) subset `D` of the real line, if `f` is differentiable on the interior of `D` and the derivative of `f` is nonpositive (i.e., less than or equal to zero) throughout the interior of `D`, then `f` is an antitone function on `D`. An antitone function is one for which an increase in the input value results in a decrease in the output value. In other words, for any two points in `D`, if the first point is less than or equal to the second, then the value of `f` at the second point is less than or equal to the value of `f` at the first point.

If a continuous, convex function `f` with a nonpositive derivative on its interior is differentiable, then `f` is antitone on its domain.


theorem measurable_of_Ioi :
    ∀ {α : Type u_1} {δ : Type u_5} [inst : TopologicalSpace α] [inst_1 : MeasurableSpace α] [inst_2 : BorelSpace α]
      [inst_3 : MeasurableSpace δ] [inst_4 : LinearOrder α] [inst_5 : OrderTopology α]
      [inst : SecondCountableTopology α] {f : δ → α}, (∀ (x : α), MeasurableSet (f ⁻¹' Set.Ioi x)) → Measurable f :=
  by sorry

The theorem `measurable_of_Ioi` states that for any type `α` with a topological space, measurable space, Borel space, linear order, order topology, and second countable topology, and any type `δ` with a measurable space, if we have a function `f` from `δ` to `α` such that the preimage of every left-open right-infinite interval `(x, ∞)` under `f` is a measurable set, then `f` itself is measurable. In other words, `f` is measurable if and only if the preimage of every interval of the form `(x, ∞)` is measurable.

If `δ` is a measurable space and `f: δ → α` is a function with `α` being a second countable topological space, measurable space, Borel space, linearly ordered set, and having the order topology, then `f` is measurable if and only if for all `x ∈ δ`, the preimage `f⁻ⁱ((x, ∞))` is a measurable set.


theorem Associated.prime_iff :
    ∀ {α : Type u_1} [inst : CommMonoidWithZero α] {p q : α}, Associated p q → (Prime p ↔ Prime q) := by sorry

The theorem `Associated.prime_iff` states that for any type `α` that is a commutative monoid with zero, and any two elements `p` and `q` of `α`, if `p` and `q` are associated (meaning one can be obtained by multiplying the other by a unit), then `p` is a prime element if and only if `q` is a prime element. A prime element in this context is an element that is not zero, not a unit, and if it divides the product of two other elements, then it must divide at least one of them.

If `p` and `q` are associated elements in a commutative monoid with zero, then `p` is prime if and only if `q` is prime.


theorem Matrix.mul_inv_rev :
    ∀ {n : Type u'} {α : Type v} [inst : Fintype n] [inst_1 : DecidableEq n] [inst_2 : CommRing α] (A B : Matrix n n α),
      (A * B)⁻¹ = B⁻¹ * A⁻¹ :=
  by sorry

This theorem states that for any type `n` and a type `α` with a commutative ring structure, given any finite type `n` (with decidable equality) and any two square matrices `A` and `B` with entries in `α`, the inverse of the product of `A` and `B` is equal to the product of the inverse of `B` and the inverse of `A`, in that order. This is essentially stating the rule of reversing the order of multiplication when taking the inverse of a product of two elements, but for matrices. In mathematical terms, given two matrices $(A,B)$, we have $(AB)^{-1} = B^{-1}A^{-1}$.

For any commutative ring `α` and finite type `n` with decidable equality, if `A` and `B` are square matrices of size `n x n` over `α` with inverses, then `A⁻¹ * B⁻¹ = B⁻¹ * A⁻¹`.


theorem Finset.eq_of_not_mem_of_mem_insert :
    ∀ {α : Type u_1} [inst : DecidableEq α] {s : Finset α} {a b : α}, b ∈ insert a s → b ∉ s → b = a := by sorry

This theorem states that for any type `α` with decidable equality, given a finite set `s` of type `α`, and any two elements `a` and `b` of type `α`, if `b` belongs to the set obtained by inserting `a` into `s` (`b ∈ insert a s`), and `b` does not belong to the original set `s` (`b ∉ s`), then `b` must be equal to `a` (`b = a`). In other words, the theorem asserts that, when inserting an element into a finite set, any new element found in the resulting set, which was not in the original, must be the one that was inserted.

Given a finite type `α` with decidable equality, if `a` is an element of `α` not in a finite set `s` of type `α`, and `insert a s` contains an element `b` not equal to `a`, then `b = a`.


theorem Sum.map_map :
    ∀ {α' : Type u_1} {α'' : Type u_2} {β' : Type u_3} {β'' : Type u_4} {α : Type u_5} {β : Type u_6} (f' : α' → α'')
      (g' : β' → β'') (f : α → α') (g : β → β') (x : α ⊕ β),
      Sum.map f' g' (Sum.map f g x) = Sum.map (f' ∘ f) (g' ∘ g) x :=
  by sorry

The theorem `Sum.map_map` states that for any types `α', α'', β', β'', α, β`, and for any functions `f': α' → α''`, `g': β' → β''`, `f: α → α'`, `g: β → β'`, and for any value `x` of type `α ⊕ β`, applying the function `Sum.map` twice in a row is the same as applying it once with the composition of the two initial functions. In other words, mapping twice sequentially is the same as mapping once with the composite function. This is an example of the property of function composition in the context of sum types.

For any sum types `α ⊕ β`, functions `f: α → α'`, `g: β → β'`, `f': α' → α''`, `g': β' → β''`, and values `x` of type `α ⊕ β`, `Sum.map (f' ∘ g) x = Sum.map (g') (Sum.map f x)`.


theorem Function.LeftInverse.list_map :
    ∀ {α : Type u} {β : Type v} {f : α → β} {g : β → α},
      Function.LeftInverse f g → Function.LeftInverse (List.map f) (List.map g) :=
  by sorry

The theorem `Function.LeftInverse.list_map` states that for any two types `α` and `β`, and any two functions `f : α → β` and `g : β → α`, if `g` is a left inverse to `f`, then `List.map g` is a left inverse to `List.map f`. In other words, if applying `g` after `f` returns the original input (i.e., `g ∘ f = id`), then applying `List.map g` after `List.map f` on any list will return the original list.

If functions `f : α → β` and `g : β → α` satisfy `g ∘ f = id_{\alpha}`, then `List.map g ∘ List.map f = id_{List α}`.


theorem MeasureTheory.Measure.restrict_zero :
    ∀ {α : Type u_2} {_m0 : MeasurableSpace α} (s : Set α), 0.restrict s = 0 := by sorry

This theorem, `MeasureTheory.Measure.restrict_zero`, states that for any given type `α` and any measurable space of type `α`, when we restrict the zero measure to any set `s` of type `α`, it remains the zero measure. This essentially means that the restriction of the zero measure to any set is still the zero measure. In mathematical terms, given a measure space (denoted by `α` and `_m0`), for all subsets `s` in that space, the restrict function applied to the zero measure and `s` will always yield the zero measure.

For any measurable space `(α, _m0)` and subset `s` of `α`, the restriction of the zero measure `m0` to `s` is still the zero measure, i.e., `m0.restrict s = 0`.


theorem Multiset.mem_ndinsert :
    ∀ {α : Type u_1} [inst : DecidableEq α] {a b : α} {s : Multiset α}, a ∈ Multiset.ndinsert b s ↔ a = b ∨ a ∈ s := by
  sorry

This theorem states that for any type `α` with a decidable equality relation, and given any elements `a` and `b` of type `α` and a multiset `s` of type `α`, the element `a` belongs to the multiset resulting from non-duplicate inserting `b` into `s` if and only if `a` is equal to `b` or `a` already belongs to `s`. In other words, after you insert an element `b` into a multiset `s` using the non-duplicate insert operation, an element `a` is in the resulting multiset if `a` was either the element you inserted, or it was already in the original multiset.

For any decidably equal type `α` and multisets `s` of `α`, an element `a` is in the multiset obtained by non-duplicate insertion of `b` into `s` if and only if `a` is equal to `b` or already in `s`.


theorem ContDiffBump.integral_pos :
    ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [inst_2 : HasContDiffBump E]
      [inst_3 : MeasurableSpace E] {c : E} (f : ContDiffBump c) {μ : MeasureTheory.Measure E} [inst_4 : BorelSpace E]
      [inst_5 : FiniteDimensional ℝ E] [inst_6 : MeasureTheory.IsLocallyFiniteMeasure μ]
      [inst_7 : MeasureTheory.Measure.IsOpenPosMeasure μ], 0 < ∫ (x : E), ↑f x ∂μ :=
  by sorry

This theorem states that for any normed additive commutative group `E` (which also has a normed space over real numbers, and possesses a continuously differentiable "bump" function), given a measure `μ` on `E` which is both locally finite and positive on open sets, and a specific continuously differentiable bump function `f` centered at a point `c` in `E`, then the integral of `f` with respect to `μ` is always positive. Here, `E` is also assumed to be a Borel space and a finite-dimensional vector space over the real numbers.

For any normed additive commutative group `E` (Borel, finite-dimensional over the real numbers) with a continuously differentiable "bump" function, a locally finite and positive measure `μ` on `E`, and a continuously differentiable bump function `f` centered at a point `c` in `E`, the integral of `f` with respect to `μ` is positive.


theorem Polynomial.mem_rootSet_of_ne :
    ∀ {T : Type w} [inst : CommRing T] {p : Polynomial T} {S : Type u_1} [inst_1 : CommRing S] [inst_2 : IsDomain S]
      [inst_3 : Algebra T S] [inst_4 : NoZeroSMulDivisors T S],
      p ≠ 0 → ∀ {a : S}, a ∈ Polynomial.rootSet p S ↔ (Polynomial.aeval a) p = 0 :=
  by sorry

This theorem states that for any commutative ring `T` and a polynomial `p` over `T`, any type `S` that is a commutative ring, a domain, and an algebra over `T` with no zero `T`-`S` mul divisors, if the polynomial `p` is not the zero polynomial, then a member `a` of type `S` is in the set of distinct roots of `p` in `S` (i.e., `Polynomial.rootSet p S`) if and only if applying the algebra homomorphism given by evaluating the polynomial `p` at `a` (i.e., `(Polynomial.aeval a) p`) results in zero. This theorem essentially describes the condition for an element to be a root of a polynomial in the context of algebraic structures.

For a commutative ring `T`, a polynomial `p` over `T`, a commutative ring and domain `S` an algebra over `T`, and an element `a` in `S` with no zero `T-S` multiplicative divisors, `a` is a root of `p` in `S` if and only if evaluating `p` at `a` results in zero.


IntermediateField.adjoin.mono

theorem IntermediateField.adjoin.mono :
    ∀ (F : Type u_1) [inst : Field F] {E : Type u_2} [inst_1 : Field E] [inst_2 : Algebra F E] (S T : Set E),
      S ⊆ T → IntermediateField.adjoin F S ≤ IntermediateField.adjoin F T :=
  by sorry

This theorem, `IntermediateField.adjoin.mono`, asserts that for any field `F` and any field extension `E` over `F` with the property that `E` is an `F`-algebra, if `S` and `T` are two subsets of `E` such that `S` is a subset of `T`, then the intermediate field generated by adjoining `S` to `F` is a subfield of the intermediate field generated by adjoining `T` to `F`. In other words, adjoins operation on subsets of `E` is monotone with respect to the subset inclusion relation.

If `F` is a field, `E` is a field extension of `F` that is an `F`-algebra, and `S` is a subset of `T` in `E`, then the subfield generated by `S` over `F` is contained in the subfield generated by `T` over `F`.


theorem Matrix.IsHermitian.eigenvalues_eq :
    ∀ {𝕜 : Type u_1} [inst : RCLike 𝕜] {n : Type u_2} [inst_1 : Fintype n] {A : Matrix n n 𝕜} [inst_2 : DecidableEq n]
      (hA : Matrix.IsHermitian A) (i : n),
      Matrix.IsHermitian.eigenvalues hA i =
        RCLike.re
          (Matrix.dotProduct (star (Matrix.transpose (Matrix.IsHermitian.eigenvectorMatrix hA) i))
            (Matrix.mulVec A (Matrix.transpose (Matrix.IsHermitian.eigenvectorMatrix hA) i))) :=
  by sorry

The theorem `Matrix.IsHermitian.eigenvalues_eq` states that for any Hermitian matrix `A` of size `n` with entries in a ring `𝕜` that behaves like the reals (i.e., `RCLike 𝕜`), and for any index `i` of type `n`, the `i`-th eigenvalue of `A` equals the real part of the dot product between the conjugated transpose of the `i`-th column of the orthonormal eigenvector matrix of `A` and the result of multiplying `A` by that `i`-th column. In other words, it relates the eigenvalues of a Hermitian matrix to the dot product of its eigenvectors and the corresponding matrix-vector multiplication.

For any Hermitian matrix `A` of size `n` over a ring `𝕜` that behaves like the reals, the `i`-th eigenvalue of `A` is equal to the real part of the dot product between the conjugate transpose of the `i`-th column of its eigenvector matrix and the product of `A` and that column.


theorem Finset.antidiagonal_zero :
    ∀ {A : Type u_1} [inst : CanonicallyOrderedAddCommMonoid A] [inst_1 : Finset.HasAntidiagonal A],
      Finset.antidiagonal 0 = {(0, 0)} :=
  by sorry

This theorem states that for any type `A` that is a canonically ordered additive commutative monoid and has an antidiagonal, the antidiagonal of `0` is the set containing only the pair `(0, 0)`. In more mathematical terms, if we consider an element from a set `A` that satisfies the properties of an additive commutative monoid with a canonical order and has the additional property of an antidiagonal, the antidiagonal of the additive identity (which is `0` in this context) is the set containing only the pair `(0, 0)`.

For any additive commutative monoid `A` with a canonical order and an antidiagonal, the antidiagonal of `0` is the singleton set `{(0, 0)}`.


theorem AddSubgroup.map_map :
    ∀ {G : Type u_1} [inst : AddGroup G] (K : AddSubgroup G) {N : Type u_5} [inst_1 : AddGroup N] {P : Type u_6}
      [inst_2 : AddGroup P] (g : N →+ P) (f : G →+ N),
      AddSubgroup.map g (AddSubgroup.map f K) = AddSubgroup.map (AddMonoidHom.comp g f) K :=
  by sorry

The theorem `AddSubgroup.map_map` states that for any additive groups `G`, `N`, and `P`, any subgroup `K` of `G`, and any additive monoid homomorphisms `f` from `G` to `N` and `g` from `N` to `P`, the image of the subgroup `K` under the composite homomorphism `g ∘ f` is the same as the image of the image of `K` under `f` under `g`. In other words, the `map` operation on subgroups is compatible with the composition of homomorphisms, or in notation, `AddSubgroup.map g (AddSubgroup.map f K) = AddSubgroup.map (AddMonoidHom.comp g f) K`. This is an instance of a basic property in abstract algebra stating that homomorphisms respect the structure of groups.

For any additive groups G, N, and P, subgroup K of G, and additive monoid homomorphisms f : G -> N and g : N -> P, the image of K under the composite homomorphism g ∘ f is equal to the image of the image of K under f, then under g. (AddSubgroup.map g (AddSubgroup.map f K) = AddSubgroup.map (AddMonoidHom.comp g f) K)


theorem OnePoint.nhds_coe_eq :
    ∀ {X : Type u_1} [inst : TopologicalSpace X] (x : X), nhds ↑x = Filter.map OnePoint.some (nhds x) := by sorry

The theorem `OnePoint.nhds_coe_eq` states that for any type `X` with a topology and any element `x` from `X`, the neighborhood filter of the embedded point `x` in the one-point compactification of `X` (represented by `↑x`) is equivalent to the image of the neighborhood filter of `x` under the map `OnePoint.some`. In other words, the neighborhoods of `x` in the extended space are the same as the images of the neighborhoods of `x` in the original space under the embedding `OnePoint.some`.

The neighborhood filter of an element `x` in the one-point compactification of a topological space `X` is equal to the image of the neighborhood filter of `x` in `X` under the embedding `OnePoint.some`.


theorem AddLocalization.r_iff_exists :
    ∀ {M : Type u_1} [inst : AddCommMonoid M] {S : AddSubmonoid M} {x y : M × ↥S},
      (AddLocalization.r S) x y ↔ ∃ c, ↑c + (↑y.2 + x.1) = ↑c + (↑x.2 + y.1) :=
  by sorry

The theorem `AddLocalization.r_iff_exists` states that for any pair of elements `x` and `y` in the cartesian product of an additive commutative monoid `M` and an additive submonoid `S` of `M`, the elements `x` and `y` are related by the localization relation `AddLocalization.r` of `M` at `S` if and only if there exists an element `c` in `S` such that the sum of the second component of `y` and the first component of `x`, both lifted to `M` via the canonical map, equals the sum of the second component of `x` and the first component of `y`, again both lifted to `M`. This theorem thus gives a criterion for two elements of the cartesian product `M × S` to be related by the localization relation in terms of the existence of such a `c` in `S`.

For elements `(x, y)` in the cartesian product of an additive commutative monoid `M` and an additive submonoid `S`, `AddLocalization.r(x, y)` if and only if there exists `c` in `S` such that `x + S.(y) = y + S.(x)` in `M`.


theorem Ordinal.type_eq_zero_of_empty :
    ∀ {α : Type u} (r : α → α → Prop) [inst : IsWellOrder α r] [inst_1 : IsEmpty α], Ordinal.type r = 0 := by sorry

The theorem `Ordinal.type_eq_zero_of_empty` states that for any type `α` and any relation `r` on `α`, if `α` is a well-ordered set (as defined by the `IsWellOrder` instance) and also an empty set (as defined by the `IsEmpty` instance), then the ordinal number corresponding to this well-order, denoted as `Ordinal.type r`, is equal to zero. This is because the ordinal of an empty set is defined to be zero.

If a well-ordered and empty set `α` has a corresponding ordinal number, then this ordinal number is equal to zero.


theorem Set.le_einfsep_iff :
    ∀ {α : Type u_1} [inst : EDist α] {s : Set α} {d : ENNReal},
      d ≤ Set.einfsep s ↔ ∀ x ∈ s, ∀ y ∈ s, x ≠ y → d ≤ edist x y :=
  by sorry

This theorem states that for any type `α` with an extended distance (`EDist`) function, any set `s` of elements of type `α`, and any extended nonnegative real number `d`, `d` is less than or equal to the extended infimum separation of the set `s` if and only if for all distinct elements `x` and `y` in the set `s`, `d` is less than or equal to the extended distance between `x` and `y`. In other words, `d` is bounded below by the minimum extended distance between any two distinct elements of the set `s`.

For any set `s` of elements in a type `α` with an extended distance function, and any extended nonnegative real number `d`, `d` is less than or equal to the extended infimum separation of `s` if and only if it is less than or equal to the minimum extended distance between any distinct elements of `s`.


/-- Congruence relations equal the smallest congruence relation in which they are contained.  -/
theorem RingCon.ringConGen_of_ringCon :
    ∀ {R : Type u_2} [inst : Add R] [inst_1 : Mul R] (c : RingCon R), ringConGen ⇑c = c := by sorry

This theorem states that for any given ring `R` with addition and multiplication operations, and a given congruence relation `c` on `R`, the smallest congruence relation containing `c` (generated by the function `ringConGen`) is equal to `c` itself. In other words, the congruence relation `c` is equivalent to the smallest congruence relation that includes it.

For any ring `R` and congruence relation `c` on `R`, `c` is equal to the smallest congruence relation containing `c` (generated by `ringConGen`).


/-- For `a : 𝓜(𝕜, A)`, the norms of `a.fst` and `a.snd` coincide, and hence these
also coincide with `‖a‖` which is `max (‖a.fst‖) (‖a.snd‖)`.  -/
theorem DoubleCentralizer.norm_fst_eq_snd :
    ∀ {𝕜 : Type u_1} {A : Type u_2} [inst : NontriviallyNormedField 𝕜] [inst_1 : NonUnitalNormedRing A]
      [inst_2 : NormedSpace 𝕜 A] [inst_3 : SMulCommClass 𝕜 A A] [inst_4 : IsScalarTower 𝕜 A A] [inst_5 : StarRing A]
      [inst_6 : CstarRing A] (a : DoubleCentralizer 𝕜 A), ‖a.toProd.1‖ = ‖a.toProd.2‖ :=
  by sorry

This theorem states that for every `a`, which is an element of the double centralizer of `𝕜` over `A`, the norms of the first and second components of `a` are equal. Here, `𝕜` is a nontrivially normed field, `A` is a non-unital normed ring that is also a star ring and a C* ring, and it forms a normed space over `𝕜`. Moreover, `𝕜` and `A` have the scalar multiplication commutativity property and `𝕜` is a scalar tower over `A`. The norm of `a` is defined as the maximum of the norms of its first and second components.

For every element `a` in the double centralizer of a nontrivially normed field `𝕜` over a non-unital normed ring `A` that is a star ring and C*, if `a` has first and second components, then the norms of these components are equal.


/-- If the quotient by an ideal is a field, then the ideal is maximal.  -/
theorem Ideal.Quotient.maximal_of_isField :
    ∀ {R : Type u} [inst : CommRing R] (I : Ideal R), IsField (R ⧸ I) → Ideal.IsMaximal I := by sorry

This theorem states that for any commutative ring `R` and an ideal `I` of `R`, if the quotient of `R` by `I` forms a field, then the ideal `I` is a maximal ideal. In the context of ring theory, a maximal ideal is an ideal that is maximal in the set of all proper ideals, i.e., it is larger than all other proper ideals, but is not the entire ring itself. This theorem is essentially a characterization of maximal ideals in terms of quotient fields.

In commutative ring theory, an ideal is maximal if and only if the quotient ring forms a field.