theorem tsum_nonneg :
    ∀ {ι : Type u_1} {α : Type u_3} [inst : OrderedAddCommMonoid α] [inst_1 : TopologicalSpace α]
      [inst_2 : OrderClosedTopology α] {g : ι → α}, (∀ (i : ι), 0 ≤ g i) → 0 ≤ ∑' (i : ι), g i :=
  by sorry

The theorem `tsum_nonneg` states that for any type `ι` and any type `α` that is an ordered additive commutative monoid (a structure with a concept of order and an operation of addition that is commutative) and also a topological space (a mathematical structure that allows for the definition of concepts like continuity and convergence), and with a topology that is closed with respect to the order, if we have a function `g` from `ι` to `α` such that all values of `g` are nonnegative (i.e., greater than or equal to zero), then the series sum of `g` over all `ι` is also nonnegative. In simpler terms, the sum of all nonnegative values in a series is also nonnegative.

For any ordered additive commutative monoid and topology where the order is closed, if every element of a function from the index set to the monoid is nonnegative, then the series sum of the function is nonnegative.


theorem MeasureTheory.integral_add_measure :
    ∀ {α : Type u_1} {G : Type u_5} [inst : NormedAddCommGroup G] [inst_1 : NormedSpace ℝ G] {m : MeasurableSpace α}
      {μ ν : MeasureTheory.Measure α} {f : α → G},
      MeasureTheory.Integrable f μ →
        MeasureTheory.Integrable f ν → ∫ (x : α), f x ∂(μ + ν) = ∫ (x : α), f x ∂μ + ∫ (x : α), f x ∂ν :=
  by sorry

The theorem `MeasureTheory.integral_add_measure` states that for any given types `α` and `G` where `G` is a normed additive commutative group and also a normed space over real numbers, and `α` is endowed with a measurable space structure `m`, given two measures `μ` and `ν` on `α`, and for any function `f` from `α` to `G`, if `f` is integrable with respect to both `μ` and `ν`, then the integral of `f` with respect to the sum of measures `μ` and `ν` is equal to the sum of the integral of `f` with respect to `μ` and the integral of `f` with respect to `ν`. In other words, the integral of `f` over the sum measure is the sum of the integrals over the individual measures.

For measurable functions between a normed additive commutative group endowed with two measures, the integral of the function with respect to the sum of the measures equals the sum of the integrals with respect to each measure.


theorem Multiset.fold_dedup_idem :
    ∀ {α : Type u_1} (op : α → α → α) [hc : Std.Commutative op] [ha : Std.Associative op] [inst : DecidableEq α]
      [hi : Std.IdempotentOp op] (s : Multiset α) (b : α),
      Multiset.fold op b (Multiset.dedup s) = Multiset.fold op b s :=
  by sorry

The theorem `Multiset.fold_dedup_idem` states that for any type `α` with a decidable equality, a binary operation `op` that is commutative, associative, and idempotent, a multiset `s` of type `α`, and an element `b` of type `α`, the result of folding `op` over the deduplicated multiset `s` with initial element `b` is the same as folding `op` over `s` with initial element `b`. In simpler terms, it means that if we remove duplicates from the multiset before folding, the result is the same as if we didn't remove duplicates, as long as the operation `op` is idempotent (applying `op` twice or more times to the same elements gives the same result as applying it once).

For any commutative, associative, and idempotent binary operation `op` on type `α` with decidable equality, and any multiset `s` of type `α` and element `b` of type `α`, the result of folding `op` over the deduplicated multiset `s` with initial element `b` is equal to folding `op` over `s` with initial element `b`.


theorem hasDerivAtFilter_const :
    ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {F : Type v} [inst_1 : NormedAddCommGroup F]
      [inst_2 : NormedSpace 𝕜 F] (x : 𝕜) (L : Filter 𝕜) (c : F), HasDerivAtFilter (fun x => c) 0 x L :=
  by sorry

The theorem `hasDerivAtFilter_const` asserts that for all types `𝕜` with a nontrivial normed field structure, all types `F` with a normed additive commutative group structure, and any value `x` of type `𝕜`, any filter `L` on `𝕜`, and any value `c` of type `F`, the function which sends all inputs to `c` has a derivative of `0` at point `x` along the filter `L`. In other words, a constant function has a zero derivative everywhere, in the sense of Frechet derivatives.

For any normed field `𝕜` and normed additive commutative group `F`, a constant function from `𝕜` to `F` has a Frechet derivative of 0 at every point in `𝕜`.


theorem Absorbs.mono_left :
    ∀ {M : Type u_1} {α : Type u_2} [inst : Bornology M] [inst_1 : SMul M α] {s₁ s₂ t : Set α},
      Absorbs M s₁ t → s₁ ⊆ s₂ → Absorbs M s₂ t :=
  by sorry

The theorem `Absorbs.mono_left` states that for any types `M` and `α`, where `M` has a structure of Bornology and `α` has a structure of scalar multiplication (`SMul`) by `M`, given three sets `s₁`, `s₂`, and `t` of type `α`, if the set `s₁` absorbs the set `t`, and `s₁` is a subset of `s₂`, then it follows that `s₂` also absorbs `t`. In other words, the absorption property is monotonic on the left side: enlarging an absorbing set preserves the absorbing property.

If `M` is a Bornology and `α` is an `SMul σ M`, and `s₁` absorbs `t` in `α` and `s₁` is a subset of `s₂`, then `s₂` absorbs `t`.


theorem lt_of_pow_lt_pow_left :
    ∀ {R : Type u_3} [inst : LinearOrderedSemiring R] {a b : R} (n : ℕ), 0 ≤ b → a ^ n < b ^ n → a < b := by sorry

This theorem states that for any linearly ordered semiring `R` and any two elements `a` and `b` of `R`, if `b` is nonnegative and `a` raised to the power of `n` is less than `b` raised to the power of `n`, then `a` must be less than `b`. Essentially, in a number system that behaves like the real numbers, if the `n`th power of `a` is less than the `n`th power of `b` (with `b` being nonnegative), then `a` is less than `b`.

If `R` is a linearly ordered semiring, `a`, `b` are in `R` with `b` nonnegative, and `a^n < b^n`, then `a < b`.


theorem Set.Finite.isLindelof_biUnion :
    ∀ {X : Type u} {ι : Type u_1} [inst : TopologicalSpace X] {s : Set ι} {f : ι → Set X},
      Set.Finite s → (∀ i ∈ s, IsLindelof (f i)) → IsLindelof (⋃ i ∈ s, f i) :=
  by sorry

This theorem states that for any type `X` equipped with a topological space structure, any set `s` of indices of type `ι`, and for any function `f` mapping indices to sets in `X`, if `s` is a finite set and every set `f(i)` is Lindelöf for each `i` in `s`, then the union of all `f(i)` for `i` in `s` is also a Lindelöf set. Recalling the definition, a Lindelöf set is one where each filter with the countable intersection property that contains the set has a cluster point in the set. So, the theorem essentially states a property about unions of Lindelöf sets in the context of a topological space.

Given a topological space `X` and a finite set `s` of indices, if each `f(i)` is a Lindelöf set in `X` for every function `f` mapping indices to sets in `X`, then the union of all `f(i)` for `i` in `s` is also a Lindelöf set in `X`.


theorem Polynomial.C_mul_X_eq_monomial :
    ∀ {R : Type u} {a : R} [inst : Semiring R], Polynomial.C a * Polynomial.X = (Polynomial.monomial 1) a := by sorry

The theorem `Polynomial.C_mul_X_eq_monomial` states that for any semiring `R` and any element `a` of `R`, the multiplication of the constant polynomial `a` (`Polynomial.C a`) with the polynomial variable (`Polynomial.X`) results in the monomial `a * X^1` (`Polynomial.monomial 1 a`). In other words, it declares the relationship that multiplying a constant polynomial by a polynomial variable is equivalent to creating a monomial with coefficient `a` and degree 1 in the context of a semiring.

For any semiring and element, the constant polynomial times the polynomial variable equals the monomial with coefficient the constant and degree 1.


theorem QuotientGroup.rightRel_apply :
    ∀ {α : Type u_1} [inst : Group α] {s : Subgroup α} {x y : α}, Setoid.r x y ↔ y * x⁻¹ ∈ s := by sorry

This theorem, "QuotientGroup.rightRel_apply", states that for any type `α` that has a group structure, given a subgroup `s` of `α` and any two elements `x` and `y` of `α`, `x` is related to `y` under the distinguished equivalence relation of the setoid if and only if the product of `y` and the inverse of `x` belongs to the subgroup `s`. This theorem ties the concept of equivalence relation to the algebraic structure of groups and subgroups.

For any group `α` and subgroup `s`, `x ≃ y` if and only if `y * x^-1 ∈ s`, where `≃` denotes the equivalence relation on `α` induced by the subgroup `s`.


/-- A singleton set is a Lindelof set.  -/
theorem isLindelof_singleton : ∀ {X : Type u} [inst : TopologicalSpace X] {x : X}, IsLindelof {x} := by sorry

The theorem states that a singleton set is always a Lindelöf set. More specifically, for any type `X` equipped with a topological space structure and for any element `x` of `X`, the singleton set consisting of just `x` satisfies the property of being Lindelöf. This means that if we take any non-trivial filter `f` with a countable intersection property that contains the singleton set `{x}`, there always exists a cluster point in the set `{x}`.

For any topological space `(X, top)` and element `x` in `X`, the singleton set `{x}` is a Lindelöf space.


theorem Set.disjoint_of_subset_left : ∀ {α : Type u} {s t u : Set α}, s ⊆ u → Disjoint u t → Disjoint s t := by sorry

The theorem `Set.disjoint_of_subset_left` states that for any type `α` and any sets `s`, `t`, and `u` of that type, if `s` is a subset of `u` and `u` is disjoint from `t`, then `s` is also disjoint from `t`. In other words, if all elements of `s` are also elements of `u` and no element of `u` can be an element of `t`, then no element of `s` can be an element of `t`. This theorem generalizes the intuitive notion of disjoint sets, and is relevant in the context of partial orders and lattice theory.

If a subset `s` of type `α` is contained in another set `u` and `u` is disjoint from set `t`, then `s` is disjoint from `t`.


theorem Set.image_update_uIcc :
    ∀ {ι : Type u_1} {α : ι → Type u_2} [inst : (i : ι) → Lattice (α i)] [inst_1 : DecidableEq ι] (f : (i : ι) → α i)
      (i : ι) (a b : α i),
      Function.update f i '' Set.uIcc a b = Set.uIcc (Function.update f i a) (Function.update f i b) :=
  by sorry

This theorem states that for any type `ι`, any function `α : ι → Type u_2` that maps each element of `ι` to a type that forms a lattice, a decidable equality on `ι`, a function `f : ι → α i`, an index `i` in `ι`, and two elements `a` and `b` of `α i`, the image under the update function of the upper interval `uIcc a b` is the same as the upper interval formed by updating `f` at `i` with `a` and `b`. In simpler terms, updating the function's values at a point within a given interval and computing the image yields the same result as directly updating the interval endpoints.

For any lattice-valued function `f` and decidable equality on type `ι`, the image under `f` of the upper interval `uIcc a b` is equal to the upper interval with endpoints updated to `f i a` and `f i b`.


Matrix.IsHermitian.transpose

theorem Matrix.IsHermitian.transpose :
    ∀ {α : Type u_1} {n : Type u_4} [inst : Star α] {A : Matrix n n α},
      Matrix.IsHermitian A → Matrix.IsHermitian (Matrix.transpose A) :=
  by sorry

This theorem states that for any hermitian matrix `A`, its transpose is also hermitian. A matrix is defined as hermitian if it is equal to its conjugate transpose. In the context of real numbers, hermitian matrices are equivalent to symmetric matrices. Thus, this theorem essentially asserts that the property of being hermitian is preserved under transposition.

For any hermitian matrix `A`, its transpose `A^T` is also hermitian, i.e., `A^T = conjg(A)^T`, where `conjg(A)` is the conjugate transpose of `A`.


theorem multiplicity.finite_mul :
    ∀ {α : Type u_1} [inst : CancelCommMonoidWithZero α] {p a b : α},
      Prime p → multiplicity.Finite p a → multiplicity.Finite p b → multiplicity.Finite p (a * b) :=
  by sorry

This theorem, `multiplicity.finite_mul`, states that for any type `α` that is a cancellative commutative monoid with zero, for any elements `p`, `a`, and `b` of `α`, if `p` is a prime element and the multiplicity of `p` in `a` and `b` is finite, then the multiplicity of `p` in the product `a * b` is also finite. In other words, if a prime number appears a finite number of times as a factor in `a` and `b`, then it also appears a finite number of times in the product of `a` and `b`.

If `α` is a cancellative commutative monoid with zero, `p` is a prime element of `α`, and the multiplicities of `p` in `a` and `b` are finite, then the multiplicity of `p` in the product `a * b` is also finite.


theorem Set.ncard_union_eq :
    ∀ {α : Type u_1} {s t : Set α},
      Disjoint s t →
        autoParam (Set.Finite s) _auto✝ →
          autoParam (Set.Finite t) _auto✝¹ → Set.ncard (s ∪ t) = Set.ncard s + Set.ncard t :=
  by sorry

The theorem `Set.ncard_union_eq` states that for any type `α` and any two sets `s` and `t` of this type, if `s` and `t` are disjoint (i.e., their intersection is the bottom or empty set), and both `s` and `t` are finite sets (which is an automatically inferred assumption), then the cardinality of the union of `s` and `t` is equal to the sum of the cardinalities of `s` and `t`. In other words, the size of the union of two disjoint finite sets is the sum of the sizes of the two sets.

If two finite sets are disjoint, then the cardinality of their union is the sum of their cardinalities.


/-- An infinite sum of functions with summable sup norm is the uniform limit of its partial sums.
Version relative to a set, with general index set.  -/
theorem tendstoUniformlyOn_tsum :
    ∀ {α : Type u_1} {β : Type u_2} {F : Type u_3} [inst : NormedAddCommGroup F] [inst_1 : CompleteSpace F] {u : α → ℝ}
      {f : α → β → F},
      Summable u →
        ∀ {s : Set β},
          (∀ (n : α), ∀ x ∈ s, ‖f n x‖ ≤ u n) →
            TendstoUniformlyOn (fun t x => Finset.sum t fun n => f n x) (fun x => ∑' (n : α), f n x) Filter.atTop s :=
  by sorry

This theorem states that, given a type of functions `F` that form a normed additive commutative group and a complete space, a function mapping `α` to real numbers `u`, and a function `f` mapping `α` and `β` to `F`, if `u` is summable, then for any set `s` of type `β`, if for all `n` of type `α`, and for all `x` in `s`, the norm of `f n x` is less than or equal to `u n`, then the sequence of partial sums of `f` (represented as `∑ x in t, f x`) converges uniformly to the infinite sum of `f` (represented as `∑' (n : α), f n x`) as `t` tends to infinity, meaning that the difference between the partial sum and the infinite sum can be made arbitrarily small by choosing a sufficiently large `t`.

In other words, an infinite series of functions whose supremum norm is summable uniformly converges to its infinite sum on a given set, with respect to the filter at infinity. More formally, for any entourage of the diagonal `u` in the uniformity of `F`, after a certain index `t`, for all `x` in the set, the distance between the infinite sum and the partial sum up to `t` is smaller than the entourage `u`.

Given a normed additive commutative group of functions `F`, a complete space, a summable function `u` to real numbers, and a function `f` mapping `α × β` to `F`, if for all `x` in every set `s` of type `β`, the norm of `f n x` is less than or equal to `u n` for all `n` of type `α`, then the sequence of partial sums of `f` uniformly converges to the infinite sum of `f` as `t` approaches infinity.


theorem Ico_mem_nhdsWithin_Ici' :
    ∀ {α : Type u} [inst : TopologicalSpace α] [inst_1 : LinearOrder α] [inst_2 : ClosedIciTopology α] {a b : α},
      a < b → Set.Ico a b ∈ nhdsWithin a (Set.Ici a) :=
  by sorry

This theorem states that for any type `α` that has a topological space structure, a linear order structure, and a right-closed interval topology, and for any two elements `a` and `b` of this type where `a` is less than `b`, the half-open interval from `a` to `b` (i.e., the set of all `x` such that `a` is less than or equal to `x` and `x` is less than `b`) is a member of the "neighborhood within" filter of `a` restricted to the set of all elements greater than or equal to `a`. In other words, the half-open interval from `a` to `b` is a neighborhood of `a` within the set of all elements greater than or equal to `a`. The "neighborhood within" filter is a concept from topology that describes the local behavior of a point within a certain set; in this case, the set of all elements greater than or equal to `a`.

For any type `α` with a topological space, linear order, and right-closed interval topology structure, the half-open interval from `a` to `b` (where `a` is less than `b`) is a neighborhood of `a` within the set of elements greater than or equal to `a`.


theorem Nat.mul_mod_mul_left : ∀ (z x y : ℕ), z * x % (z * y) = z * (x % y) := by sorry

This theorem states that for any three natural numbers `z`, `x`, and `y`, the remainder of the product of `z` and `x` divided by the product of `z` and `y` is equal to the product of `z` and the remainder of `x` divided by `y`. In notation, we can write this as `z*x mod (z*y) = z*(x mod y)`. This is a property of the multiplication and modulus operations in the realm of natural numbers.

For any natural numbers `z`, `x`, and `y`, `z*(x mod y)` equals `z*x mod (z*y)`.


theorem AlgHom.map_adjoin :
    ∀ {R : Type uR} {A : Type uA} {B : Type uB} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Semiring B]
      [inst_3 : Algebra R A] [inst_4 : Algebra R B] (φ : A →ₐ[R] B) (s : Set A),
      Subalgebra.map φ (Algebra.adjoin R s) = Algebra.adjoin R (⇑φ '' s) :=
  by sorry

The theorem `AlgHom.map_adjoin` states that for any commutative semiring `R` and semirings `A` and `B` equipped with algebra structures over `R`, and for any algebra homomorphism `φ` from `A` to `B` and any set `s` of elements from `A`, the image of the subalgebra generated by `s` under the map `φ` is equal to the subalgebra generated by the image of `s` under `φ`. In other words, applying an algebra homomorphism to the subalgebra generated by a set is the same as generating a subalgebra from the image of the set under the homomorphism.

For any commutative semirings `R`, semialgebras `A` and `B` over `R`, algebra homomorphism `φ: A → B`, and set `s ∈ A`, the subalgebra of `B` generated by `φ(s)` is equal to the image of the subalgebra of `A` generated by `s` under `φ`.


theorem Associates.factors_mono :
    ∀ {α : Type u_1} [inst : CancelCommMonoidWithZero α] [inst_1 : UniqueFactorizationMonoid α] {a b : Associates α},
      a ≤ b → Associates.factors a ≤ Associates.factors b :=
  by sorry

The theorem `Associates.factors_mono` states that for any type `α` that has a `CancelCommMonoidWithZero` structure and a `UniqueFactorizationMonoid` structure, and for any two elements `a` and `b` of the `Associates` of `α`, if `a` is less than or equal to `b`, then the multiset of irreducible factors of `a` (represented as a `FactorSet`) is less than or equal to the multiset of irreducible factors of `b`. Here, the `≤` relation for `FactorSets` is defined in terms of the associated partial order on multisets.

For any type `α` with `CancelCommMonoidWithZero` and `UniqueFactorizationMonoid` structures, if `a` and `b` are associates in `α` with `a ≤ b`, then the multiset of irreducible factors of `a` is less than or equal to the multiset of irreducible factors of `b` according to the partial order on multisets.


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

The theorem `List.cons_bagInter_of_neg` asserts that for any type `α`, a list `l₂` of type `α`, an element `a` of type `α`, and any instance of decidable equality on `α` (which allows us to decide if two elements of `α` are equal), given a list `l₁` of type `α`, if `a` is not in `l₂`, then the bag intersection of the list `l₂` with the list that has `a` as its head and `l₁` as its tail, is equal to the bag intersection of `l₁` with `l₂`.

In simpler terms, it states that if an element `a` is not in a list `l₂`, then `a` does not affect the common elements between `l₂` and any list that includes `a` and `l₁`.

If `α` has decidable equality and `a ∉ l₂`, then `bagInter (cons α a l₁) l₂ = bagInter l₁ l₂`.


theorem Nat.coprime_div_gcd_div_gcd : ∀ {m n : ℕ}, 0 < Nat.gcd m n → Nat.Coprime (m / Nat.gcd m n) (n / Nat.gcd m n) :=
  by sorry

The theorem `Nat.coprime_div_gcd_div_gcd` states that for any two natural numbers `m` and `n`, if the greatest common divisor (gcd) of `m` and `n` is greater than zero, then the result of dividing `m` by the gcd of `m` and `n` and the result of dividing `n` by the gcd of `m` and `n` are coprime. In other words, the numbers obtained by dividing `m` and `n` by their gcd are relatively prime, that is, their greatest common divisor is 1.

If the greatest common divisor of natural numbers `m` and `n` is positive, then `m` divided by their gcd and `n` divided by their gcd are coprime.


theorem OrderIso.limsup_apply :
    ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_6} [inst : ConditionallyCompleteLattice β]
      [inst_1 : ConditionallyCompleteLattice γ] {f : Filter α} {u : α → β} (g : β ≃o γ),
      autoParam (Filter.IsBoundedUnder (fun x x_1 => x ≤ x_1) f u) _auto✝ →
        autoParam (Filter.IsCoboundedUnder (fun x x_1 => x ≤ x_1) f u) _auto✝¹ →
          autoParam (Filter.IsBoundedUnder (fun x x_1 => x ≤ x_1) f fun x => g (u x)) _auto✝² →
            autoParam (Filter.IsCoboundedUnder (fun x x_1 => x ≤ x_1) f fun x => g (u x)) _auto✝³ →
              g (Filter.limsup u f) = Filter.limsup (fun x => g (u x)) f :=
  by sorry

The theorem `OrderIso.limsup_apply` states that for any types `α`, `β`, and `γ` with `β` and `γ` being conditionally complete lattices and given a filter `f` on type `α` and a function `u` from `α` to `β`, if an order isomorphism `g` from `β` to `γ` exists, then under certain conditions, the limsup (infimum of the upper bounds) of the function `u` along the filter `f` after being mapped by `g` is equal to the image of the limsup of `u` along `f` under `g`.

The conditions that need to be satisfied are that the image of the filter `f` under `u` and under the composition of `g` and `u` are both bounded and cobounded under the less than or equal to relation. In other words, there exists some uniform bound that all elements eventually do not exceed (bounded), and there is a lower limit that the elements do not infinitely descend below (cobounded).

Given filter `f` on type `α`, function `u` from `α` to conditionally complete lattices `β` and `γ`, and order isomorphism `g` from `β` to `γ`, if the images of `f` under `u` and `g ∘ u` are both bounded and cobounded, then `limsup(g(limsup(u(x)|x ∈ f))) = limsup(u(x)|x ∈ f)`.


theorem Polynomial.natDegree_X_add_C :
    ∀ {R : Type u} [inst : Nontrivial R] [inst : Semiring R] (x : R),
      Polynomial.natDegree (Polynomial.X + Polynomial.C x) = 1 :=
  by sorry

This theorem states that for any type `R` that is a nontrivial semiring, and for any element `x` of `R`, the natural degree of the polynomial which is the sum of the polynomial variable `X` and the constant polynomial `C x` is always `1`. This means that the polynomial `X + C x` is treated as a first-degree polynomial regardless of the value of `x` in the semiring `R`.

For any nontrivial semiring `R` and its element `x`, the polynomial `X + C x` has degree 1.


theorem Matrix.add_mul :
    ∀ {l : Type u_1} {m : Type u_2} {n : Type u_3} {α : Type v} [inst : NonUnitalNonAssocSemiring α]
      [inst_1 : Fintype m] (L M : Matrix l m α) (N : Matrix m n α), (L + M) * N = L * N + M * N :=
  by sorry

This theorem, `Matrix.add_mul`, states that for any types `l`, `m`, `n` and `α` where `α` is a non-unital non-associative semiring and `m` is finite, given three matrices `L`, `M`, and `N` with entries in `α` where `L` and `M` are matrices with rows indexed by `l` and columns indexed by `m`, and `N` is a matrix with rows indexed by `m` and columns indexed by `n`, the multiplication of the sum of `L` and `M` with `N` is equal to the sum of the result of `L` multiplied by `N` and `M` multiplied by `N`. In more mathematical terms, it's saying that $(L + M) \cdot N = L \cdot N + M \cdot N$. This is a property of matrix multiplication mirroring the distributive law of multiplication over addition.

For matrices `L` and `M` with finite, non-unital, non-associative semiring entries, and `N` with compatible dimensions, $(L + M) \cdot N = L \cdot N + M \cdot N$.


theorem WithTop.add_lt_add_right :
    ∀ {α : Type u} [inst : Add α] {a b c : WithTop α} [inst_1 : LT α]
      [inst_2 : CovariantClass α α (Function.swap fun x x_1 => x + x_1) fun x x_1 => x < x_1],
      a ≠ ⊤ → b < c → b + a < c + a :=
  by sorry

This theorem, `WithTop.add_lt_add_right`, states that for any type `α` that has an addition operation and a less than operation, and for any three elements `a`, `b`, and `c` of the type `α` with the special top element `⊤` added, if `a` is not equal to `⊤` and `b` is less than `c`, then the result of adding `a` to `b` is less than the result of adding `a` to `c`. It requires that `α` has a covariant class, meaning the order is preserved when the parameters of the function `x + x_1` are swapped. In mathematical terms, it is essentially stating that if `a ≠ ∞` and `b < c`, then `b + a < c + a`, where `a`, `b`, and `c` are elements in an ordered semigroup.

For any ordered semigroup with covariant order, if `a` is not the top element and `b` is less than `c`, then `a + b` is less than `a + c`.


theorem Nat.ModEq.add_right_cancel : ∀ {n a b c d : ℕ}, c ≡ d [MOD n] → a + c ≡ b + d [MOD n] → a ≡ b [MOD n] := by
  sorry

This theorem, `Nat.ModEq.add_right_cancel`, states that for any natural numbers `n`, `a`, `b`, `c`, and `d`, if `c` is congruent to `d` modulo `n`, and `a + c` is congruent to `b + d` modulo `n`, then `a` is congruent to `b` modulo `n`. It essentially says that if two numbers add the same amount (`c` or `d`) and the results are congruent modulo `n`, then the original two numbers (`a` and `b`) are also congruent modulo `n`. This theorem proves the property of right cancellation under addition in modular arithmetic.

If `a` is congruent to `b` modulo `n`, `c` is congruent to `d` modulo `n`, then `a + c` is congruent to `b + d` modulo `n` implies `a` is congruent to `b` modulo `n`.


theorem addOrderOf_dvd_natCard : ∀ {G : Type u_6} [inst : AddGroup G] (x : G), addOrderOf x ∣ Nat.card G := by sorry

The theorem `addOrderOf_dvd_natCard` states that for any type `G` that is an additive group, for every element `x` in `G`, the additive order of `x` divides the cardinality of `G` as a natural number. In other words, if `n` is the minimum positive number such that adding `x` to itself `n` times results in the additive identity (or if `x` has infinite order, `n` is defined to be `0`), then `n` is a divisor of the number of elements in `G`. If `G` is infinite, its cardinality is defined to be `0`.

For any additive group G and every x in G, the order of x as an element of G divides the cardinality of G as natural numbers.


theorem Nat.log_one_right : ∀ (b : ℕ), Nat.log b 1 = 0 := by sorry

This theorem, `Nat.log_one_right`, states that for any given natural number `b`, the logarithm of `1` in base `b` is always `0`. This is due to the mathematical property that any number raised to the power of `0` is `1`, including the base `b`. Thus, the largest `k : ℕ` such that `b^k ≤ 1` will always be `0` when `n` is `1`.

The logarithm of 1 with respect to any base is equal to 0.


theorem Set.preimage_smul_inv₀ :
    ∀ {α : Type u_2} {β : Type u_3} [inst : GroupWithZero α] [inst_1 : MulAction α β] {a : α},
      a ≠ 0 → ∀ (t : Set β), (fun x => a⁻¹ • x) ⁻¹' t = a • t :=
  by sorry

This theorem, denoted as `Set.preimage_smul_inv₀`, states that for any types `α` and `β`, given a `GroupWithZero` instance for `α` and a `MulAction` instance between `α` and `β`. If we have a non-zero element `a` in `α` and a set `t` of type `β`, then the preimage of the set `t` under the function `(fun x => a⁻¹ • x)` is equal to the set obtained by scaling `t` by `a`. In other words, if we scale each element in `t` by the inverse of `a` and then calculate the preimages, we get the same result as if we had directly scaled the set `t` by `a`.

In terms of mathematical notation, this can be expressed as: for all $a \in \alpha$ such that $a \neq 0$ and for all sets $t \subset \beta$, we have $(f^{-1}(t) = a \cdot t)$ where $f(x) = a^{-1} \cdot x$.

For any non-zero element `a` in a group with zero `α` and a set `t` in `β`, the preimage of `t` under the function `x ↔ a⁻¹ * x` is equal to the set obtained by scaling `t` by `a`.


theorem Mathlib.Data.Finset.Pointwise._auxLemma.54 :
    ∀ {α : Type u_2} [inst : DecidableEq α] [inst_1 : Mul α] {s t : Finset α} {x : α},
      (x ∈ s * t) = ∃ y ∈ s, ∃ z ∈ t, y * z = x :=
  by sorry

The theorem `Mathlib.Data.Finset.Pointwise._auxLemma.54` states that, for any type `α` where equality is decidable and multiplication operation is defined, and given two finite sets `s` and `t` of type `α`, and an element `x` of type `α`, the condition that `x` is in the set product of `s` and `t` is equivalent to there existing an element `y` in `s` and an element `z` in `t` such that the product of `y` and `z` equals `x`. In other words, `x` is in the set product of `s` and `t` if and only if there are elements in `s` and `t` whose multiplication gives `x`.

For finite sets $s$ and $t$ of type $\alpha$ where equality is decidable and multiplication is defined, $x$ belongs to the set product $s \times t$ if and only if there exist $y \in s$ and $z \in t$ such that $y \cdot z = x$.


theorem superset_of_eq :
    ∀ {α : Type u} [inst : HasSubset α] {a b : α} [inst_1 : IsRefl α fun x x_1 => x ⊆ x_1], a = b → b ⊆ a := by sorry

This theorem states that for any type `α` that has a subset operation, and any two elements `a` and `b` of this type, if reflexivity property holds for the subset operation (i.e., any element is a subset of itself), then if `a` is equal to `b`, `b` is a subset of `a`. In mathematical terms, for any set `α`, any two elements `a` and `b` of `α`, if `a = b`, then `b` is a subset of `a`.

If `α` is a type with a subset operation and reflexivity holds, then for all `a` and `b` in `α`, `a = b` implies `b ⊆ a`.


theorem Mathlib.Data.Finset.Pointwise._auxLemma.60 :
    ∀ {α : Type u_2} [inst : DecidableEq α] [inst_1 : Div α] {s t : Finset α} {a : α},
      (a ∈ s / t) = ∃ b ∈ s, ∃ c ∈ t, b / c = a :=
  by sorry

This theorem, `Mathlib.Data.Finset.Pointwise._auxLemma.60`, states that for any type `α` that has decidable equality and a division operation, for any two finite sets `s` and `t` of elements of `α`, and for any element `a` in `α`, the condition of `a` being in the set resulting from dividing every element of `s` by every element of `t` is equivalent to the existence of an element `b` in `s` and an element `c` in `t` such that `b / c` equals `a`.

For any type `α` with decidable equality and division, the element `a` is in the set of quotients of every element in finite sets `s` and `t` if and only if there exist `b` in `s` and `c` in `t` such that `b / c = a`.


theorem Set.univ_pi_singleton :
    ∀ {ι : Type u_1} {α : ι → Type u_2} (f : (i : ι) → α i), (Set.pi Set.univ fun i => {f i}) = {f} := by sorry

The theorem `Set.univ_pi_singleton` states that for any type of indices `ι` and any family of types `α` indexed by `ι`, for any function `f` from `ι` to `α`, the set of all dependent functions `g : Πa, α a` such that `g a` belongs to the singleton set `{f a}` for all `a` in the universal set (which contains all indices) is precisely the singleton set `{f}`. In other words, the only function that maps each index to its corresponding value in `f` is `f` itself.

For any type of indices ι and any family of types α indexed by ι, the dependent function Πa, α a that maps each index a to the unique element in {fa} is exactly the function f.


theorem BoxIntegral.Prepartition.iUnion_compl :
    ∀ {ι : Type u_1} {I : BoxIntegral.Box ι} [inst : Finite ι] (π : BoxIntegral.Prepartition I),
      BoxIntegral.Prepartition.iUnion (BoxIntegral.Prepartition.compl π) = ↑I \ BoxIntegral.Prepartition.iUnion π :=
  by sorry

This theorem states that for any given prepartition `π` of a box `I` in a finite-dimensional space `ι`, the union of the boxes in the complement prepartition `π.compl` equals the set difference of the box `I` and the union of the boxes in the original prepartition `π`. In other words, the part of the box `I` not covered by the prepartition `π` is exactly what is covered by the complement prepartition `π.compl`.

For any prepartition π of a box I in a finite-dimensional space, the complement π.compl covers the complement of the union of the boxes in π, that is, I \ ∪ π = ∪ (box j : π.compl) box j.


theorem MulOpposite.unop_surjective : ∀ {α : Type u_1}, Function.Surjective MulOpposite.unop := by sorry

The theorem `MulOpposite.unop_surjective` states that for any given type `α`, the function `MulOpposite.unop` is surjective. In other words, every element of the type `α` can be obtained by applying the `MulOpposite.unop` function to some element of the type `αᵐᵒᵖ`. Here, `αᵐᵒᵖ` represents the multiplicative opposite of `α` and `MulOpposite.unop` is a function that retrieves the original element from its multiplicative opposite.

For any type `α`, the function `MulOpposite.unop` from the multiplicative opposite `αᵐᵒᵖ` to `α` is surjective.


theorem Filter.mem_of_eq_bot : ∀ {α : Type u} {f : Filter α} {s : Set α}, f ⊓ Filter.principal sᶜ = ⊥ → s ∈ f := by
  sorry

This theorem states that for any type `α`, any filter `f` of type `α`, and any set `s` of type `α`, if the intersection of filter `f` and the principal filter of the complement of set `s` equals the bottom element (`⊥`, representing the smallest filter or an empty filter), then set `s` is a member of filter `f`. Essentially, it's saying that if filtering out everything outside of `s` from `f` leaves nothing, then `s` must have been part of `f` to begin with.

If the intersection of filter `f` on type `α` with the complement of set `s` is the bottom filter, then `s` is an element of `f`.


theorem Nat.binaryRec.proof_5 :
    ∀ {C : ℕ → Sort u_1} (n : ℕ), Nat.bit (Nat.bodd n) (Nat.div2 n) = n → C n = C (Nat.bit (Nat.bodd n) (Nat.div2 n)) :=
  by sorry

This theorem asserts that for every natural number `n` and for every function `C` from natural numbers to a type, if `n` can be represented as a binary number by appending the binary digit equivalent of whether `n` is odd (`Nat.bodd n`) to the binary representation of the floor division of `n` by 2 (`Nat.div2 n`), then the value of `C` at `n` is the same as the value of `C` at the binary number representation of `n`. In other words, the function `C` is invariant under the operation of binary representation of numbers.

For every function `C` and all natural numbers `n`, if `n` is represented in binary as the concatenation of the binary representation of `Nat.div2 n` and the binary digit representing the oddness of `n` (i.e., `Nat.bodd n`), then `C(n) = C(binary_representation_of_n)`.


MeasureTheory.Memℒp.restrict

theorem MeasureTheory.Memℒp.restrict :
    ∀ {α : Type u_1} {E : Type u_2} {m0 : MeasurableSpace α} {p : ENNReal} {μ : MeasureTheory.Measure α}
      [inst : NormedAddCommGroup E] (s : Set α) {f : α → E},
      MeasureTheory.Memℒp f p μ → MeasureTheory.Memℒp f p (μ.restrict s) :=
  by sorry

The theorem `MeasureTheory.Memℒp.restrict` states that for any type `α`, any extended nonnegative real number `p`, any measure `μ` on a measurable space `α`, and any normed additive commutative group `E`, if a function `f` from `α` to `E` belongs to `ℒp(μ)` (i.e., `f` is almost-everywhere strongly measurable and the `p`-th power of the norm of `f` integrated with respect to `μ` is finite), then `f` also belongs to `ℒp(μ.restrict s)` for any subset `s` of `α`. In other words, the `ℒp` property is preserved when the measure is restricted to a subset of the space.

If `f` is a function from a measurable space `(α, Σ, μ)` to a normed additive commutative group `E` that belongs to `ℒp(μ)` for some extended nonnegative real number `p`, then `f` also belongs to `ℒp(μ.restrict s)` for any subset `s` of `α`.


theorem ENNReal.eventually_le_limsup :
    ∀ {α : Type u_1} {f : Filter α} [inst : CountableInterFilter f] (u : α → ENNReal),
      ∀ᶠ (y : α) in f, u y ≤ Filter.limsup u f :=
  by sorry

The theorem `ENNReal.eventually_le_limsup` states that for any type `α`, any filter `f` on `α` that is a countable intersection filter, and any function `u` from `α` to the extended nonnegative real numbers (denoted as `ENNReal`, which includes all nonnegative real numbers plus positive infinity), there exists an event in `f` such that for all elements `y` of `α` in this event, the value `u(y)` is less than or equal to the limit superior (`limsup`) of `u` with respect to the filter `f`. In mathematical terms, we can express this as:
∀y ∈ α, eventually for `f`, it holds that `u(y) ≤ limsup f(u)`. This is a property that connects the notions of limit superior and filters in the context of extended nonnegative real numbers.

For any countable intersection filter `f` on type `α` and function `u` from `α` to `ENNReal`, there exists an element `y` in `α` such that for all `x` in `α` in the event `f` containing `y`, `u(x)` is less than or equal to the limit superior of `u` with respect to `f`.


Set.Nonempty.add

theorem Set.Nonempty.add :
    ∀ {α : Type u_2} [inst : Add α] {s t : Set α}, Set.Nonempty s → Set.Nonempty t → Set.Nonempty (s + t) := by sorry

This theorem states that for any type `α` that has an addition operation, given two sets `s` and `t` of that type, if both `s` and `t` are nonempty (i.e., each set contains at least one element), then their sum set `s + t` is also nonempty. The sum set `s + t` is defined as the set of all elements that can be obtained by adding an element of `s` to an element of `t`.

If `α` is a type with an addition operation and `s` and `t` are nonempty sets of `α`, then `s + t` is a nonempty set.


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

This theorem states that for any two integers `a` and `b`, `a` is less than `b` if and only if `a` is less than or equal to `b` and `a` is not equal to `b`. In other words, the "<" relation on integers is completely determined by the "≤" relation and the "≠" relation.

For integers `a` and `b`, `a` < `b` if and only if `a` ≤ `b` and `a` ≠ `b`.


Function.LeftInverse.leftInvOn

theorem Function.LeftInverse.leftInvOn :
    ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {g : β → α},
      Function.LeftInverse f g → ∀ (s : Set β), Set.LeftInvOn f g s :=
  by sorry

The theorem `Function.LeftInverse.leftInvOn` states that for any types `α` and `β`, and functions `f : α → β` and `g : β → α`, if `f` is a left inverse of `g` (i.e., `f ∘ g = id`), then `f` is also a left inverse of `g` on any set `s` of type `β`. In other words, for every element `x` in set `s`, we have `f(g(x)) = x`. This theorem shows how the global property of being a left inverse carries over to any subset of the domain.

If `f : α → β` and `g : β → α` are such that `f ∘ g = id_β`, then `f` restricts to a left inverse of `g` on any subset `s` of `β`, i.e., `∀ x ∈ s, f(g(x)) = x`.


theorem CategoryTheory.Limits.WidePullback.π_arrow :
    ∀ {J : Type w} {D : Type u_1} [inst : CategoryTheory.Category.{v₂, u_1} D] {B : D} {objs : J → D}
      (arrows : (j : J) → objs j ⟶ B) [inst_1 : CategoryTheory.Limits.HasWidePullback B objs arrows] (j : J),
      CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.WidePullback.π arrows j) (arrows j) =
        CategoryTheory.Limits.WidePullback.base arrows :=
  by sorry

The theorem `CategoryTheory.Limits.WidePullback.π_arrow` is a statement about the structure of wide pullbacks in a category. If we have a wide pullback in a category, indexed by a type `J` and defined for a base object `B` and a family of objects `objs : J → D`, where `D` is the type of objects in the category and each object in `objs` comes with a morphism `arrows : (j : J) → objs j ⟶ B` to `B`, then for any index `j` in `J`, the composition of the projection morphism from the wide pullback to the object `objs j` and the corresponding `arrows j` morphism is equal to the base morphism of the wide pullback. This is essentially the universal property of the wide pullback in categorical terms.

Given a wide pullback in a category indexed by type J and defined for a base object B and a family of morphisms arrows : J → Obj(C) × Morp(C) with Obj(C) the type of objects and Morp(C) the type of morphisms in C, for each j in J, the composition of the projection morphism to objs j and arrows j is equal to the base morphism of the wide pullback.


theorem Polynomial.eraseLead_monomial :
    ∀ {R : Type u_1} [inst : Semiring R] (i : ℕ) (r : R), Polynomial.eraseLead ((Polynomial.monomial i) r) = 0 := by
  sorry

The theorem `Polynomial.eraseLead_monomial` states that for any semiring `R`, for any natural number `i`, and for any `r` in `R`, when we create a monomial using `r` and `i` in `R`, and then erase the leading term of that monomial, what remains is the zero polynomial. In mathematical terms, if we have a monomial `a * X^s`, erasing the leading term essentially removes the entire monomial, leaving us with the zero polynomial.

For any semiring R, erasing the leading term of a monomial a * X^s in R results in the zero polynomial.


theorem Complex.hasDerivAt_tan : ∀ {x : ℂ}, Complex.cos x ≠ 0 → HasDerivAt Complex.tan (1 / Complex.cos x ^ 2) x := by
  sorry

The theorem `Complex.hasDerivAt_tan` states that for all complex numbers `x`, if the cosine of `x` is not equal to zero, then the complex tangent function has a derivative at `x`, and this derivative is given by `1/(cos(x))^2`. In mathematical terms, it says that if `cos(x) ≠ 0`, then the derivative of `tan(x)` is `1/(cos(x))^2`, where the derivative is taken with respect to `x`.

If the cosine of a complex number `x` is non-zero, then the complex tangent function `tan(x)` has a derivative equal to `1/(cos(x))^2`.


theorem zpow_strictMono_left :
    ∀ (α : Type u_1) [inst : OrderedCommGroup α] {n : ℤ}, 0 < n → StrictMono fun x => x ^ n := by sorry

The theorem `zpow_strictMono_left` states that for any type `α` that forms an ordered commutative group, for any integer `n` that is greater than zero, the function that maps `x` to `x ^ n` (i.e., `x` raised to the power `n`) is strictly monotone. This means that if `a` and `b` are any two elements of `α` such that `a < b`, then `a^n < b^n`.

For any ordered commutative group type `α` and positive integer `n`, the power function `x ↔ x ^ n` is strict monotone, i.e., `x < y` implies `x ^ n < y ^ n`.


theorem le_himp : ∀ {α : Type u_2} [inst : GeneralizedHeytingAlgebra α] {a b : α}, a ≤ b ⇨ a := by sorry

This theorem, `le_himp`, states that for any type `α` that forms a Generalized Heyting Algebra, for any elements `a` and `b` of that type, if `a` is less than or equal to `b`, this implies `a`. In mathematical terms, given a Generalized Heyting Algebra, this theorem is about the order-theoretic relation (≤) between its elements and the implication operation (⇨). It essentially says that if an element is less than or equal to another, it can be implied by that relation.

In a Generalized Heyting Algebra, for all elements `a` and `b`, if `a` is less than or equal to `b`, then `a` implies `b`.


theorem Multiset.erase_le : ∀ {α : Type u_1} [inst : DecidableEq α] (a : α) (s : Multiset α), Multiset.erase s a ≤ s :=
  by sorry

This theorem states that for any given type `α` which has decidable equality, for any element `a` of type `α`, and for any multiset `s` of elements of type `α`, the multiset that results from erasing `a` from `s` is always less than or equal to the original multiset `s`. In other words, removing an element from a multiset will not result in a multiset larger than the original one.

For any decidably equal type `α` and multiset `s` of elements from `α`, the multiset obtained by removing any element `a` from `s` is a sub-multiset of `s`.


theorem Ordinal.nadd_comm : ∀ (a b : Ordinal.{u_1}), Ordinal.nadd a b = Ordinal.nadd b a := by sorry

This theorem states that natural addition, denoted as `Ordinal.nadd`, on ordinals is commutative. In other words, for any two ordinals `a` and `b`, the ordinal resulting from performing the natural addition of `a` and `b` is the same as the ordinal resulting from performing natural addition of `b` and `a`. This characteristic is in contrast to normal ordinal addition, therefore, emphasizing the property of natural addition being commutative.

For all ordinals a and b, `Ordinal.nadd a b = Ordinal.nadd b a`.


theorem Filter.map_add_atTop_eq_nat : ∀ (k : ℕ), Filter.map (fun a => a + k) Filter.atTop = Filter.atTop := by sorry

This theorem states that for any natural number `k`, the mapping of the filter `atTop` (representing the limit towards infinity on an ordered set) through the function `a => a + k` results in the same `atTop` filter. In other words, adding a constant `k` to each element of an infinite sequence does not change the fact that the sequence grows without bound.

For any natural number `k`, the `atTop` filter of the function `x => x + k` over an ordered set is equal to the `atTop` filter of the identity function.


/-- Poincaré recurrence theorem: given a conservative map `f` and a measurable set `s`,
almost every point `x ∈ s` returns back to `s` infinitely many times.  -/
theorem MeasureTheory.Conservative.ae_mem_imp_frequently_image_mem :
    ∀ {α : Type u_2} [inst : MeasurableSpace α] {f : α → α} {s : Set α} {μ : MeasureTheory.Measure α},
      MeasureTheory.Conservative f μ →
        MeasurableSet s → ∀ᵐ (x : α) ∂μ, x ∈ s → ∃ᶠ (n : ℕ) in Filter.atTop, f^[n] x ∈ s :=
  by sorry

The Poincaré Recurrence Theorem in measure theory states that, for any given conservative map `f`, a measurable space `α`, a measurable set `s` within this space, and a measure `μ` over the space, if almost every point `x` in `s` is conserved under `f` with respect to measure `μ`, then for almost every point `x` in `s`, there exist infinite natural numbers `n` such that the `n`-th iterate of `f` at `x` is in `s`. The term "almost every" is in the measure-theoretic sense, meaning that the set of points for which the property does not hold has measure zero. The `Filter.atTop` represents the limit going to infinity in the set of natural numbers. This theorem is a fundamental result in ergodic theory, providing conditions under which points in a set will repeatedly return to the set.

If a measurable set contains almost every point of zero-measure recurrent points under a conservative map in a measure space, then for almost every point in the set, there exist infinitely many iterates that lie within the set.


theorem Bool.true_or : ∀ (b : Bool), (true || b) = true := by sorry

This theorem states that for any Boolean value `b`, the logical OR operation between `true` and `b` is always `true`. In other words, no matter what `b` is, if one of the arguments is `true`, the result of `true OR b` is always `true`. This corresponds to the general law of Boolean algebra that `true OR anything` is `true`.

For all Boolean values `b`, `true` or `b` is equal to `true`.


theorem Multiset.sup_le :
    ∀ {α : Type u_1} [inst : SemilatticeSup α] [inst_1 : OrderBot α] {s : Multiset α} {a : α},
      Multiset.sup s ≤ a ↔ ∀ b ∈ s, b ≤ a :=
  by sorry

The theorem `Multiset.sup_le` states that for any type `α` which has a semilattice structure with supremum (`SemilatticeSup α`) and a bottom element (`OrderBot α`), and for any multiset `s` of type `α` and any element `a` of type `α`, the supremum of the multiset `s` is less than or equal to `a` if and only if every element `b` in the multiset `s` is less than or equal to `a`. In other words, the greatest element of a multiset (considering duplicates) is less than or equal to `a` iff every element in the multiset is less than or equal to `a`.

For any semilattice with supremum and bottom element type `α`, the multiset supremum of `α` is less than or equal to any element `a` if and only if every element in the multiset is less than or equal to `a`.


theorem Odd.strictMono_pow : ∀ {R : Type u_4} [inst : LinearOrderedRing R] {n : ℕ}, Odd n → StrictMono fun a => a ^ n :=
  by sorry

The theorem `Odd.strictMono_pow` states that for any type `R` that forms a linearly ordered ring, and for any natural number `n` such that `n` is odd, the function `f(a) = a^n` is strictly monotonic. In other words, if `n` is an odd natural number and `a` and `b` are elements from a linearly ordered ring such that `a < b`, then `a^n < b^n`.

For any odd natural number `n` and linearly ordered ring `R`, the function `a ↦ a^n` is strictly increasing on `R`.


theorem MeasureTheory.AEStronglyMeasurable.inner :
    ∀ {α : Type u_1} {𝕜 : Type u_2} {E : Type u_3} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E]
      [inst_2 : InnerProductSpace 𝕜 E] {x : MeasurableSpace α} {μ : MeasureTheory.Measure α} {f g : α → E},
      MeasureTheory.AEStronglyMeasurable f μ →
        MeasureTheory.AEStronglyMeasurable g μ → MeasureTheory.AEStronglyMeasurable (fun x => ⟪f x, g x⟫_𝕜) μ :=
  by sorry

The theorem `MeasureTheory.AEStronglyMeasurable.inner` states that for any types `α`, `𝕜`, and `E`, any `RCLike` instance for `𝕜`, any `NormedAddCommGroup` instance for `E`, any `InnerProductSpace` instance for `𝕜` and `E`, any measurable space `x` as well as any measure `μ` on this measurable space, and any two functions `f` and `g` from `α` to `E`, if `f` and `g` are almost everywhere strongly measurable with respect to `μ`, then the function that maps each element of `α` to the inner product of `f(x)` and `g(x)` is also almost everywhere strongly measurable with respect to `μ`. Here, "almost everywhere strongly measurable" means that the function is the same "almost everywhere" as the limit of a sequence of simple functions.

If `f` and `g` are almost everywhere strongly measurable functions from a measurable space `(α, Σ, μ)` to an inner product space `(E, ∣·∣)` over a normed field `𝕜`, then the function `x ↦ ∣f(x)∣² * ⟨f(x), g(x)⟩` is almost everywhere equal to a limit of simple functions.


theorem Order.isSuccLimit_toDual_iff :
    ∀ {α : Type u_1} [inst : LT α] {a : α}, Order.IsSuccLimit (OrderDual.toDual a) ↔ Order.IsPredLimit a := by sorry

This theorem states that for any type `α` with a less than (`LT`) operation and any element `a` of this type, `a` is a successor limit in the dual order if and only if `a` is a predecessor limit in the original order. Here, a successor limit is a value that does not cover any other in a successor order, meaning it cannot be the successor of anything smaller. Conversely, a predecessor limit is a value that is not covered by any other in a predecessor order, implying it cannot be the predecessor of anything greater. The function `OrderDual.toDual` is used to transform an element from the original order type to the equivalent in the dual order.

For any type with a total order and an element, it is a successor limit in the dual order if and only if it is a predecessor limit in the original order.


/-- The inductively defined smallest congruence relation containing a binary relation `r` equals
the infimum of the set of congruence relations containing `r`.  -/
theorem Con.conGen_eq :
    ∀ {M : Type u_1} [inst : Mul M] (r : M → M → Prop), conGen r = sInf {s | ∀ (x y : M), r x y → s x y} := by sorry

This theorem states that for a given binary relation `r` on a type `M` equipped with multiplication, the smallest congruence relation containing `r`, which is inductively defined, is equivalent to the infimum of the set of all congruence relations which contain `r`. In other words, the smallest multiplicative congruence relation that includes `r` is the same as the greatest lower bound of the set of all congruence relations that satisfy `r`.

The smallest multiplicative congruence relation containing a binary relation on a type with multiplication is equal to the greatest lower bound of all congruence relations containing it.


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

This theorem, `List.cons_bagInter_of_pos`, states that for any type `α` with decidable equality (`DecidableEq α`) and for any initial list `l₂`, any element `a : α` and another list `l₁`, if `a` is a member of `l₂`, then the multiset intersection (`List.bagInter`) of the list with `a` as the head and `l₁` as the tail (`a :: l₁`) with `l₂` equals to a list with `a` as the head and the multiset intersection of `l₁` and `l₂` with `a` erased as the tail (`a :: List.bagInter l₁ (List.erase l₂ a)`). In other words, when `a` is in `l₂`, `a` will also be in the multiset intersection of `(a :: l₁)` and `l₂`, and the remaining intersection is just the multiset intersection of `l₁` and `l₂` without `a`.

For lists `l₁` and `l₂` over a type `α` with decidable equality, if `a` is an element of `l₂`, then `a :: List.bagInter l₁ l₂` equals `a :: List.bagInter l₁ (List.erase l₂ a)`.


theorem Finset.image_id : ∀ {α : Type u_1} {s : Finset α} [inst : DecidableEq α], Finset.image id s = s := by sorry

This theorem, `Finset.image_id`, states that for any type `α` with decidable equality and any finite set `s` of type `α`, the image of `s` under the identity function is identical to `s` itself. In other words, if we apply the identity function to each element of the finite set `s`, the resulting set is exactly `s`. This is analogous to the mathematical property that the image of a set under the identity map is the set itself.

For any finite set `s` of type `α` with decidable equality, the image of `s` under the identity function is equal to `s`.


theorem Mathlib.Data.Sym.Sym2._auxLemma.19 :
    ∀ {α : Type u_1} {r : α → α → Prop} {sym : Symmetric r} {z : α × α}, (Sym2.mk z ∈ Sym2.fromRel sym) = r z.1 z.2 :=
  by sorry

This theorem, `Mathlib.Data.Sym.Sym2._auxLemma.19`, states that for any type `α`, a symmetric relation `r` on `α`, and a pair `z` of type `α × α`, the membership of the pair `z` in the set derived from the symmetric relation `r` by the function `Sym2.fromRel` is equivalent to the relation `r` holding between the first and the second element of the pair `z`. In other words, a pair `z` is in the set defined by the symmetric relation `r` if and only if the relation `r` is true when applied to the elements of `z`.

For any type `α` and symmetric relation `r` on `α`, `(z : α × α) ∈ Set.image (Sym2.fromRel r) z if and only if r z.1 z.2`.


theorem Mathlib.Data.Sym.Sym2._auxLemma.17 : ∀ {α : Type u_1} (z : α × α), Sym2.IsDiag (Sym2.mk z) = (z.1 = z.2) := by
  sorry

This theorem, `Mathlib.Data.Sym.Sym2._auxLemma.17`, states that for any type `α` and any pair `z` of type `α`, the predicate `Sym2.IsDiag` applied to the result of `Sym2.mk` applied to `z` is equivalent to checking if the two elements of `z` are equal. In other words, an element of the symmetric square of a type `α` is on the diagonal if and only if its two components are equal.

For any type `α` and any pair `z` of elements of type `α`, the element `Sym2.mk z z` in the symmetric square of `α` is on the diagonal if and only if the components of `z` are equal.


theorem ContinuousOn.integrableOn_Icc :
    ∀ {X : Type u_1} {E : Type u_3} [inst : MeasurableSpace X] [inst_1 : TopologicalSpace X]
      [inst_2 : NormedAddCommGroup E] {f : X → E} {μ : MeasureTheory.Measure X} [inst_3 : OpensMeasurableSpace X]
      {a b : X} [inst_4 : MeasureTheory.IsFiniteMeasureOnCompacts μ] [inst_5 : Preorder X] [inst_6 : CompactIccSpace X]
      [inst_7 : T2Space X], ContinuousOn f (Set.Icc a b) → MeasureTheory.IntegrableOn f (Set.Icc a b) μ :=
  by sorry

The theorem `ContinuousOn.integrableOn_Icc` states that for any type `X` that is a measurable space, a topological space, a T2 space, and has a preorder, and any type `E` that is a normed communal addition group, given a function `f` from `X` to `E`, a measure `μ` on `X` that is finite on compacts, and two elements `a` and `b` of `X` such that the interval from `a` to `b` is compact, if `f` is continuous on the closed interval from `a` to `b`, then `f` is integrable on that interval with respect to the measure `μ`. In other words, if the function is continuous on a specific, compact interval, then it is also integrable over that same interval.

If a continuous function on a compact interval of a measurable space with a preorder and a finite measure on compacts, valued in a normed additive group, then the function is integrable on that interval.


/-- If multiplying by `1` on either side is the identity, `1` is regular.  -/
theorem isRegular_one : ∀ {R : Type u_1} [inst : MulOneClass R], IsRegular 1 := by sorry

This theorem states that for any type `R` that has a multiplication and an identity element `1` (denoted by the `MulOneClass` typeclass), the identity element `1` is regular. In the context of ring theory, an element is regular if it is not a zero divisor. In other words, if for all non-zero elements `a` and `b` in `R`, if `1 * a = 1 * b`, then `a = b`, and if `a * 1 = b * 1`, then `a = b`.

For any type `R` in Lean 4 belonging to the `MulOneClass` with identity element `1`, `1` is a regular element. In other words, for all non-zero `a, b` in `R`, `1 * a = 1 * b` implies `a = b` and `a * 1 = b * 1` implies `a = b`.


BoxIntegral.Prepartition.ext

theorem BoxIntegral.Prepartition.ext :
    ∀ {ι : Type u_1} {I : BoxIntegral.Box ι} {π₁ π₂ : BoxIntegral.Prepartition I},
      (∀ (J : BoxIntegral.Box ι), J ∈ π₁ ↔ J ∈ π₂) → π₁ = π₂ :=
  by sorry

This theorem states that for any type `ι`, any box `I` of type `BoxIntegral.Box ι`, and any two prepartitions `π₁` and `π₂` of this box, if it is the case that for any given box `J` of type `BoxIntegral.Box ι`, `J` is an element of `π₁` if and only if `J` is an element of `π₂`, then these two prepartitions `π₁` and `π₂` are equal. In other words, two prepartitions are identical if they contain exactly the same set of boxes.

Two partitions of a box in Lean 4 are equal if and only if they contain the same set of boxes.


theorem Mathlib.Analysis.Asymptotics.SuperpolynomialDecay._auxLemma.2 :
    ∀ {G : Type u_1} [inst : Semigroup G] (a b c : G), a * (b * c) = a * b * c := by sorry

This theorem, named `Mathlib.Analysis.Asymptotics.SuperpolynomialDecay._auxLemma.2`, states that for any type `G` that forms a semigroup, the multiplication operation is associative. In simpler terms, given any three elements `a`, `b`, and `c` of type `G`, the product of `a` with the product of `b` and `c` is the same as the product of `a`, `b`, and `c` taken in a row without bracketing. It's a formal encoding of the mathematical principle that in a semigroup, the way in which we group factors in a product does not change the result, i.e., `(a * (b * c)) = ((a * b) * c)`.

In a semigroup, the associativity of multiplication holds: `(a * (b * c)) = ((a * b) * c)` for all elements `a`, `b`, and `c`.


theorem EReal.embedding_coe : Embedding Real.toEReal := by sorry

The theorem `EReal.embedding_coe` states that the function `Real.toEReal`, which maps real numbers to extended real numbers, is an embedding. In other words, it preserves the structure of real numbers when mapping them to the extended real numbers. This means that if two real numbers are distinct, their images under this function in the extended real numbers are also distinct, and the relative order of real numbers is preserved in the extended real numbers.

The function `Real.toEReal` is an embedding of the real numbers into the extended real numbers, preserving the order and distinctness of real numbers.


theorem List.ext_nthLe :
    ∀ {α : Type u} {l₁ l₂ : List α},
      List.length l₁ = List.length l₂ →
        (∀ (n : ℕ) (h₁ : n < List.length l₁) (h₂ : n < List.length l₂), List.nthLe l₁ n h₁ = List.nthLe l₂ n h₂) →
          l₁ = l₂ :=
  by sorry

The theorem `List.ext_nthLe` states that for any two lists `l₁` and `l₂` of the same type `α`, if the lengths of the two lists are equal, and for every natural number `n` less than the length of the lists, the `n`th element of `l₁` and `n`th element of `l₂` are equal, then the two lists `l₁` and `l₂` are the same. This theorem essentially asserts that two lists are equal if they have the same length and their corresponding elements are identical.

If two lists of the same type have equal lengths and agree in their first `n` elements for all `n < length`, then they are equal.


theorem Mathlib.Data.Set.Intervals.Basic._auxLemma.44 :
    ∀ {α : Type u} [inst : LinearOrder α] {a b c : α}, (min a b ≤ c) = (a ≤ c ∨ b ≤ c) := by sorry

This theorem, named `Mathlib.Data.Set.Intervals.Basic._auxLemma.44`, states a property of an ordered type `α` in linear order. Specifically, given any three elements `a`, `b`, and `c` of this type, the statement that the minimum of `a` and `b` is less than or equal to `c` is equivalent to the statement that either `a` is less than or equal to `c` or `b` is less than or equal to `c`.

For all ordered types α and elements a, b, and c, a ≤ b if and only if either a ≤ c or b ≤ c.


theorem Mathlib.Data.Set.Intervals.Basic._auxLemma.45 :
    ∀ {α : Type u} [inst : LinearOrder α] {a b c : α}, (a < max b c) = (a < b ∨ a < c) := by sorry

This theorem states that for any type `α` equipped with a linear order, and for any three elements `a`, `b` and `c` of `α`, the proposition that `a` is less than the maximum of `b` and `c` is equivalent to the proposition that `a` is less than `b` or `a` is less than `c`. In other words, `a` being less than the max of `b` and `c` implies that `a` must be less than either `b` or `c` and vice versa.

For any type `α` with a linear order, and for all `a`, `b`, `c` in `α`, `a` < max `(b, c)` if and only if `a` < `b` or `a` < `c`.


theorem Mathlib.Data.Set.Intervals.Basic._auxLemma.43 :
    ∀ {α : Type u} [inst : LinearOrder α] {a b c : α}, (min a b < c) = (a < c ∨ b < c) := by sorry

This theorem in Lean 4 states that for any type `α` that has a linear order, and for any three elements `a`, `b`, and `c` of this type, the condition that the minimum of `a` and `b` is less than `c` is equivalent to the condition that `a` is less than `c` or `b` is less than `c`. In mathematical terms, for any `a`, `b`, and `c` in a set that has a linear order, `min(a, b) < c` if and only if `a < c` or `b < c`.

For any type `α` with a linear order, `min(a, b) < c` if and only if `a < c` or `b < c`.


theorem Mathlib.Data.Set.Intervals.Basic._auxLemma.46 :
    ∀ {α : Type u} [inst : LinearOrder α] {a b c : α}, (a ≤ max b c) = (a ≤ b ∨ a ≤ c) := by sorry

This theorem states that for any type `α` exhibiting a linear order, and for any three elements `a`, `b`, and `c` of this type, the statement "a is less than or equal to the maximum of b and c" is equivalent to the statement "a is less than or equal to b OR a is less than or equal to c". In other words, `a` being less than or equal to the highest value among `b` and `c` means that `a` is either less than or equal to `b` or `a` is less than or equal to `c`.

For any type `α` with a linear order, and for all `a`, `b`, `c` in `α`, `a <= max b c` if and only if `a <= b` or `a <= c`.


theorem Set.indicator_support :
    ∀ {α : Type u_1} {M : Type u_4} [inst : Zero M] {f : α → M}, Set.indicator (Function.support f) f = f := by sorry

This theorem states that, given a function `f` from some type `α` to another type `M` where `M` has a zero element, the `Set.indicator` of the `Function.support` of `f` and `f` itself is equal to `f`. In other words, if we create a function that takes a value from `f` when the input is in the support of `f` (the set of points where `f` does not return zero) and returns zero otherwise, we end up with the original function `f`.

Given a function `f` from type `α` to type `M` with `M` having a zero element, `Function.support f`'s indicator function equals `f`.


/-- The image under a monotone function of a set which is bounded below is bounded below. See also
`BddBelow.image2`.  -/
theorem Monotone.map_bddBelow :
    ∀ {α : Type u} {β : Type v} [inst : Preorder α] [inst_1 : Preorder β] {f : α → β},
      Monotone f → ∀ {s : Set α}, BddBelow s → BddBelow (f '' s) :=
  by sorry

The theorem states that the image of a set, which is bounded below, under a monotone function, is also bounded below. In other words, if there is a monotone function `f` from type `α` to type `β`, and if there exists a set `s` of type `α` that is bounded below, then the image of the set `s` through the function `f` is also bounded below. Here, both types `α` and `β` are preordered, meaning that they possess a binary relation indicating that, for any two elements in the set, one of the elements is less than or equal to the other.

If `f` is a monotone function from preordered set `α` to preordered set `β`, and `s ⊆ α` has a bottom element, then `f''s` has a bottom element.


theorem Mathlib.Data.Set.Intervals.Basic._auxLemma.26 :
    ∀ {α : Type u} [inst : PartialOrder α] {a b : α}, (a < b) = (a ≤ b ∧ a ≠ b) := by sorry

The theorem, named `Mathlib.Data.Set.Intervals.Basic._auxLemma.26`, states that for any type `α` equipped with a partial order, and for any two elements `a` and `b` of this type, the property that `a` is less than `b` is equivalent to `a` being less than or equal to `b` and `a` not being equal to `b`. In other words, in a partially ordered set, "less than" is equivalent to "less than or equal to and not equal to".

In a partially ordered set, `a < b` if and only if `a ≤ b` and `a ≠ b`.


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

This theorem, titled `Mathlib.Data.Set.Intervals.Basic._auxLemma.27`, states that for any type `α` and any two elements `a` and `b` of that type, the statement "`a` equals `b`" is equivalent to the statement "`b` equals `a`". In other words, equality is symmetric in any sort or type.

For any type `α` and elements `a`, `b` of type `α`, the equality `a = b` is equivalent to `b = a`.


theorem PowerSeries.coeff_zero_C :
    ∀ {R : Type u_1} [inst : Semiring R] (a : R), (PowerSeries.coeff R 0) ((PowerSeries.C R) a) = a := by sorry

This theorem states that for any semiring R and any element a of R, the nth coefficient of the constant formal power series of a (where n equals to zero), is a itself. In other words, when we construct a constant formal power series from an element a in the semiring R and then extract the 0th coefficient, we get back the original element a. It's essentially saying that the constant formal power series correctly embeds the semiring R into the ring of power series over R.

For any semiring R and its element a, the constant formal power series of a equals a itself when the degree is zero.


theorem Complex.sameRay_iff : ∀ {x y : ℂ}, SameRay ℝ x y ↔ x = 0 ∨ y = 0 ∨ Complex.arg x = Complex.arg y := by sorry

This theorem states that for any two complex numbers `x` and `y`, they are in the same ray according to the `SameRay` definition if and only if either `x` is zero, `y` is zero, or the arguments of `x` and `y` (as defined by the `Complex.arg` function) are equal. In other words, two complex numbers are in the same ray if they are zero or they have the same argument (angle from the positive real axis in the complex plane).

Complex numbers `x` and `y` lie on the same ray if and only if `x = 0`, `y = 0`, or `Complex.arg x = Complex.arg y`.


theorem Mathlib.LinearAlgebra.Prod._auxLemma.6 :
    ∀ (R : Type u_1) {M : Type u_3} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {x : M},
      (x ∈ ⊥) = (x = 0) :=
  by sorry

This theorem, named "Mathlib.LinearAlgebra.Prod._auxLemma.6," states that for any semiring `R`, an additively commutative monoid `M` and a module `M` over `R`, an element `x` of `M` belongs to the bottom module (denoted as `⊥` in Lean) if and only if `x` is equal to the zero element of `M`. In simple terms, in the context of linear algebra, the theorem says that an element belongs to the zero submodule if and only if it is the zero vector.

For any semiring R, additively commutative monoid M, and R-module M, an element x of M belongs to the bottom module if and only if x is the additive identity of M.


theorem Mathlib.LinearAlgebra.Prod._auxLemma.2 :
    ∀ {R : Type u_1} {R₂ : Type u_3} {M : Type u_9} {M₂ : Type u_12} [inst : Semiring R] [inst_1 : Semiring R₂]
      [inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid M₂] [inst_4 : Module R M] [inst_5 : Module R₂ M₂]
      {τ₁₂ : R →+* R₂} {F : Type u_20} [inst_6 : FunLike F M M₂] [inst_7 : SemilinearMapClass F τ₁₂ M M₂]
      [inst_8 : RingHomSurjective τ₁₂] {f : F} {x : M₂}, (x ∈ LinearMap.range f) = ∃ y, f y = x :=
  by sorry

The theorem `Mathlib.LinearAlgebra.Prod._auxLemma.2` in Lean 4 states that for any semirings `R` and `R₂`, additive commutative monoids `M` and `M₂`, `R`-module structure on `M`, `R₂`-module structure on `M₂`, a ring homomorphism `τ₁₂` from `R` to `R₂`, a type `F` which behaves like a function from `M` to `M₂`, a semilinear map structure on `F` with respect to the ring homomorphism `τ₁₂`, and the assumption that `τ₁₂` is surjective. If we consider any `f` of type `F` and `x` of type `M₂`, then `x` is in the range of the linear map `f` if and only if there exists `y` such that `f y = x`. In other words, an element is in the range of a linear map if and only if it is the image of some element under the map.

For any surjective ring homomorphism τ₁₂ from semiring R to R₂, and semilinear map F from an additive commutative monoid M to an R₂-module M₂, an element x of M₂ is in the range of F if and only if there exists y in M such that F(y) = x.


/-- Composing on the left by a uniformly continuous function preserves
uniform convergence on a filter  -/
theorem UniformContinuous.comp_tendstoUniformlyOnFilter :
    ∀ {α : Type u} {β : Type v} {γ : Type w} {ι : Type x} [inst : UniformSpace β] {F : ι → α → β} {f : α → β}
      {p : Filter ι} {p' : Filter α} [inst_1 : UniformSpace γ] {g : β → γ},
      UniformContinuous g →
        TendstoUniformlyOnFilter F f p p' → TendstoUniformlyOnFilter (fun i => g ∘ F i) (g ∘ f) p p' :=
  by sorry

This theorem states that if you have a uniformly continuous function `g` from type `β` to type `γ`, and a sequence of functions `F` that converges uniformly on a filter `p'` to a limiting function `f` with respect to filter `p`, then composing `g` on the left with `F` and `f` preserves this uniform convergence. In more mathematical terms, if `g` is uniformly continuous and `(Fₙ)` converges uniformly to `f` on a filter `p'` with respect to `p`, then the sequence `(g ∘ Fₙ)` also converges uniformly to `g ∘ f` on `p'` with respect to `p`. The concept of uniform convergence implies that the convergence rate is the same for all points in the space, i.e., it does not depend on the choice of a particular point.

If `g` is uniformly continuous from `β` to `γ`, and `F:` (a sequence of functions from `β` to `γ`) converges uniformly to `f` on filter `p'` with respect to filter `p`, then `(g ∘ F)` converges uniformly to `g ∘ f` on `p'` with respect to `p`.


theorem MvPolynomial.exists_coeff_ne_zero :
    ∀ {R : Type u} {σ : Type u_1} [inst : CommSemiring R] {p : MvPolynomial σ R},
      p ≠ 0 → ∃ d, MvPolynomial.coeff d p ≠ 0 :=
  by sorry

This theorem states that for any multivariate polynomial `p` with coefficients in a commutative semiring `R` and variables indexed by set `σ`, if the polynomial is not zero, then there exists a monomial `d` in the polynomial such that the coefficient of `d` in `p` is not zero. In other words, any non-zero multivariate polynomial must have at least one monomial with a non-zero coefficient.

If `p` is a non-zero multivariate polynomial with coefficients in a commutative semiring `R` and variables indexed by set `σ`, then `p` has a non-zero coefficient for some monomial `d` in `p`.


theorem sub_toIocDiv_zsmul_mem_Ioc :
    ∀ {α : Type u_1} [inst : LinearOrderedAddCommGroup α] [hα : Archimedean α] {p : α} (hp : 0 < p) (a b : α),
      b - toIocDiv hp a b • p ∈ Set.Ioc a (a + p) :=
  by sorry

The theorem `sub_toIocDiv_zsmul_mem_Ioc` asserts that for any type `α` that is a linear ordered additive commutative group and can be embedded in the real numbers (Archimedean property), and for any positive value `p` of type `α`, and any values `a` and `b` of type `α`, the result of subtracting the product of `p` and the unique integer given by the function `toIocDiv` applied to `hp`, `a` and `b` from `b`, lies in the interval `(a, a + p]`. Here, the interval `(a, a + p]` is a set of all elements `x` of type `α` such that `a < x <= a + p`.

For any Archimedean linear ordered additive commutative group type `α`, positive value `p` of type `α`, and values `a` and `b` of type `α` with `a < b`, the result of subtracting `p * (toIocDiv p (b - a))` from `b` lies in the interval `(a, a + p]`.


theorem Isometry.hausdorffMeasure_image :
    ∀ {X : Type u_2} {Y : Type u_3} [inst : EMetricSpace X] [inst_1 : EMetricSpace Y] [inst_2 : MeasurableSpace X]
      [inst_3 : BorelSpace X] [inst_4 : MeasurableSpace Y] [inst_5 : BorelSpace Y] {f : X → Y} {d : ℝ},
      Isometry f →
        0 ≤ d ∨ Function.Surjective f →
          ∀ (s : Set X),
            ↑↑(MeasureTheory.Measure.hausdorffMeasure d) (f '' s) = ↑↑(MeasureTheory.Measure.hausdorffMeasure d) s :=
  by sorry

This theorem states that for any two types `X` and `Y` equipped with an eMetricSpace structure, and a function `f` from `X` to `Y`, given that `f` is an isometry and `d` is a real number that is either non-negative or such that `f` is surjective, then for any set `s` of type `X`, the Hausdorff measure of the image of `s` under `f` is equal to the Hausdorff measure of `s` itself. Here, the Hausdorff measure is a particular way of measuring sets in a metric space, and an isometry is a function between metric spaces that preserves distances.

For any eMetricSpace structures on types `X` and `Y`, if `f: X → Y` is an isometry, `d ≥ 0` or `f` surjective, then the Hausdorff measure of `f`(`s`) equals the Hausdorff measure of `s` for any set `s` in `X`.


theorem MeasureTheory.Measure.restrict_apply₀' :
    ∀ {α : Type u_2} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} {s t : Set α},
      MeasureTheory.NullMeasurableSet s μ → ↑↑(μ.restrict s) t = ↑↑μ (t ∩ s) :=
  by sorry

This theorem states that for any type `α`, given a measurable space `m0` on `α`, a measure `μ`, and two sets `s` and `t` of type `α`, if `s` is a `NullMeasurableSet` with respect to measure `μ`, the measure of `t` restricted to `s` is equal to the measure of the intersection of `t` and `s`. In other words, when we restrict the measure `μ` to the null measurable set `s` and apply this restricted measure to set `t`, it is the same as applying the original measure `μ` to the intersection of `t` and `s`.

For any measurable space `(α, m0)`, measure `μ`, and null measurable sets `s` and `t` in `α`, the restricted measure `μ`|`s` of set `t` equals the measure of their intersection `s ∩ t`.


Bornology.IsBounded.closure

theorem Bornology.IsBounded.closure :
    ∀ {α : Type u} [inst : PseudoMetricSpace α] {s : Set α}, Bornology.IsBounded s → Bornology.IsBounded (closure s) :=
  by sorry

The theorem `Bornology.IsBounded.closure` states that for any type `α` that forms a pseudometric space and for any set `s` of type `α`, if `s` is bounded relative to the ambient bornology on `α`, then the closure of `s` (i.e., the smallest closed set containing `s`) is also bounded relative to the bornology on `α`. In other words, the property of being bounded is preserved under taking closures.

If a set `s` in a pseudometric space `α` is bounded, then its closure is also bounded.


theorem convexHull_mono :
    ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : OrderedSemiring 𝕜] [inst_1 : AddCommMonoid E] [inst_2 : Module 𝕜 E]
      {s t : Set E}, s ⊆ t → (convexHull 𝕜) s ⊆ (convexHull 𝕜) t :=
  by sorry

The theorem `convexHull_mono` states that for any ordered semiring `𝕜` and any type `E` which forms a module over `𝕜`, if we have two sets `s` and `t` of type `E` such that `s` is a subset of `t`, then the convex hull of `s` is also a subset of the convex hull of `t`. In other words, if a set `s` is contained within a larger set `t`, then the smallest convex set that contains `s` is also contained within the smallest convex set that contains `t`.

For any ordered semiring 𝕜 and module E over it, if s is a subset of t in E, then the convex hull of s is contained in the convex hull of t.


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

This theorem states that for any type `α` that is a preorder, an additive commutative semigroup, and has a subtraction operation that is ordered, and with a contravariant relation between addition and the less-equal relation, if the sum of two elements `a` and `b` is less than or equal to a third element `c`, then `b` is less than or equal to the difference of `c` and `a`. In mathematical notation, this is saying that if $a + b \leq c$, then $b \leq c - a$.

If `α` is a preorder, an additive commutative semigroup with ordered subtraction and contravariant addition relation, then for all `a`, `b`, and `c` in `α`, `a + b ≤ c` implies `b ≤ c - a`.


theorem SemiconjBy.inv_symm_left_iff :
    ∀ {G : Type u_1} [inst : Group G] {a x y : G}, SemiconjBy a⁻¹ y x ↔ SemiconjBy a x y := by sorry

The theorem `SemiconjBy.inv_symm_left_iff` states that for any group `G` and any elements `a`, `x` and `y` of `G`, the statement "the inverse of `a` is semiconjugate to `y` by `x`" is equivalent to " `a` is semiconjugate to `x` by `y`". Here, an element `a` is said to be semiconjugate to `x` by `y` (denoted as SemiconjBy `a x y`), if the product of `a` and `x` equals the product of `y` and `a`. It's written in mathematical notation as `a * x = y * a`.

For any group `G` and elements `a`, `x`, and `y` in `G`, `SemiconjBy x a y` if and only if `SemiconjBy a y x`, where `SemiconjBy a b c` denotes `a * b = c * a`.


theorem Polynomial.degree_pos_of_irreducible :
    ∀ {R : Type u} [inst : Field R] {p : Polynomial R}, Irreducible p → 0 < Polynomial.degree p := by sorry

This theorem states that for any given irreducible polynomial `p` over a field `R`, the degree of `p` is positive. In other words, if `p` is a polynomial that cannot be factored into a product of two non-unit polynomials in the field `R`, then the highest power of `X` that appears in `p` is greater than zero.

Every irreducible polynomial over a field has positive degree.


theorem CategoryTheory.Limits.IsImage.fac_lift :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} {f : X ⟶ Y}
      {F : CategoryTheory.Limits.MonoFactorisation f} (hF : CategoryTheory.Limits.IsImage F)
      (F' : CategoryTheory.Limits.MonoFactorisation f), CategoryTheory.CategoryStruct.comp F.e (hF.lift F') = F'.e :=
  by sorry

The theorem `CategoryTheory.Limits.IsImage.fac_lift` states that for any category `C`, any two objects `X` and `Y` in `C`, and any morphism `f` from `X` to `Y`, given a monic factorisation `F` of `f` that is an image, and another monic factorisation `F'` of `f`, the composition of the morphism `F.e` in `F` and the lift of `F'` under `hF` is equal to the morphism `F'.e` in `F'`. In essence, it verifies a key property of images in category theory, namely the existence of a unique morphism from the image to any other factorization of the same morphism.

For any category `C`, given morphisms `f: X → Y`, monic factorizations `F: X → I ⊟ X` and `F': X → I' ⊟ Y` of `f` that are images, the lift of `F'` under `hF` followed by `F.e` equals `F'.e`.


theorem Polynomial.coeff_update_apply :
    ∀ {R : Type u} [inst : Semiring R] (p : Polynomial R) (n : ℕ) (a : R) (i : ℕ),
      Polynomial.coeff (Polynomial.update p n a) i = if i = n then a else Polynomial.coeff p i :=
  by sorry

This theorem states that for any semiring `R`, any polynomial `p` over `R`, any natural number `n`, and any element `a` of `R`, the coefficient of the `i-th` term of the polynomial resulting from replacing the `n-th` coefficient of `p` with `a` is `a` if `i` is equal to `n`, otherwise, it is the `i-th` coefficient of the original polynomial `p`. In other words, only the `n-th` coefficient changes to `a` and all other coefficients remain the same.

For any semiring `R`, polynomial `p` over `R`, natural number `n`, and element `a` of `R`, replacing the `n`-th coefficient of `p` with `a` results in a polynomial with the `i`-th coefficient equal to the original `i`-th coefficient if `i ≠ n`, and equal to `a` if `i = n`.


theorem dist_mul_left :
    ∀ {M : Type u} [inst : PseudoMetricSpace M] [inst_1 : Mul M] [inst_2 : IsometricSMul M M] (a b c : M),
      dist (a * b) (a * c) = dist b c :=
  by sorry

The theorem `dist_mul_left` states that for any type `M` that is a pseudo-metric space with multiplication and for which scalar multiplication is isometric, the distance between the product of two elements `a` and `b` and the product of the same `a` and another element `c` is the same as the distance between `b` and `c`. In other words, multiplying by `a` does not change the distance between `b` and `c`.

For any pseudo-metric space `M` with multiplication and isometric scalar multiplication, the distance between `a * b` and `a * c` equals the distance between `b` and `c`.


theorem Ultrafilter.compl_not_mem_iff : ∀ {α : Type u} {f : Ultrafilter α} {s : Set α}, sᶜ ∉ f ↔ s ∈ f := by sorry

This theorem states that for any type `α`, any ultrafilter `f` on `α`, and any set `s` of elements of type `α`, the complement of `s` is not an element of `f` if and only if `s` is an element of `f`. In other words, a set `s` belongs to an ultrafilter `f` if and only if its complement doesn't belong to `f`. This theorem is a basic property of ultrafilters in set theory.

An ultrafilter `f` on a type `α` contains a set `s` if and only if it does not contain the complement of `s`.


NormedAddGroupHom.uniformContinuous

theorem NormedAddGroupHom.uniformContinuous :
    ∀ {V₁ : Type u_2} {V₂ : Type u_3} [inst : SeminormedAddCommGroup V₁] [inst_1 : SeminormedAddCommGroup V₂]
      (f : NormedAddGroupHom V₁ V₂), UniformContinuous ⇑f :=
  by sorry

The theorem `NormedAddGroupHom.uniformContinuous` states that for any two semi-normed additive commutative groups, `V₁` and `V₂`, any homomorphism `f` from `V₁` to `V₂` is uniformly continuous. This means that as any pair of elements `(x, y)` in `V₁` gets arbitrarily close together (i.e., tends towards the diagonal), the images of these elements under `f` (i.e., `(f x, f y)`) also get arbitrarily close together in `V₂`, no matter where `x` and `y` are in `V₁`.

Given any two semi-normed additive commutative groups `V₁` and `V₂` and any homomorphism `f` from `V₁` to `V₂`, `f` is uniformly continuous.


theorem Part.dom_iff_mem : ∀ {α : Type u_1} {o : Part α}, o.Dom ↔ ∃ y, y ∈ o := by sorry

This theorem, `Part.dom_iff_mem`, states that for any given partial function `o` of an arbitrary type `α`, the domain of `o` (`o.Dom`) exists if and only if there exists an element `y` such that `y` is an element of `o`. In other words, a partial function has a domain if it has at least one element.

A partial function `o` over type `α` has a domain if and only if there exists an element `y` in `α` such that `o y` is defined.


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

The theorem `Set.mul_subset_mul_left` states that for any type `α` that has a multiplication operation (`Mul α`), and any given sets `s`, `t₁`, and `t₂` of this type, if `t₁` is a subset of `t₂`, then the set of all products of elements in `s` with elements in `t₁` is also a subset of the set of all products of elements in `s` with elements in `t₂`. In other words, if we multiply the elements of a smaller set `t₁` by a set `s`, the resulting set will be contained within the set resulting from multiplying the larger set `t₂` by the same set `s`.

For any type `α` with multiplication and sets `s` and `t₁` being subsets of `t₂` in `α`, the set {x₁ * y₁ | x₁ ∈ s, y₁ ∈ t₁} is contained in the set {x₂ * y₂ | x₂ ∈ s, y₂ ∈ t₂}.


/-- One semiconjugates any element to itself.  -/
theorem SemiconjBy.one_left : ∀ {M : Type u_2} [inst : MulOneClass M] (x : M), SemiconjBy 1 x x := by sorry

This theorem states that for any type `M` equipped with a multiplication and a `1` (an instance of `MulOneClass`), any element `x` of type `M` is semiconjugate to itself by `1`. In mathematical terms, this means that `1 * x = x * 1` for any `x`, which is a property of the multiplicative identity in a multiplicative monoid or a similar algebraic structure.

For any type `M` with a multiplication and `1` (`MulOneClass`), the multiplicative identity `1` commutes with any element `x` in `M`, i.e., `1 * x = x * 1`.


theorem ZMod.nat_cast_zmod_eq_zero_iff_dvd : ∀ (a b : ℕ), ↑a = 0 ↔ b ∣ a := by sorry

This theorem states that for any two natural numbers `a` and `b`, the cast of `a` to `ℤ/bℤ` (the ring of integers modulo `b`) is equal to zero if and only if `b` divides `a`. Here, `b ∣ a` represents the divisibility relation where `b` divides `a`. In other words, if `a` is a multiple of `b`, then its image under the natural number to `Z/bZ` (mod `b`) casting will be zero, and conversely, if the cast of `a` to `Z/bZ` is zero, then `a` must be a multiple of `b`.

For any natural numbers `a` and `b`, `a ≡ 0 (mod b)` if and only if `b` divides `a`.


theorem AddMonoidAlgebra.sup_support_add_le :
    ∀ {R : Type u_1} {A : Type u_3} {B : Type u_5} [inst : SemilatticeSup B] [inst_1 : OrderBot B] [inst_2 : Semiring R]
      (degb : A → B) (f g : AddMonoidAlgebra R A),
      Finset.sup (f + g).support degb ≤ Finset.sup f.support degb ⊔ Finset.sup g.support degb :=
  by sorry

The theorem `AddMonoidAlgebra.sup_support_add_le` states that for any semiring `R`, types `A` and `B`, a function `degb : A → B`, and two elements `f` and `g` of the add monoid algebra generated by `A` over `R`, the supremum (greatest element) of the set `{degb x | x ∈ support(f + g)}` is less than or equal to the supremum of the set `{degb x | x ∈ support(f)}` joined with the supremum of the set `{degb x | x ∈ support(g)}`. Here, `support(f)` denotes the set of elements in `A` that appear in the formal combination `f` with a non-zero coefficient. The join operation `⊔` is defined on `B` which is assumed to be a semilattice with a bottom element.

For any semiring R, types A and B, a function degb : A → B, and elements f and g of the add monoid algebra over R generated by A, the supremum of degb over the support of f + g is less than or equal to the join of the supremum of degb over the support of f and the supremum of degb over the support of g.


theorem MeasureTheory.Measure.MeasurableSet.nullMeasurableSet_subtype_coe :
    ∀ {α : Type u_2} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} {s : Set α} {t : Set ↑s},
      MeasureTheory.NullMeasurableSet s μ → MeasurableSet t → MeasureTheory.NullMeasurableSet (Subtype.val '' t) μ :=
  by sorry

This theorem states that, for every type `α` with a given `MeasurableSpace` structure `m0` and a measure `μ`, if we have a set `s` of type `α` and a set `t` of elements that are subtypes of `s`, and if `s` is a null measurable set with respect to `μ` and `t` is a measurable set, then the set of underlying elements of `t` (obtained using the `Subtype.val` function on each element of `t`) is also a null measurable set with respect to `μ`.

In other words, it asserts that measurability and null measurability properties are preserved when going from a set of subtypes to the corresponding set of underlying elements.

If `s` is a null measurable set and `t` is a measurable subset of a measurable space `(α, m0)` with measure `μ`, then the set of underlying elements of `t` is a null measurable set.


ContinuousLinearMap.isOpenMap

/-- The Banach open mapping theorem: a surjective bounded linear map between Banach spaces is
open.  -/
theorem ContinuousLinearMap.isOpenMap :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F]
      (f : E →L[𝕜] F) [inst_5 : CompleteSpace F] [inst_6 : CompleteSpace E], Function.Surjective ⇑f → IsOpenMap ⇑f :=
  by sorry

The Banach Open Mapping Theorem states that for any non-trivially normed field 𝕜, and any Banach spaces E and F (which are normed additive commutative groups and also normed spaces over 𝕜), a surjective continuous linear map from E to F is an open map. In other words, for such a map f, every open subset of E gets mapped to an open subset of F. The spaces E and F are required to be complete, meaning that every Cauchy sequence in these spaces converges to a limit in the space itself.

A surjective continuous linear map between two complete Banach spaces is an open mapping.


theorem Ordinal.le_one_iff : ∀ {a : Ordinal.{u_3}}, a ≤ 1 ↔ a = 0 ∨ a = 1 := by sorry

The theorem `Ordinal.le_one_iff` states that for any ordinal `a`, `a` is less than or equal to 1 if and only if `a` is equal to 0 or `a` is equal to 1. In other words, in the context of ordinals, the only values that are less than or equal to 1 are 0 and 1 itself.

For any ordinal `a`, `a <= 1` if and only if `a = 0` or `a = 1`.


IsometryEquiv.surjective

theorem IsometryEquiv.surjective :
    ∀ {α : Type u} {β : Type v} [inst : PseudoEMetricSpace α] [inst_1 : PseudoEMetricSpace β] (h : α ≃ᵢ β),
      Function.Surjective ⇑h :=
  by sorry

The theorem `IsometryEquiv.surjective` states that for any two types `α` and `β`, which are provided with pseudo-emetric space structures, if there exists an isometry equivalence `h` from `α` to `β`, then the function corresponding to this isometry equivalence (`h`) is surjective. In other words, for every element in `β`, there is an element in `α` such that when the isometry equivalence `h` is applied to the element from `α`, it equals the given element in `β`.

Given isometry equivalences between pseudo-metric spaces `α` and `β`, if the equivalence is surjective, then every element in `β` has an equivalent element in `α`.


MeasureTheory.Lp.ext

theorem MeasureTheory.Lp.ext :
    ∀ {α : Type u_1} {E : Type u_2} {m0 : MeasurableSpace α} {p : ENNReal} {μ : MeasureTheory.Measure α}
      [inst : NormedAddCommGroup E] {f g : ↥(MeasureTheory.Lp E p μ)}, ↑↑f =ᶠ[MeasureTheory.Measure.ae μ] ↑↑g → f = g :=
  by sorry

This theorem states that for any type `α`, any type `E` that forms a normed add commutative group, any measurable space `m0` on `α`, any extended nonnegative real number `p`, and any measure `μ` on `α`, if `f` and `g` are elements of the `Lp` space defined over `E` with respect to the measure `μ` and `p`, then if `f` and `g` are equal almost everywhere (i.e., they are equal except on a set of measure zero), then `f` and `g` are considered equal. In other words, two functions in the `Lp` space are considered the same if they differ only on a set of measure zero.

For any measurable spaces `α`, `E` with `E` being a normed add commutative group, measure `μ` on `α`, and `p` an extended nonnegative real number, if `f` and `g` are equal almost everywhere in the `Lp` space over `E` with respect to `μ`, then `f` and `g` are equal as elements of `Lp`.


theorem Part.map_none : ∀ {α : Type u_1} {β : Type u_2} (f : α → β), Part.map f Part.none = Part.none := by sorry

This theorem states that for any types `α` and `β`, and any function `f` from `α` to `β`, mapping `f` over the `none` value in the `Part` type (which has a `False` domain and an empty function) yields the `none` value in the `Part` type. In other words, applying any function with the `Part.map` operation to an empty partial function results in another empty partial function.

For any types `α` and `β` and function `f` from `α` to `β`, the application of `f` to a `Part` with empty domain results in another `Part` with empty domain.


theorem Filter.seq_mem_seq :
    ∀ {α : Type u} {β : Type v} {f : Filter (α → β)} {g : Filter α} {s : Set (α → β)} {t : Set α},
      s ∈ f → t ∈ g → Set.seq s t ∈ Filter.seq f g :=
  by sorry

This theorem states that for all types `α` and `β`, given a filter `f` of functions from `α` to `β`, a filter `g` of `α`, a set `s` of functions from `α` to `β`, and a set `t` of `α`, if `s` is in `f` and `t` is in `g`, then the sequence operation on `s` and `t` is in the sequence operation on `f` and `g`. In simpler terms, if we have a set of functions and a set of inputs both contained in certain filters, then the set of outputs obtained by applying the functions to the inputs is also contained in a corresponding filter.

If `f` is a filter of functions from `α` to `β`, `g` is a filter of `α`, `s ∈ f`, `t ∈ g`, and `s(x) = y` for all `x ∈ t`, then the set `{y | ∃x ∈ t, s(x) = y} ∈ sequence (f, g)`.


theorem symmetrize_mem_uniformity :
    ∀ {α : Type ua} [inst : UniformSpace α] {V : Set (α × α)}, V ∈ uniformity α → symmetrizeRel V ∈ uniformity α := by
  sorry

The theorem `symmetrize_mem_uniformity` states that for any type `α` that has an associated Uniform Space, and for any set `V` of pairs from `α`, if `V` is in the uniformity of `α`, then the symmetrized relation of `V` is also in the uniformity of `α`. Here, symmetrizing a relation means creating a new relation that contains both `(a, b)` and `(b, a)` if and only if the original relation contains `(a, b)`. In other words, the symmetrized relation is the maximal symmetric relation contained in the original relation.

If `V` is a set of pairs from a uniform space `α`, then the symmetrized relation of `V` is also in the uniformity of `α`.


theorem Real.inv_rpow : ∀ {x : ℝ}, 0 ≤ x → ∀ (y : ℝ), x⁻¹ ^ y = (x ^ y)⁻¹ := by sorry

This theorem states that for any real number `x` which is greater than or equal to zero, and for any real number `y`, the inverse of `x` raised to the power of `y` is equal to the inverse of `x` raised to the power of `y`. In mathematical notation, this is written as (for every `x ≥ 0` and any `y` in the real numbers) `1/x^y = (x^y)^-1`.

For any non-negative real number `x` and real number `y`, `(x^y)^-1 = 1/x^y`.


theorem Rat.le_def : ∀ {a b c d : ℤ}, 0 < b → 0 < d → (Rat.divInt a b ≤ Rat.divInt c d ↔ a * d ≤ c * b) := by sorry

This theorem states that for any four integers `a`, `b`, `c`, and `d`, with both `b` and `d` being positive, the quotient of `a` and `b` (represented as `Rat.divInt a b`) is less than or equal to the quotient of `c` and `d` (represented as `Rat.divInt c d`) if and only if the product of `a` and `d` is less than or equal to the product of `c` and `b`. In mathematical terms, it is saying that $\frac{a}{b} \leq \frac{c}{d}$ if and only if $ad \leq cb$, under the condition that $b > 0$ and $d > 0$.

For integers `a`, `b`, `c`, and `d` with `b` and `d` positive, `Rat.divInt a b <= Rat.divInt c d` if and only if `a * d <= c * b`.


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

This theorem states that for any type `G` which has an `AddGroup` structure, and for any elements `a`, `b`, and `c` of `G`, if `a + c` equals `b`, then `a` equals `b` plus the additive inverse of `c`. In other words, if the sum of two elements in the group is equal to a third element, then the first element is equal to the difference between the third element and the second one.

For any additive group `G` and elements `a`, `b`, `c` in `G`, if `a + c = b`, then `a = b - c`.


/-- `F[S][T] = F[S ∪ T]`  -/
theorem IntermediateField.adjoin_adjoin_left :
    ∀ (F : Type u_1) [inst : Field F] {E : Type u_2} [inst_1 : Field E] [inst_2 : Algebra F E] (S T : Set E),
      IntermediateField.restrictScalars F (IntermediateField.adjoin (↥(IntermediateField.adjoin F S)) T) =
        IntermediateField.adjoin F (S ∪ T) :=
  by sorry

The theorem `IntermediateField.adjoin_adjoin_left` states that for any two sets `S` and `T` of elements from a field extension `E` over a field `F`, the field obtained by first adjoining `S` to `F` and then adjoining `T` to the result is the same as the field obtained by adjoining the union of `S` and `T` to `F`. In other words, the process of adjoining is associative with respect to the union of sets. This is written in mathematical notation as `F[S][T] = F[S ∪ T]`.
The field `F` and the field extension `E` are both assumed to be algebraically structured over `F`.

The theorem asserts that for any sets S and T of elements from a field extension E over a field F, the fields F[S][T] and F[S ∪ T] are equal.


theorem Polynomial.finite_setOf_isRoot :
    ∀ {R : Type u} [inst : CommRing R] [inst_1 : IsDomain R] {p : Polynomial R},
      p ≠ 0 → Set.Finite {x | Polynomial.IsRoot p x} :=
  by sorry

This theorem states that for any commutative ring `R` which is also an integral domain, and for any non-zero polynomial `p` over `R`, the set of roots of `p` (i.e., the set of elements `x` in `R` such that `p` evaluated at `x` equals 0) is finite. In other words, a non-zero polynomial over an integral domain has only finitely many roots.

In an integral domain, a non-zero polynomial has finitely many roots.


theorem ONote.NFBelow.repr_lt : ∀ {o : ONote} {b : Ordinal.{0}}, ONote.NFBelow o b → ONote.repr o < Ordinal.omega ^ b :=
  by sorry

This theorem states that for any ordinal notation `o` and any ordinal `b` in the base universe, if the normal form of `o` is strictly below `b`, then the ordinal represented by `o` is strictly less than omega (the first infinite ordinal) raised to the power of `b`. In mathematical terms, if `o` is an ordinal notation and `b` is an ordinal such that the normal form of `o` is less than `b`, then the ordinal corresponding to `o` is less than ω^b, where ω is the ordinal corresponding to the set of natural numbers.

For any ordinal notation `o` and ordinal `b`, if the normal form of `o` is strictly less than `b`, then the ordinal represented by `o` is strictly less than the ordinal ω^b.