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

The theorem `PartialHomeomorph.image_source_inter_eq'` states that for any given partial homeomorphism `e` from a set `X` to a set `Y`, where both `X` and `Y` are equipped with a topological structure, and for any subset `s` of `X`, the image of the intersection of `e.source` and `s` under the mapping `e` is equal to the intersection of `e.target` and the preimage of `s` under the inverse of the partial homeomorphism `e`. Here, `e.source` refers to the domain of definition of the partial homeomorphism `e` and `e.target` refers to the set `Y`. This theorem connects the concepts of image, preimage, intersection, and inverses in the context of partial homeomorphisms between topological spaces.

For any partial homeomorphism between topological spaces, the image of the intersection of its domain and a subset is equal to the intersection of its range and the preimage of that subset under its inverse.


/-- The Hausdorff edistance of a set to itself vanishes.  -/
theorem EMetric.hausdorffEdist_self :
    ∀ {α : Type u} [inst : PseudoEMetricSpace α] {s : Set α}, EMetric.hausdorffEdist s s = 0 := by sorry

This theorem states that the Hausdorff edistance (extended metric) of a set to itself is always zero. In other words, for any set `s` in a given pseudo extended metric space `α`, if you calculate the Hausdorff edistance from the set `s` to the same set `s`, the result will always be zero. This is consistent with the general principle that the distance from any point to itself, in any conventional metric space, is zero.

In any pseudo extended metric space, the Hausdorff distance between a set and itself is zero.


theorem cmp_compares : ∀ {α : Type u_1} [inst : LinearOrder α] (a b : α), Ordering.Compares (cmp a b) a b := by sorry

This theorem, `cmp_compares`, states that for any type `α` with a linear order, and any two elements `a` and `b` of that type, the `cmp` function, which assigns an `Ordering` to the pair `(a, b)`, satisfies the `Ordering.Compares` property with respect to `a` and `b`. In other words, the relation between `a` and `b` indicated by the `Ordering` returned by `cmp a b` (less than, equal to, or greater than) accurately describes the actual relation between `a` and `b` according to their linear order.

For any type `α` with a linear order and any `a, b : α`, the `cmp` function returns an `Ordering` that accurately reflects the comparison of `a` and `b` according to the linear order.


theorem Nat.count_nth :
    ∀ {p : ℕ → Prop} [inst : DecidablePred p] {n : ℕ},
      (∀ (hf : Set.Finite (setOf p)), n < (Set.Finite.toFinset hf).card) → Nat.count p (Nat.nth p n) = n :=
  by sorry

The theorem `Nat.count_nth` states that for any decidable predicate `p` applied to natural numbers, and for any natural number `n`, if `n` is strictly less than the cardinality of the finite set derived from the predicate `p`, then the count of natural numbers less than the `n`-th natural number satisfying `p` equals `n` itself. In other words, it counts how many natural numbers below the `n`-th number satisfy the predicate `p` and asserts that this count is equal to `n`.

For any decidable predicate `p` on natural numbers and `n` less than the cardinality of `{x | p x}`, the number of natural numbers `x` such that `x < n` and `p x` holds equals `n`.


LinearIsometry.injective

theorem LinearIsometry.injective :
    ∀ {R : Type u_1} {R₂ : Type u_2} {E₂ : Type u_6} {F : Type u_9} [inst : Semiring R] [inst_1 : Semiring R₂]
      {σ₁₂ : R →+* R₂} [inst_2 : SeminormedAddCommGroup E₂] [inst_3 : Module R₂ E₂] [inst_4 : NormedAddCommGroup F]
      [inst_5 : Module R F] (f₁ : F →ₛₗᵢ[σ₁₂] E₂), Function.Injective ⇑f₁ :=
  by sorry

The theorem `LinearIsometry.injective` states that for any semirings `R` and `R₂`, any seminormed additive commutative group `E₂`, any normed additive commutative group `F`, any module over `R₂` on `E₂`, any module over `R` on `F`, and any linear isometry `f₁` from `F` to `E₂` with ring homomorphism `σ₁₂` from `R` to `R₂`, the corresponding function `f₁` is injective. In other words, if `f₁ x = f₁ y` then `x = y` for any `x` and `y` in `F`. This theorem is a fundamental property of linear isometries in the context of semirings, seminormed additive commutative groups, normed additive commutative groups, and modules.

Given any linear isometry `f₁` from a normed additive commutative group `F` to a seminormed additive commutative group `E₂` with compatible ring homomorphisms, `f₁` is injective.


theorem Cardinal.toNat_strictMonoOn : StrictMonoOn (⇑Cardinal.toNat) (Set.Iio Cardinal.aleph0) := by sorry

The theorem `Cardinal.toNat_strictMonoOn` states that the function `Cardinal.toNat`, which maps finite cardinal numbers to their corresponding natural number while assigning 0 to all infinite cardinal numbers, is strictly increasing on the left-infinite right-open interval of cardinals less than `ℵ₀` (the smallest infinite cardinal). In other words, for all cardinals `a` and `b` in this interval such that `a` is less than `b`, the natural number associated with `a` by `Cardinal.toNat` is less than the natural number associated with `b`.

For all $a, b$ with $0 < a < \aleph\_0$ and $a < b$, we have $\text{Cardinal.toNat}\ a < \text{Cardinal.toNat}\ b$.


theorem div_le_iff_of_neg :
    ∀ {α : Type u_2} [inst : LinearOrderedField α] {a b c : α}, c < 0 → (b / c ≤ a ↔ a * c ≤ b) := by sorry

This theorem states that for any type `α` which is a linear ordered field, and for any three elements `a`, `b`, `c` of the type `α`, if `c` is less than zero, then `b` divided by `c` is less than or equal to `a` if and only if `a` times `c` is less than or equal to `b`. It essentially provides a condition for a certain inequality involving division and multiplication to hold in the context of a linear ordered field, under the condition that `c` is negative.

For any linear ordered field `α` and elements `a`, `b`, `c` in `α` with `c` negative, `b/c ≤ a` if and only if `a*c ≤ b`.


theorem Set.compl_sUnion : ∀ {α : Type u_1} (S : Set (Set α)), (⋃₀ S)ᶜ = ⋂₀ (compl '' S) := by sorry

This theorem states that for any type `α` and a set `S` of subsets of `α`, the complement of the union of all subsets in `S` is equal to the intersection of the complements of all subsets in `S`. In other words, it expresses De Morgan's law for sets: the complement of the union is the intersection of the complements. In terms of mathematical notation, given a set `S` of subsets of a universal set `U`, it asserts that the equality `(⋃₀ S)ᶜ = ⋂₀ (compl '' S)` holds, where `⋃₀ S` denotes the union of all subsets in `S`, `⋂₀` denotes the intersection over all subsets, `ᶜ` denotes set complement, and `compl '' S` is the image of `S` under the complement function.

The complement of the union of a set of subsets is equal to the intersection of the complements of those subsets. (De Morgan's law for sets)


theorem normalize_one :
    ∀ {α : Type u_1} [inst : CancelCommMonoidWithZero α] [inst_1 : NormalizationMonoid α], normalize 1 = 1 := by sorry

The theorem `normalize_one` states that for any type `α` that has a `CancelCommMonoidWithZero` and a `NormalizationMonoid` structure, the `normalize` function applied to the multiplicative identity `1` yields `1`. In other words, normalizing `1` does not change its value in any such algebraic structure.

For any type `α` equipped with both a `CancelCommMonoidWithZero` and a `NormalizationMonoid` structure, the normalization of the multiplicative identity `1` is equal to `1`.


theorem Matrix.diagonal_map :
    ∀ {n : Type u_3} {α : Type v} {β : Type w} [inst : DecidableEq n] [inst_1 : Zero α] [inst_2 : Zero β] {f : α → β},
      f 0 = 0 → ∀ {d : n → α}, Matrix.map (Matrix.diagonal d) f = Matrix.diagonal fun m => f (d m) :=
  by sorry

The theorem `Matrix.diagonal_map` states that for any types `n`, `α`, and `β`, given that `n` has a decidable equality, `α` and `β` have a zero element, and a function `f` from `α` to `β` such that `f` of zero equals zero, for any function `d : n → α`, mapping `f` over the diagonal matrix of `d` results in the diagonal matrix of `f` applied to `d`. In other words, applying a function to every element of a diagonal matrix while maintaining the diagonal structure is equivalent to first applying the function to the diagonal entries and then forming a diagonal matrix.

For any type `n` with decidable equality, types `α` and `β` with zero elements, and a function `f : α → β` with `f 0 = 0`, the application of `f` to the diagonal matrix of a function `d : n → α` is equal to the diagonal matrix of `f` applied to `d`.


theorem Function.iterate_one : ∀ {α : Type u} (f : α → α), f^[1] = f := by sorry

This theorem states that for any function `f` from a type `α` to itself, iterating `f` once (i.e., applying `f` once to its argument) is equivalent to `f` itself. Here, `f^[1]` denotes the result of applying the function `f` once.

For any function `f` from type `α`, `f^[1]` equals `f`.


theorem norm_le_norm_add_norm_sub' : ∀ {E : Type u_6} [inst : SeminormedAddGroup E] (u v : E), ‖u‖ ≤ ‖v‖ + ‖u - v‖ := by
  sorry

This theorem states that for any seminormed add group `E`, and for any two elements `u` and `v` in `E`, the norm of `u` is less than or equal to the sum of the norm of `v` and the norm of the difference between `u` and `v`. This is a generalization of the triangle inequality in the context of seminormed add groups.

For any seminormed add group `E` and elements `u`, `v` in `E`, |u| ≤ |v| + |u - v|.


theorem LinearMap.mem_range :
    ∀ {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

This theorem, named `LinearMap.mem_range`, states that for all types `R`, `R₂`, `M`, `M₂`, and `F`, given certain conditions, an element `x` of type `M₂` is in the range of a linear map `f` if and only if there exists an element `y` such that the result of applying the function `f` to `y` equals `x`.

The conditions required are that `R` and `R₂` are semirings, `M` and `M₂` are additive commutative monoids, `M` and `M₂` are modules over `R` and `R₂` respectively, there is a ring homomorphism `τ₁₂` from `R` to `R₂` which is surjective, `F` is a type that behaves like a function from `M` to `M₂`, and `F` belongs to the class of semilinear maps `SemilinearMapClass` from `M` to `M₂` for `τ₁₂`.

Given semirings R and R₂, additive commutative monoids and modules M and M₂ over R and R₂ respectively, a surjective ring homomorphism τ₁₂ from R to R₂, and a semilinear map F from M to M₂ with respect to τ₁₂, an element x of M₂ is in the range of the linear map F if and only if there exists an element y in M such that F(y) = x.


/-- A version of `lt_top_iff_ne_top` for `WithTop` that only requires `LT α`, not
`PartialOrder α`.  -/
theorem WithTop.lt_top_iff_ne_top : ∀ {α : Type u_1} [inst : LT α] {x : WithTop α}, x < ⊤ ↔ x ≠ ⊤ := by sorry

This theorem, `WithTop.lt_top_iff_ne_top`, states that for any type `α` equipped with a less than (`LT`) relation, and for any value `x` of the type `WithTop α` (that is, `α` extended with a top element), `x` is less than the top element if and only if `x` is not equal to the top element. This theorem doesn't require `α` to have a partial order structure, only a less than relation.

For any type `α` with a less than relation `LT`, and for any `x` in `WithTop α`, `x` is less than the top element if and only if `x` is not equal to the top element.


theorem not_and_of_not_left : ∀ {a : Prop} (b : Prop), ¬a → ¬(a ∧ b) := by sorry

This theorem states that for any two logical propositions `a` and `b`, if `a` is not true (denoted as `¬a`), then the combined statement "`a` and `b`" (denoted as `a ∧ b`) is also not true (denoted as `¬(a ∧ b)`). In other words, if we know that `a` is false, then any statement saying both `a` and `b` are true must also be false. This is a fundamental principle in classical logic.

The negation of the conjunction of two propositions is logically equivalent to the negation of each proposition.


theorem Mathlib.GroupTheory.Subgroup.Basic._auxLemma.69 :
    ∀ {G : Type u_1} [inst : Group G] {N : Type u_5} [inst_1 : Group N] {K : Subgroup N} {f : G →* N} {x : G},
      (x ∈ Subgroup.comap f K) = (f x ∈ K) :=
  by sorry

This theorem states that for any groups `G` and `N`, a subgroup `K` of `N`, a group homomorphism `f` from `G` to `N`, and any element `x` of `G`, `x` is an element of the preimage subgroup of `K` under `f` if and only if the image of `x` under `f` is an element of `K`. In mathematical terms, this is saying that for any $x \in G$, $x \in f^{-1}(K)$ if and only if $f(x) \in K$.

For any group homomorphism $f$ from group $G$ to group $N$ and subgroup $K$ of $N$, $x \in G$ lies in the preimage $f^{-1}(K)$ if and only if $f(x) \in K$.


theorem Mathlib.GroupTheory.Subgroup.Basic._auxLemma.70 :
    ∀ {G : Type u_1} [inst : AddGroup G] {N : Type u_5} [inst_1 : AddGroup N] {K : AddSubgroup N} {f : G →+ N} {x : G},
      (x ∈ AddSubgroup.comap f K) = (f x ∈ K) :=
  by sorry

This theorem states that for any types `G` and `N` that are equipped with `AddGroup` structures, any subgroup `K` of `N`, any homomorphism `f` from `G` to `N`, and any element `x` of `G`, the element `x` is in the preimage of the subgroup `K` under the homomorphism `f` if and only if the image of `x` under `f` is in `K`. In simpler terms, `x` is in the preimage of `K` via `f` exactly when `f(x)` is in `K`.

For any AddGroup types G and N, homomorphism f : G -> N, subgroup K of N, and element x in G, x is in the preimage of K under f if and only if f(x) is in K.


theorem MulAction.pow_smul_eq_iff_period_dvd :
    ∀ {α : Type v} {M : Type u} [inst : Monoid M] [inst_1 : MulAction M α] {n : ℕ} {m : M} {a : α},
      m ^ n • a = a ↔ MulAction.period m a ∣ n :=
  by sorry

The theorem `MulAction.pow_smul_eq_iff_period_dvd` states that for any monoid `M`, any `M`-set `α`, any natural number `n`, any element `m` of `M`, and any element `a` of `α`, the condition that `m` to the power `n` acting on `a` equals `a` is equivalent to the statement that the period of the multiplicative action of `m` on `a` divides `n`. This period is defined as the smallest positive `n` such that `m` to the power `n` acting on `a` equals `a` or `0` if no such `n` exists.

For any monoid action on an set, the power of an element acting on another equals the identity if and only if the period of the action of that element on the other element divides the power.


theorem StructureGroupoid.mem_of_eqOnSource :
    ∀ {H : Type u} [inst : TopologicalSpace H] (G : StructureGroupoid H) {e e' : PartialHomeomorph H H},
      e ∈ G → e' ≈ e → e' ∈ G :=
  by sorry

The theorem `StructureGroupoid.mem_of_eqOnSource` states that for any type `H` with a topological space structure, given a structure groupoid `G` on `H` and two partial homeomorphisms `e` and `e'` from `H` to `H`, if `e` is an element of `G` and `e'` is equivalent to `e` in the sense that they are defined on the same source and their restrictions to this source coincide, then `e'` is also an element of `G`.

If `e` is an element of a groupoid `G` on a topological space `H` and `e'` is a partial homeomorphism equivalent to `e` with the same source, then `e'` is also an element of `G`.


theorem Even.add_odd : ∀ {α : Type u_2} [inst : Semiring α] {m n : α}, Even m → Odd n → Odd (m + n) := by sorry

The theorem `Even.add_odd` states that for any type `α` that is a semiring, if we have two elements `m` and `n` of this type, with `m` being even and `n` being odd, then the sum of `m` and `n` is also odd. In mathematical terms, if there exists some `r` such that `m = r + r` (definition of `m` being even) and there exists some `k` such that `n = 2*k + 1` (definition of `n` being odd), then there exists some `l` such that `m + n = 2*l + 1`, which makes `m + n` odd.

If `m` is even and `n` is odd in a semiring, then their sum `m + n` is odd. ( mathematically expressed as: `∃ r, m = r + r ∧ ∃ k, n = 2*k + 1 → ∃ l, m + n = 2*l + 1`)


theorem Zsqrtd.nonnegg_neg_pos : ∀ {c d a b : ℕ}, Zsqrtd.Nonnegg c d (-↑a) ↑b ↔ Zsqrtd.SqLe a d b c := by sorry

The theorem `Zsqrtd.nonnegg_neg_pos` states that for all natural numbers `c`, `d`, `a`, and `b`, the property `Zsqrtd.Nonnegg c d (-↑a) ↑b` holds if and only if `Zsqrtd.SqLe a d b c` is true. This means that a negative integer times the square root of `c` plus a positive integer times the square root of `d` is non-negative if and only if the square of the natural number `a` multiplied by `d` is less than or equal to the square of the natural number `b` multiplied by `c`. In mathematical terms, `-a √c + b √d ≥ 0` if and only if `d * a^2 ≤ c * b^2`.

The theorem `Zsqrtd.nonnegg_neg_pos` asserts that `-a * sqrt(c) + b * sqrt(d) >= 0` is equivalent to `d * a^2 <= c * b^2`.


theorem AffineIsometry.angle_map :
    ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V]
      [inst_2 : MetricSpace P] [inst_3 : NormedAddTorsor V P] {V₂ : Type u_3} {P₂ : Type u_4}
      [inst_4 : NormedAddCommGroup V₂] [inst_5 : InnerProductSpace ℝ V₂] [inst_6 : MetricSpace P₂]
      [inst_7 : NormedAddTorsor V₂ P₂] (f : P →ᵃⁱ[ℝ] P₂) (p₁ p₂ p₃ : P),
      EuclideanGeometry.angle (f p₁) (f p₂) (f p₃) = EuclideanGeometry.angle p₁ p₂ p₃ :=
  by sorry

The theorem `AffineIsometry.angle_map` states that for any real affine isometry `f` and any three points `p1`, `p2`, `p3` in a given metric space with inner product and normed add torsor, the angle at the image of `p2` under `f`, between the line segments to the images of `p1` and `p3` is equal to the angle at `p2` between the line segments to `p1` and `p3`. Thus, this theorem shows that affine isometries preserve the angle between line segments.

The theorem `AffineIsometry.angle_map` asserts that given any real affine isometry `f` and points `p1`, `p2`, `p3` in a metric space with inner product and normed add torsor, the angle between the line segments from `p1` to `p2` and from `p1` to `p3` is equal to the angle between the line segments from `f(p2)` to `f(p1)` and from `f(p2)` to `f(p3)`.


theorem Polynomial.eq_prod_roots_of_monic_of_splits_id :
    ∀ {K : Type v} [inst : Field K] {p : Polynomial K},
      Polynomial.Monic p →
        Polynomial.Splits (RingHom.id K) p →
          p = Multiset.prod (Multiset.map (fun a => Polynomial.X - Polynomial.C a) (Polynomial.roots p)) :=
  by sorry

The theorem states that for any field `K` and any monic polynomial `p` over `K`, if `p` splits over `K` (meaning it is either the zero polynomial or all of its irreducible factors have degree 1), then `p` can be expressed as the product of linear factors `(Polynomial.X - Polynomial.C a)`, where `a` is a root of `p`. Each root `a` is included in the product with multiplicity equal to its multiplicity as a root of `p`. In mathematical terms, this corresponds to the statement that a monic polynomial is equal to the product of `(X - a_i)` over all its roots `a_i`.

A monic polynomial over a field that splits into linear factors is equal to the product of these factors, where each factor corresponds to a root with the root's multiplicity.


theorem Real.volume_val :
    ∀ (s : Set ℝ), ↑↑MeasureTheory.volume s = ↑↑(StieltjesFunction.measure StieltjesFunction.id) s := by sorry

This theorem states that for any set `s` of real numbers, the measure of `s` under the Lebesgue measure (denoted by `MeasureTheory.volume s`) is equal to the measure of `s` under the measure associated with the identity Stieltjes function. In mathematical terms, this could be written as: for all subsets `s` of ℝ, the Lebesgue measure of `s` equals the measure of `s` given by the Stieltjes function associated with the identity function on ℝ.

For any set `s` of real numbers, the Lebesgue measure of `s` equals the measure of `s` with respect to the Stieltjes integral using the identity function.


theorem Function.support_binop_subset :
    ∀ {α : Type u_1} {M : Type u_5} {N : Type u_6} {P : Type u_7} [inst : Zero M] [inst_1 : Zero N] [inst_2 : Zero P]
      (op : M → N → P),
      op 0 0 = 0 →
        ∀ (f : α → M) (g : α → N),
          (Function.support fun x => op (f x) (g x)) ⊆ Function.support f ∪ Function.support g :=
  by sorry

The theorem `Function.support_binop_subset` states that for any types `α`, `M`, `N`, and `P`, where `M`, `N`, and `P` all have a `Zero` instance, and for any binary operation `op` from `M` and `N` to `P` that satisfies `op 0 0 = 0`, for any functions `f` from `α` to `M` and `g` from `α` to `N`, the support (set of points where the function is not zero) of the function `x => op (f x) (g x)` is a subset of the union of the supports of functions `f` and `g`. This theorem essentially conveys that any point where the composed operation produces a non-zero result must also be a point where either `f` or `g` (or both) produce a non-zero result.

For functions `f : α → M` and `g : α → N` with types having `Zero` instances, and a binary operation `op : M × N → P` satisfying `op 0 0 = 0`, the support of `x => op (f x) (g x)` is contained in the union of the supports of `f` and `g`.


theorem Real.exp_lt_one_iff : ∀ {x : ℝ}, Real.exp x < 1 ↔ x < 0 := by sorry

The theorem `Real.exp_lt_one_iff` states that for all real numbers `x`, the exponential of `x` is less than 1 if and only if `x` is less than 0. In other words, this theorem establishes a bi-conditional relationship between a real number being less than 0 and its exponential value being less than 1.

For all real numbers x, exp(x) < 1 if and only if x < 0.


/-- Homotopic maps induce the same map on homology.
 -/
theorem homology'_map_eq_of_homotopy :
    ∀ {ι : Type u_1} {V : Type u} [inst : CategoryTheory.Category.{v, u} V] [inst_1 : CategoryTheory.Preadditive V]
      {c : ComplexShape ι} {C D : HomologicalComplex V c} {f g : C ⟶ D} [inst_2 : CategoryTheory.Limits.HasEqualizers V]
      [inst_3 : CategoryTheory.Limits.HasCokernels V] [inst_4 : CategoryTheory.Limits.HasImages V]
      [inst_5 : CategoryTheory.Limits.HasImageMaps V],
      Homotopy f g → ∀ (i : ι), (homology'Functor V c i).map f = (homology'Functor V c i).map g :=
  by sorry

This theorem states that if two morphisms (`f` and `g`) between two homological complexes (`C` and `D`) in a category `V` are homotopic, then they induce the same map on homology for any indexing type `ι`. This holds under the conditions that the category `V` is preadditive, has equalizers, cokernels, images, and image maps. In simpler terms, the homology of two homotopic morphisms in a suitable category will be equal.

If `f` and `g` are homotopic morphisms between homological complexes `C` and `D` in a preadditive category `V` with equalizers, cokernels, images, and image maps, then they induce equal homology maps for any indexing type `ι`.


theorem PartialHomeomorph.extend_coord_change_source :
    ∀ {𝕜 : Type u_1} {E : Type u_2} {M : Type u_3} {H : Type u_4} [inst : NontriviallyNormedField 𝕜]
      [inst_1 : NormedAddCommGroup E] [inst_2 : NormedSpace 𝕜 E] [inst_3 : TopologicalSpace H]
      [inst_4 : TopologicalSpace M] (f f' : PartialHomeomorph M H) (I : ModelWithCorners 𝕜 E H),
      (PartialEquiv.trans (PartialEquiv.symm (PartialHomeomorph.extend f I)) (PartialHomeomorph.extend f' I)).source =
        ↑I '' (PartialHomeomorph.trans (PartialHomeomorph.symm f) f').source :=
  by sorry

The theorem `PartialHomeomorph.extend_coord_change_source` states that for any nontrivially normed field `𝕜`, normed add commutative group `E`, any types `M` and `H` both with a topological space structure, any two partial homeomorphisms `f` and `f'` from `M` to `H`, and any model with corners `I` from `𝕜` to `E` to `H`, the source of the partial equivalence obtained by transforming the extension of `f` through `I` to a partial equivalence, taking the inverse, then composing it with the extension of `f'` through `I`, is the image under `I` of the source of the partial homeomorphism obtained by first taking the inverse of `f` then composing it with `f'`. This theorem is about the compatibility of the extension and inverse operations on partial homeomorphisms and model with corners with the source operation on partial equivalences and homeomorphisms.

Given a nontrivially normed field `𝕜`, normed add commutative group `E`, types `M` and `H` with topological space structures, partial homeomorphisms `f` and `f'` from `M` to `H`, and a model with corners `I` from `𝕜` to `E` to `H`, the sources of the partial equivalences obtained by transforming and composing the inverses and extensions of `f` and `f'` through `I` are equal.


theorem isometry_mul_right :
    ∀ {M : Type u} [inst : Mul M] [inst_1 : PseudoEMetricSpace M] [inst_2 : IsometricSMul Mᵐᵒᵖ M] (a : M),
      Isometry fun x => x * a :=
  by sorry

The theorem `isometry_mul_right` states that for any given type `M`, if `M` has an operation of multiplication (`Mul`), has a structure of a pseudoemetric space (`PseudoEMetricSpace`), and scalar multiplication by elements of `Mᵐᵒᵖ` is an isometry (`IsometricSMul`), then for any element `a` of `M`, the function that multiplies every element of `M` by `a` from the right is an isometry. In other words, in such a space, right multiplication by a fixed element preserves the edistance between any two points.

If `M` is a type equipped with a pseudo-metric, multiplication, and isometric right scalar multiplication, then right multiplication by any fixed element preserves the pseudo-metric.


MeasureTheory.MeasurePreserving.id

theorem MeasureTheory.MeasurePreserving.id :
    ∀ {α : Type u_1} [inst : MeasurableSpace α] (μ : MeasureTheory.Measure α), MeasureTheory.MeasurePreserving id μ μ :=
  by sorry

This theorem states that for any measurable space `α` and any measure `μ` on that space, the identity function preserves the measure. In other words, applying the identity function to any set in the space does not change its measure under `μ`. In terms of measure theory, it essentially says that the measure of a set remains the same when we do nothing to the set.

For any measurable space `(α, Σ, μ)`, the measure of a set `A ∈ Σ` under `μ` is equal to the measure of its identity image `{x ∈ α | x ∈ A}`. In symbols: `μ(A) = μ({x | x ∈ A})`.


theorem Zsqrtd.norm_eq_mul_conj : ∀ {d : ℤ} (n : ℤ√d), ↑(Zsqrtd.norm n) = n * star n := by sorry

The theorem `Zsqrtd.norm_eq_mul_conj` states that for any integer `d` and any element `n` from the integer ring `ℤ[√d]`, the norm of `n` (as defined by the function `Zsqrtd.norm`) is equal to the product of `n` and its conjugate (where the conjugate is denoted by `star n`). In mathematical terms, this means that if `n` is an element of `ℤ[√d]`, then the norm of `n` (represented as `n.re * n.re - d * n.im * n.im`) is equal to the product of `n` and its conjugate.

For any integer `d` and element `n` in the integer ring `ℤ[√d]`, the norm of `n` equals the product of `n` and its conjugate: `n.re * n.re - d * n.im * n.im = n * star n`.


theorem List.map_bind :
    ∀ {α : Type u} {β : Type v} {γ : Type w} (g : β → List γ) (f : α → β) (l : List α),
      List.bind (List.map f l) g = List.bind l fun a => g (f a) :=
  by sorry

The theorem `List.map_bind` states that for any types `α`, `β`, and `γ`, and for any functions `g` from `β` to `List γ` and `f` from `α` to `β`, and for any list `l` of type `List α`, the operation of first mapping `f` over the list `l` and then binding the result with `g` is equivalent to the operation of binding the list `l` with the function that applies `f` to an element and then applies `g` to the result. This theorem is a property of the `List` monad and is analogous to the monad law of associativity.

For any types `α`, `β`, and `γ`, and functions `f: α → β` and `g: β → List γ`, the application of `List.map` with `f` followed by `List.bind` with `g` on a list `l` of type `List α` is equal to the application of `List.bind` with the composite function `x ↦ f x >> g` on list `l`.


IsUnit.inv

theorem IsUnit.inv : ∀ {α : Type u} [inst : DivisionMonoid α] {a : α}, IsUnit a → IsUnit a⁻¹ := by sorry

The theorem `IsUnit.inv` states that for any type `α` that is a division monoid, for any element `a` of `α`, if `a` is a unit (i.e., it has a two-sided inverse), then the inverse of `a` (`a⁻¹`) is also a unit. In other words, if an element has an inverse in the division monoid, then its inverse also has an inverse, which is the original element itself.

If `α` is a division monoid and `a` is a unit in `α`, then `a⁻¹` is also a unit in `α`.


theorem PartENat.toWithTop_top' : ∀ {h : Decidable ⊤.Dom}, PartENat.toWithTop ⊤ = ⊤ := by sorry

This theorem states that for any decidable instance `h` of the domain of the top element `⊤`, the operation of converting this top element from a partial natural number (`PartENat`) to a natural number with infinity (`ℕ∞`) using the `toWithTop` function will yield the top element. In other words, converting the top element of `PartENat` to `ℕ∞` preserves the topness of the element.

For any decidable instance `h` of the domain, `toWithTop h ⊤ = ⊤` in `ℕ∞`, where `⊤` is the top element in `PartENat`.


theorem LaurentPolynomial.T_zero : ∀ {R : Type u_1} [inst : Semiring R], LaurentPolynomial.T 0 = 1 := by sorry

This theorem states that for any semiring `R`, the `T` function of the Laurent Polynomial, when evaluated at 0, gives the value 1. Here, `LaurentPolynomial.T` is a function from integers to Laurent polynomials over `R`. It corresponds to the function `n ↦ T ^ n` in mathematics, but is defined in a different way due to technical reasons.

For any semiring `R`, the value of the Laurent Polynomial `T` function evaluated at `0` is equal to `1`.


theorem Set.empty_prod : ∀ {α : Type u_1} {β : Type u_2} {t : Set β}, ∅ ×ˢ t = ∅ := by sorry

The theorem `Set.empty_prod` states that for all types `α` and `β`, and for any set `t` of type `β`, the cartesian product of the empty set (denoted by `∅`) and `t` is equal to the empty set. In mathematical notation, this could be written as `∅ × t = ∅`. This theorem reflects the idea that if you form pairs where one component must come from an empty set, you can't form any pairs, resulting in an empty set.

The empty set taken as a factor in a cartesian product results in an empty set for any set as the second factor. (i.e., ∅ × t = ∅)


theorem Sum.Lex.inl_lt_inl_iff :
    ∀ {α : Type u_1} {β : Type u_2} [inst : LT α] [inst_1 : LT β] {a b : α},
      toLex (Sum.inl a) < toLex (Sum.inl b) ↔ a < b :=
  by sorry

This theorem, `Sum.Lex.inl_lt_inl_iff`, states that for any two types `α` and `β` equipped with a less than relation (`<`), the `toLex` function applied to the injection of an element `a` from `α` into the sum type (`Sum.inl a`) is less than the `toLex` function applied to the injection of another element `b` from `α` into the sum type (`Sum.inl b`) if and only if `a` is less than `b`. In other words, the `toLex` function preserves the order of elements when they are injected into the sum type using `Sum.inl`.

For any types `α` equipped with a total order `<`, and for all `a` and `b` in `α`, `Sum.inl a < Sum.inl b` in the lexicographic order on `Sum α` if and only if `a < b` in `α`.


/-- `SameRay.neg` as an `iff`.  -/
theorem sameRay_neg_iff :
    ∀ {R : Type u_1} [inst : StrictOrderedCommRing R] {M : Type u_2} [inst_1 : AddCommGroup M] [inst_2 : Module R M]
      {x y : M}, SameRay R (-x) (-y) ↔ SameRay R x y :=
  by sorry

The theorem `sameRay_neg_iff` states that for any strict ordered commutative ring `R`, and an additive commutative group `M` which is also a module over `R`, any two elements `x` and `y` of `M` are in the same ray if and only if their negations `-x` and `-y` are in the same ray. The concept of being in the "same ray" involves the vectors being zero or the existence of positive multiples of them that are equal (i.e., one vector is a positive scalar multiple of the other).

For any strict ordered commutative ring R and additive commutative group M as an R-module, x and y in M are in the same ray if and only if -x and -y are in the same ray.


theorem Filter.HasBasis.eq_iInf :
    ∀ {α : Type u_1} {ι : Sort u_4} {l : Filter α} {s : ι → Set α},
      Filter.HasBasis l (fun x => True) s → l = ⨅ i, Filter.principal (s i) :=
  by sorry

This theorem states that for any type `α` and an indexing type `ι`, given a filter `l` on `α` and a function `s` from `ι` to the set of `α`, if `l` has a basis such that every set in the basis is included (the predicate is always true), then the filter `l` is equal to the infimum of the principal filters of the sets `s(i)` as `i` varies over `ι`. Here, a principal filter of a set `s` is the collection of all supersets of `s`, and the infimum of a collection of filters is the greatest filter that is less than or equal to all filters in the collection.

If `α` is a type, `ι` is an indexing type, `l` is a filter on `α`, `s` is a function from `ι` to `α`, and `l` has a basis consisting of sets all included in some `s(i)`, then `l` is the infimum of the principal filters of `s(i)` as `i` varies over `ι`.


theorem Finset.sort_sorted :
    ∀ {α : Type u_1} (r : α → α → Prop) [inst : DecidableRel r] [inst_1 : IsTrans α r] [inst_2 : IsAntisymm α r]
      [inst_3 : IsTotal α r] (s : Finset α), List.Sorted r (Finset.sort r s) :=
  by sorry

The theorem `Finset.sort_sorted` states that for any type `α` and any relation `r` on `α` that is a decidable, transitive, antisymmetric and total relation, the list obtained by sorting a finset `s` of `α` using the relation `r` is a sorted list with respect to the relation `r`. In other words, given a set of elements, if we have a rule to decide the order between any two elements and this order is consistent (transitive, antisymmetric, and total), then the list obtained by sorting the set using our rule will indeed be sorted according to our order rule.

For any decidable, transitive, antisymmetric, and total relation `r` on a type `α`, sorting a finset of `α` using `r` results in a sorted list with respect to `r`.


theorem Finset.erase_ssubset :
    ∀ {α : Type u_1} [inst : DecidableEq α] {a : α} {s : Finset α}, a ∈ s → Finset.erase s a ⊂ s := by sorry

The theorem `Finset.erase_ssubset` states that for any type `α` with decidable equality, any element `a` of type `α`, and any finite set `s` of elements of type `α`, if `a` is an element of `s`, then the set resulting from erasing `a` from `s` (denoted as `Finset.erase s a`) is a strict subset of `s`. In other words, removing an element from a set results in a smaller set.

For any type `α` with decidable equality, if `a` is an element of a finite set `s` of type `α`, then `Finset.erase s a` is a strict subset of `s`.


theorem Filter.tendsto_def :
    ∀ {α : Type u} {β : Type v} {f : α → β} {l₁ : Filter α} {l₂ : Filter β},
      Filter.Tendsto f l₁ l₂ ↔ ∀ s ∈ l₂, f ⁻¹' s ∈ l₁ :=
  by sorry

The theorem `Filter.tendsto_def` states that for any two types `α` and `β`, and any function `f` from `α` to `β`, and any filters `l₁` on `α` and `l₂` on `β`, the function `f` tends to filter `l₂` along filter `l₁` if and only if for every set `s` in the filter `l₂`, the preimage of `s` under `f` is in the filter `l₁`. In other words, the theorem provides a characterization of the concept of limit of a function in terms of preimages of sets.

A function between two types tends to a filter if and only if the preimage of every set in the filter is in the filter through the domain.


theorem min_neg_neg : ∀ {α : Type u_1} [inst : LinearOrderedAddCommGroup α] (a b : α), min (-a) (-b) = -max a b := by
  sorry

This theorem, `min_neg_neg`, states that for all types `α` that form a linearly ordered additive commutative group, for any two elements `a` and `b` of this type, the minimum of the negations of `a` and `b` is equal to the negation of the maximum of `a` and `b`. In mathematical terms, it says that $\min(-a, -b) = -\max(a, b)$ for all $a, b$ in a given linearly ordered additive commutative group.

For all linearly ordered additive commutative groups (α, +, <) and all a, b ∈ α, we have -(min(a, b)) = max(a, b).


theorem Int.floor_eq_iff :
    ∀ {α : Type u_2} [inst : LinearOrderedRing α] [inst_1 : FloorRing α] {z : ℤ} {a : α},
      ⌊a⌋ = z ↔ ↑z ≤ a ∧ a < ↑z + 1 :=
  by sorry

This theorem, named `Int.floor_eq_iff`, states that for all types `α` that are instances of `LinearOrderedRing` and `FloorRing`, and for all integers `z` and any `a` of type `α`, the floor of `a` is equal to `z` if and only if `z` (converted into type `α`) is less than or equal to `a` and `a` is strictly less than `z + 1` (where the integer `z + 1` is converted to type `α`). In mathematical terms, this theorem defines the condition under which the floor function equals a certain integer.

For any type `α` instance of `LinearOrderedRing` and `FloorRing`, and for all integers `z` and `α` values `a`, `floor(a) = z` if and only if `z ≤ a` and `a < z + 1` (where `z` and `z + 1` are converted to type `α`).


theorem dist_eq_zero : ∀ {γ : Type w} [inst : MetricSpace γ] {x y : γ}, dist x y = 0 ↔ x = y := by sorry

This theorem states that for any type `γ` that is a metric space, the distance between two points `x` and `y` in that space is zero if and only if `x` and `y` are the same point. This is a fundamental property in metric spaces, formalizing the intuitive notion that two distinct points cannot be at zero distance from each other.

In a metric space `γ`, points `x` and `y` have zero distance if and only if `x = y`.


theorem AddMonoidHom.noncommPiCoprod_single :
    ∀ {M : Type u_1} [inst : AddMonoid M] {ι : Type u_2} [inst_1 : DecidableEq ι] [inst_2 : Fintype ι]
      {N : ι → Type u_3} [inst_3 : (i : ι) → AddMonoid (N i)] (ϕ : (i : ι) → N i →+ M)
      {hcomm : Pairwise fun i j => ∀ (x : N i) (y : N j), AddCommute ((ϕ i) x) ((ϕ j) y)} (i : ι) (y : N i),
      (AddMonoidHom.noncommPiCoprod ϕ hcomm) (Pi.single i y) = (ϕ i) y :=
  by sorry

This theorem, named `AddMonoidHom.noncommPiCoprod_single`, states that for any type `M` with an `AddMonoid` structure, type `ι` with a `DecidableEq` and `Fintype` structure, and a function `N` from `ι` to a type with an `AddMonoid` structure, given a family of additively homomorphic functions `ϕ` from `N i` to `M` for each `i : ι`, and under the condition that for every pair of different indices `i` and `j`, the additive results of `ϕ i` and `ϕ j` commute for all values `x : N i` and `y : N j`. Then, for any `i : ι` and `y : N i`, the result of applying the non-commutative version of the `Pi`-coproduct operation (`AddMonoidHom.noncommPiCoprod ϕ hcomm`) to the function supported at `i` with value `y` and `0` elsewhere (`Pi.single i y`) is equal to the result of applying `ϕ i` to `y`. In simpler words, under these conditions, this theorem says that applying the additive homomorphism at a specific index to a specific value equals using the non-commuting coproduct operation to the function that only has value at that index.

For any type `M` with an `AddMonoid` structure, type `ι` with a `DecidableEq` and `Fintype` structure, and a function `N : ι -> Types` to a type with an `AddMonoid` structure, if `ϕ : ∀ i : ι, N i -> M` is a family of additively homomorphic functions satisfying commutativity condition, then for all `i : ι` and `y : N i`, `AddMonoidHom.noncommPiCoprod ϕ hcomm (Pi.single i y) = ϕ i y`.


InitialSeg.init

theorem InitialSeg.init :
    ∀ {α : Type u_1} {β : Type u_2} {r : α → α → Prop} {s : β → β → Prop} (f : r ≼i s) {a : α} {b : β},
      s b (f a) → ∃ a', f a' = b :=
  by sorry

This theorem states that for all types `α` and `β` with relations `r` and `s` respectively, given that the relation `r` is an initial segment of `s` under a function `f`, then for any elements `a` from `α` and `b` from `β`, if `s` relates `b` to the image of `a` under `f`, there exists an element `a'` in `α` such that `f` maps `a'` to `b`. In other words, if `b` follows `f(a)` in the `s` relation, `b` is also the image of some element in `α` under `f`.

Given relations `r` on type `α` and `s` on type `β`, if `r` is an initial segment of `s` under a function `f` and `s(b) ∋ f(a)`, then there exists `a' ∈ α` such that `f(a') = b`.


theorem Int.floor_zero : ∀ {α : Type u_2} [inst : LinearOrderedRing α] [inst_1 : FloorRing α], ⌊0⌋ = 0 := by sorry

This theorem states that for any given type `α`, which is a Linear Ordered Ring and also a Floor Ring, the floor of zero is equal to zero. In other words, for any algebraic structure where subtraction and multiplication are defined and it satisfies the properties of an ordered ring along with a floor function, the greatest integer less than or equal to zero is always zero.

For any Linear Ordered Ring and Floor Ring `α`, the floor of `0` is equal to `0`.


theorem MeasureTheory.VectorMeasure.nonneg_of_zero_le_restrict :
    ∀ {α : Type u_1} {m : MeasurableSpace α} {M : Type u_3} [inst : TopologicalSpace M]
      [inst_1 : OrderedAddCommMonoid M] (v : MeasureTheory.VectorMeasure α M) {i : Set α},
      MeasureTheory.VectorMeasure.restrict 0 i ≤ MeasureTheory.VectorMeasure.restrict v i → 0 ≤ ↑v i :=
  by sorry

The theorem `MeasureTheory.VectorMeasure.nonneg_of_zero_le_restrict` states that for any measurable space `α`, a topological space `M` that is also an ordered additive commutative monoid, a vector measure `v` over `α` and `M`, and a set `i` of `α`, if the restriction of the zero vector measure to the set `i` is less than or equal to the restriction of `v` to `i`, then the measure `v` applied to `i` is nonnegative. In other words, the restriction of a vector measure can be used to infer nonnegativity of the measure on a certain set.

If the restriction of a vector measure over a measurable space to a set is less than or equal to the zero measure, then the measure of that set is nonnegative.


theorem openEmbedding_sigmaMk :
    ∀ {ι : Type u_5} {σ : ι → Type u_7} [inst : (i : ι) → TopologicalSpace (σ i)] {i : ι}, OpenEmbedding (Sigma.mk i) :=
  by sorry

This theorem states that for any type `ι`, any type function `σ` mapping `ι` to another type, and a given instance of a topological space for each `σ i`, where `i` is an element of `ι`, the function `Sigma.mk i` that takes an element of `σ i` and constructs a sigma type is an open embedding. In topology, an open embedding is a function between topological spaces that is both an embedding and an open map, meaning it injectively maps points to points and open sets to open sets.

For any type `ι`, given instances of topological spaces for each `σ i` where `i` is an element of `ι`, the function `Sigma.mk : ∀ i : ι, σ i → Σ i, σ i` is an open embedding.


theorem Denumerable.encode_ofNat :
    ∀ {α : Type u_1} [inst : Denumerable α] (n : ℕ), Encodable.encode (Denumerable.ofNat α n) = n := by sorry

This theorem, `Denumerable.encode_ofNat`, states that for any type `α` that is denumerable (i.e., can be put into a one-to-one correspondence with the natural numbers), and a given natural number `n`, when we use the function `Denumerable.ofNat` to get the `n`-th element of `α` and then encode it back to a natural number using `Encodable.encode`, we get the original natural number `n` back. In other words, encoding the `n`-th element of a denumerable type `α` yields `n` itself. This is essentially asserting the correctness of the encoding and decoding process for denumerable types.

For any denumerable type α and natural number n, `Denumerable.encode_ofNat α n = n`.


theorem Equiv.finite_iff : ∀ {α : Sort u_1} {β : Sort u_2}, α ≃ β → (Finite α ↔ Finite β) := by sorry

This theorem states that for any two types `α` and `β`, if `α` is equivalent to `β` (expressed as `α ≃ β` in Lean), then `α` is finite if and only if `β` is finite. In other words, the finiteness of `α` and `β` is equivalent if `α` and `β` are equivalent. This theorem is an important property of equivalence relations and finiteness in the context of type theory.

For any types `α` and `β`, if `α ≃ β`, then `α` is finite if and only if `β` is finite.


theorem Subgroup.mul_mem_cancel_right :
    ∀ {G : Type u_1} [inst : Group G] (H : Subgroup G) {x y : G}, x ∈ H → (y * x ∈ H ↔ y ∈ H) := by sorry

This theorem states that for any type `G` that has a group structure, given a subgroup `H` of `G` and any elements `x` and `y` of `G`, if `x` belongs to `H`, then `y * x` belongs to `H` if and only if `y` belongs to `H`. This means that multiplication with `x` from the right within the subgroup `H` has a cancellation property, i.e., the presence of `x` on the right side of the multiplication does not affect the membership of the result in the subgroup `H`.

For any group `G` and subgroup `H`, if `x` is in `H` and `y` is in `H`, then `y * x` is in `H`. (The theorem also states the converse that if `x` is in `H` and `y` is in `H` such that `y * x` is in `H`, then `y` is in `H`, but stating both parts together in a single sentence would make it more complex.)


theorem Set.subset_sInter : ∀ {α : Type u_1} {S : Set (Set α)} {t : Set α}, (∀ t' ∈ S, t ⊆ t') → t ⊆ ⋂₀ S := by sorry

This theorem states that for all types `α`, and for all sets `S` of sets of `α`, and for all sets `t` of `α`, if every set `t'` that is an element of `S` is a superset of `t` (`t` is a subset of `t'`), then `t` is also a subset of the intersection of all sets in `S`. In mathematical terms, if for all `t'` in `S`, `t ⊆ t'`, then `t` is a subset of the intersection (`⋂`) of all the sets in `S`.

If every set in a family of sets containing a given set is a superset of it, then the given set is a subset of their intersection.


theorem Ordinal.le_add_left : ∀ (a b : Ordinal.{u_3}), a ≤ b + a := by sorry

This theorem states that for any two ordinals 'a' and 'b', the ordinal 'a' is always less than or equal to the sum of 'b' and 'a'. In other words, given any two ordinals, the value of an ordinal is always less than or equal to the value of the sum of that ordinal and another ordinal. This is a property of ordinals in the mathematical field of set theory.

For any ordinals 'a' and 'b', a ≤ a + b.


theorem GaloisConnection.l_iSup₂ :
    ∀ {α : Type u} {β : Type v} {ι : Sort x} {κ : ι → Sort u_1} [inst : CompleteLattice α] [inst_1 : CompleteLattice β]
      {l : α → β} {u : β → α},
      GaloisConnection l u → ∀ {f : (i : ι) → κ i → α}, l (⨆ i, ⨆ j, f i j) = ⨆ i, ⨆ j, l (f i j) :=
  by sorry

This theorem states that given a Galois connection (defined by function pairs `l` and `u`), for every function `f` mapping from a type `ι` to another type `κ`, which then maps to a type `α` in a complete lattice, the supremum (or least upper bound, denoted by ⨆) of the function `l` applied on `f` over all `i` and `j` is equal to the function `l` applied on the supremum of `f` over all `i` and `j`. This theorem is significant as it captures the preservation property of Galois connections across complete lattices with respect to the operation of taking supremums.

Given a Galois connection `(l, u)` and a function `f` from a complete lattice `ι` to a type `α`, the supremum of `l ∘ f` over all `i` and `j` equals `l` applied to the supremum of `f` over all `i` and `j`.


theorem OrderIso.map_ciSup :
    ∀ {α : Type u_1} {β : Type u_2} {ι : Sort u_4} [inst : ConditionallyCompleteLattice α]
      [inst_1 : ConditionallyCompleteLattice β] [inst_2 : Nonempty ι] (e : α ≃o β) {f : ι → α},
      BddAbove (Set.range f) → e (⨆ i, f i) = ⨆ i, e (f i) :=
  by sorry

This theorem states that for every types `α`, `β` and `ι`, where `α` and `β` are conditionally complete lattices and `ι` is nonempty, for every order isomorphism `e` between `α` and `β`, and for every function `f` from `ι` to `α`, if the range of `f` is bounded above, then the order isomorphism `e` applied to the supremum (denoted as `⨆ i, f i`) of `f`, is equal to the supremum of the image of `f` under `e`. In other words, if `f`'s outputs have an upper bound, the order isomorphism preserves the supremum operation.

For order isomorphisms between conditionally complete lattices, if a function with a bounded range is applied, the order isomorphism preserves the supremum of the function's images.


theorem Int.mod_modEq : ∀ (a n : ℤ), a % n ≡ a [ZMOD n] := by sorry

This theorem, `Int.mod_modEq`, states that for any two integers `a` and `n`, the remainder of `a` divided by `n` is congruent to `a` modulo `n`. In mathematical notation, it means that `a % n` is equivalent to `a [ZMOD n]`. This asserts the basic property of modulo operation in the field of integer numbers.

For any integers `a` and `n`, `a % n` is equivalent to `a` modulo `n` in the sense of congruences.


theorem Finset.one_le_prod' :
    ∀ {ι : Type u_1} {N : Type u_5} [inst : OrderedCommMonoid N] {f : ι → N} {s : Finset ι},
      (∀ i ∈ s, 1 ≤ f i) → 1 ≤ Finset.prod s fun i => f i :=
  by sorry

The theorem `Finset.one_le_prod'` states that for any type ι and any ordered commutative monoid N, given a function `f` mapping elements of type ι to elements of type N and a finite set `s` of type ι, if all the elements in `s`, when applied to the function `f`, return a value greater than or equal to 1, then the product of these values (calculated as `Finset.prod s f`) is also greater than or equal to 1.

If `f : ι -> N` is a function and `s : Finset ι` is a finite set such that `∀ x ∈ s, f x ≥ 1`, then `Finset.prod s f ≥ 1`.


theorem YoungDiagram.exists_not_mem_row : ∀ (μ : YoungDiagram) (i : ℕ), ∃ j, (i, j) ∉ μ := by sorry

This theorem states that for every Young Diagram, represented by `μ`, and for any natural number `i`, there exists a natural number `j` such that the pair `(i, j)` does not belong to `μ`. In other words, it's saying that no matter what row `i` we are looking at in the Young Diagram, there is always a column `j` that is not in that row.

For every Young Diagram `μ` and natural number `i`, there exists a natural number `j` such that `(i, j)` is not in `μ`.


theorem Primrec₂.unpaired' : ∀ {f : ℕ → ℕ → ℕ}, Nat.Primrec (Nat.unpaired f) ↔ Primrec₂ f := by sorry

The theorem `Primrec₂.unpaired'` establishes a correspondence between a function being binary primitive recursive and its unpaired version being natural number primitive recursive. In other words, for any function `f` that maps two natural numbers to another natural number, `f` is a binary primitive recursive function if and only if the function obtained by applying `Nat.unpaired` to `f` is a primitive recursive function for natural numbers. Here, `Nat.unpaired f` is a function that takes a single natural number, decodes it into a pair of natural numbers using the pairing function, and applies `f` to the pair.

A binary function is primitive recursive if and only if its unpaired version, obtained by applying `Nat.unpaired` and composing with the pairing function, is a primitive recursive function for natural numbers.


theorem continuousOn_iff' :
    ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] {f : α → β} {s : Set α},
      ContinuousOn f s ↔ ∀ (t : Set β), IsOpen t → ∃ u, IsOpen u ∧ f ⁻¹' t ∩ s = u ∩ s :=
  by sorry

The theorem `continuousOn_iff'` states that for any types `α` and `β` endowed with a topological structure, a function `f` from `α` to `β`, and a subset `s` of `α`, `f` is continuous on `s` if and only if for every open set `t` in `β`, there exists an open set `u` in `α` such that the preimage of `t` under `f` intersected with `s` is equal to the intersection of `u` and `s`. This can be seen as a way of characterizing continuous functions through the behavior of their preimages on open sets.

A function between topological spaces is continuous on a subset if and only if the preimage of every open set under the function intersecting the subset equals the intersection of the subset and some open set in the domain.


StarSubalgebra.ext

theorem StarSubalgebra.ext :
    ∀ {R : Type u_2} {A : Type u_3} [inst : CommSemiring R] [inst_1 : StarRing R] [inst_2 : Semiring A]
      [inst_3 : StarRing A] [inst_4 : Algebra R A] [inst_5 : StarModule R A] {S T : StarSubalgebra R A},
      (∀ (x : A), x ∈ S ↔ x ∈ T) → S = T :=
  by sorry

This theorem states that for any given types `R` and `A` where `R` is a commutative semiring, `A` is a semiring, both `R` and `A` have a star-ring structure, and `A` is an algebra over `R` with star-module structure, then for any two star subalgebras `S` and `T` of `R` in `A`, if for any element `x` in `A`, `x` is in `S` if and only if `x` is in `T`, then `S` and `T` are equal. That is, two star subalgebras are equal if they have the same elements.

Given commutative semirings `R` and `A`, if `A` is an `R`-algebra with star-module structure and `S` and `T` are star subalgebras of `R` in `A` such that for all `x` in `A`, `x` is in `S` if and only if `x` is in `T`, then `S` equals `T`.


theorem ENorm.map_smul :
    ∀ {𝕜 : Type u_1} {V : Type u_2} [inst : NormedField 𝕜] [inst_1 : AddCommGroup V] [inst_2 : Module 𝕜 V]
      (e : ENorm 𝕜 V) (c : 𝕜) (x : V), ↑e (c • x) = ↑‖c‖₊ * ↑e x :=
  by sorry

This theorem states that for any normed field `𝕜`, additively commutative group `V`, and `𝕜`-module `V`, given an extended norm `e` on `V`, a scalar `c` from `𝕜`, and a vector `x` from `V`, the extended norm of the scalar multiplication of `c` and `x` (`c • x`) is equal to the product of the nonnegative norm (or absolute value) of `c` (`‖c‖₊`) and the extended norm of `x`. In essence, it captures the principle that scaling a vector by a factor changes its norm by the absolute value of that factor.

For any normed field `𝕜`, additively commutative group `V`, and `𝕜`-module `V` with extended norm `e`, the extended norm of scalar multiplication `e(c • x) = ‖c‖₊ * e(x)` for all `c` from `𝕜` and `x` from `V`.


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

This theorem is a property of addition in subgroups of an additive group. It states that for any type `G` that has an additive group structure, for any additive subgroup `H` of `G`, and for any elements `x` and `y` of `G`, if `x` is an element of `H`, then `y + x` is an element of `H` if and only if `y` is an element of `H`. In mathematical terms, given `x ∈ H`, the membership of `y + x` in `H` is equivalent to the membership of `y` in `H`.

For any additive subgroup `H` of an additive group `G` and any `x, y` in `G`, if `x` is in `H` then `y + x` is in `H` if and only if `y` is in `H`.


theorem AlgHom.comp_algebraMap_of_tower :
    ∀ (R : Type u) {S : Type v} {A : Type w} {B : Type u₁} [inst : CommSemiring R] [inst_1 : CommSemiring S]
      [inst_2 : Semiring A] [inst_3 : Semiring B] [inst_4 : Algebra R S] [inst_5 : Algebra S A] [inst_6 : Algebra S B]
      [inst_7 : Algebra R A] [inst_8 : Algebra R B] [inst_9 : IsScalarTower R S A] [inst_10 : IsScalarTower R S B]
      (f : A →ₐ[S] B), RingHom.comp (↑f) (algebraMap R A) = algebraMap R B :=
  by sorry

This theorem states that for any commutative semi-rings R and S and semi-rings A and B, if we have algebra structures between R and S, S and A, S and B, R and A, R and B, and if A and B form a scalar tower over R and S, then the composition of any algebra homomorphism from A to B over S with the embedding from R to A defined by the algebra structure is equal to the embedding from R to B defined by its algebra structure. Essentially, this theorem is a statement about the compatibility of the algebra structure and the concept of a scalar tower in the context of ring homomorphisms, specifically how the algebra map behaves with respect to the composition of algebra homomorphisms.

Given commutative semi-rings R, S, and algebra structures between R and S, S and A, S and B, R and A, and R and B, if A and B form a scalar tower over R and S, then the composition of the algebra homomorphism from A to B over S with the embedding from R to A is equal to the embedding from R to B.


theorem Real.abs_exp : ∀ (x : ℝ), |Real.exp x| = Real.exp x := by sorry

This theorem states that the absolute value of the exponential function, when applied to any real number `x`, is equal to the value of the exponential function at `x` itself. In mathematical terms, for any real number `x`, the equality `|exp(x)| = exp(x)` holds true. This implies that the real exponential function always returns a non-negative number.

For all real numbers x, the absolute value of the exponential function |exp(x)| equals exp(x).


theorem isChain_of_trichotomous :
    ∀ {α : Type u_1} {r : α → α → Prop} [inst : IsTrichotomous α r] (s : Set α), IsChain r s := by sorry

This theorem, named `isChain_of_trichotomous`, states that for any type `α` and a relation `r` on `α`, if the relation `r` is trichotomous, meaning for any two elements `x` and `y` in `α`, either `r x y`, `x = y`, or `r y x` holds, then any set `s` of elements from `α` is a chain with respect to the relation `r`. In other words, it states that if a relation is trichotomous, then all elements of a set are pairwise comparable under that relation, highlighting the property of a chain.

For any type `α` and trichotomous relation `r` on `α`, any set `s` of elements from `α` forms a chain with respect to `r`.


theorem pow_card_eq_one' : ∀ {G : Type u_6} [inst : Group G] {x : G}, x ^ Nat.card G = 1 := by sorry

The theorem `pow_card_eq_one'` states that for any type `G` which has a group structure (denoted by `[inst : Group G]`), for any element `x` of `G`, raising `x` to the power of the cardinality of `G` equals the identity element `1` in the group. This suggests that any group element to the power of the group's cardinality gives the identity of the group. If `G` is infinite, `Nat.card G = 0` and any element to the power of zero gives the identity in the group context.

For any group `G` and any of its elements `x`, the power `x^(card G)` equals the identity `1_G` if `G` is finite, and equals `1_G` for the identity element and `1` for any other element if `G` is infinite.


theorem Set.ite_same : ∀ {α : Type u} (t s : Set α), Set.ite t s s = s := by sorry

The theorem `Set.ite_same` states that for any type `α` and for any two sets `t` and `s` of type `α`, the operation `Set.ite` applied to `t`, `s`, and `s` (i.e., using the same set `s` for both the second and third arguments), returns `s` itself. In other words, this theorem states that if you take the intersection of a set `s` with another set `t`, and then form the union of the result with the difference of `s` and `t`, you get back the original set `s`. This is expressed mathematically as: `s ∩ t ∪ s \ t = s`.

The theorem `Set.ite_same` asserts that for any set `s` and `t`, `s ∩ t ∪ (s \ t) = s`.


theorem Polynomial.coeff_neg :
    ∀ {R : Type u} [inst : Ring R] (p : Polynomial R) (n : ℕ), Polynomial.coeff (-p) n = -Polynomial.coeff p n := by
  sorry

This theorem, `Polynomial.coeff_neg`, states that for any given type `R` that is a ring, for any polynomial `p` of type `R` and for any natural number `n`, the coefficient of `X^n` in the negation of `p` (`-p`) is equal to the negation of the coefficient of `X^n` in `p`. In other words, negating a polynomial negates each of its coefficients.

For any ring type R, polynomial p of type R, and natural number n, the coefficient of X^n in the negation of p is the negation of the coefficient of X^n in p.


theorem Finset.filter_or :
    ∀ {α : Type u_1} (p q : α → Prop) [inst : DecidablePred p] [inst_1 : DecidablePred q] [inst_2 : DecidableEq α]
      (s : Finset α), Finset.filter (fun a => p a ∨ q a) s = Finset.filter p s ∪ Finset.filter q s :=
  by sorry

This theorem, `Finset.filter_or`, states that for any type `α`, given two predicates `p` and `q` that can be decided for each element of `α`, and a finite set `s` of type `α` with decidable equality, filtering the set `s` with a predicate that is the logical disjunction (or) of `p` and `q` is equivalent to taking the union of the set filtered by predicate `p` and the set filtered by predicate `q`. More formally, if `p` and `q` are predicates on `α` and `s` is a finite set of `α`, then the set of elements in `s` for which `p` or `q` holds is equal to the union of the set of elements in `s` for which `p` holds and the set of elements in `s` for which `q` holds.

For any finite set `s` and predicates `p` and `q` on type `α` with decidable equality, `{x : α | p x or q x} = {x : α | p x} ∪ {x : α | q x}`.


theorem CategoryTheory.Monad.left_unit :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] (T : CategoryTheory.Monad C) (X : C),
      CategoryTheory.CategoryStruct.comp ((CategoryTheory.Monad.η T).app (T.obj X)) ((CategoryTheory.Monad.μ T).app X) =
        CategoryTheory.CategoryStruct.id (T.obj X) :=
  by sorry

This theorem, `CategoryTheory.Monad.left_unit`, states that for any category `C`, and for any monad `T` on `C`, and for any object `X` in `C`, the composition of the unit of the monad `T` applied to the object `T.obj X` and the multiplication of the monad `T` applied to the object `X` is equal to the identity morphism on the object `T.obj X`. This theorem is essentially expressing the left unit law for a monad in the category theory context. The left unit law is one of the three conditions in the definition of a monad, along with the right unit law and the associativity law.

For any monad T on a category C and object X in C, the unit of T at X multiplied by the multiplication of T at X equals the identity morphism on T.obj X. (Expressed in Lean as `T.unit X ∘ T.bind X = id _`)


theorem Set.image_comm :
    ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {s : Set α} {β' : Type u_6} {f : β → γ} {g : α → β} {f' : α → β'}
      {g' : β' → γ}, (∀ (a : α), f (g a) = g' (f' a)) → f '' (g '' s) = g' '' (f' '' s) :=
  by sorry

The theorem `Set.image_comm` states that for all types `α, β, γ, β'`, and for all sets `s` of type `α`, and for all functions `f` from `β` to `γ`, `g` from `α` to `β`, `f'` from `α` to `β'`, and `g'` from `β'` to `γ`, if for every element `a` of type `α`, the composition `f(g(a))` equals the composition `g'(f'(a))`, then the image of the image of `s` under `g` then `f` equals the image of the image of `s` under `f'` then `g'`. In simpler terms, this theorem says that if two composite functions give the same result when applied to every element of a set, then the sets obtained by first applying one function and then the other to the entire set are also the same.

If for all `a` in a set `α`, `f(g(a)) = g'(f'(a))` for functions `f: β → γ`, `g: α → β`, `f': α → β'`, and `g': β' → γ`, then `f''(s) := {f(x) | x ∈ s} = g''(s') := {g'(x) | x ∈ s}` for sets `s ⊆ α` and `s' ⊆ α`.


/-- Heine-Cantor: a continuous function on a compact uniform space is uniformly
continuous.  -/
theorem CompactSpace.uniformContinuous_of_continuous :
    ∀ {α : Type u_1} {β : Type u_2} [inst : UniformSpace α] [inst_1 : UniformSpace β] [inst_2 : CompactSpace α]
      {f : α → β}, Continuous f → UniformContinuous f :=
  by sorry

The Heine-Cantor theorem states that if you have a function `f` mapping from a compact uniform space `α` to any other uniform space `β`, and this function is continuous, then it is also uniformly continuous. In mathematical terms, a function is uniformly continuous on a set if, given any positive distance, there is a distance such that any two points in the set less than this distance apart are mapped to points less than the positive distance apart. In this context, a compact space is a topological space in which every open cover has a finite subcover.

If `f` is a continuous function from the compact uniform space `α` to the uniform space `β`, then `f` is uniformly continuous.


theorem nsmul_nonneg_iff :
    ∀ {M : Type u_3} [inst : AddMonoid M] [inst_1 : LinearOrder M]
      [inst_2 : CovariantClass M M (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] {x : M} {n : ℕ},
      n ≠ 0 → (0 ≤ n • x ↔ 0 ≤ x) :=
  by sorry

This theorem states that for any type `M` which is an additive monoid and has a linear order, and for any variable `x` of type `M` and natural number `n`, if `n` is not zero, then `n` times `x` is nonnegative if and only if `x` is nonnegative. This essentially means that the non-negativity of a scalar multiple in a linearly ordered monoid is equivalent to the non-negativity of the original element, provided the scalar itself is non-zero.

For any additive monoid M with a linear order, and for all x in M and natural number n, the product x * n is non-negative if and only if x is non-negative.


Set.InvOn.bijOn

/-- If functions `f'` and `f` are inverse on `s` and `t`, `f` maps `s` into `t`, and `f'` maps `t`
into `s`, then `f` is a bijection between `s` and `t`. The `mapsTo` arguments can be deduced from
`surjOn` statements using `LeftInvOn.mapsTo` and `RightInvOn.mapsTo`.  -/
theorem Set.InvOn.bijOn :
    ∀ {α : Type u_1} {β : Type u_2} {s : Set α} {t : Set β} {f : α → β} {f' : β → α},
      Set.InvOn f' f s t → Set.MapsTo f s t → Set.MapsTo f' t s → Set.BijOn f s t :=
  by sorry

This theorem states that if we have two functions, `f` and `f'`, which are inverses to each other on sets `s` and `t` respectively, and if `f` maps all elements of `s` into `t` and `f'` maps all elements of `t` into `s`, then `f` is a bijection from `s` to `t`. In other words, `f` is one-to-one (injective) and onto (surjective) between `s` and `t`. Note that the conditions that `f` maps `s` to `t` and `f'` maps `t` to `s` can be inferred from the respective surjectivity conditions using the properties of left and right inverses.

If functions `f` and `f'` are mutual inverses with `f` mapping set `s` onto `t` and `f'` mapping `t` onto `s`, then `f` is a bijection from `s` to `t`.


theorem PadicSeq.norm_equiv :
    ∀ {p : ℕ} [hp : Fact (Nat.Prime p)] {f g : PadicSeq p}, f ≈ g → PadicSeq.norm f = PadicSeq.norm g := by sorry

The theorem `PadicSeq.norm_equiv` states that for any natural number `p` that is prime, and for any two `p`-adic Cauchy sequences `f` and `g`, if `f` and `g` are equivalent (i.e., the distance between `f` and `g` tends to zero), then the `p`-adic norms of `f` and `g` are equal. In other words, the process of taking the `p`-adic norm of a Cauchy sequence is well-defined up to equivalence of sequences.

For any prime number `p`, if two `p`-adic Cauchy sequences are equivalent, then they have equal `p`-adic norms.


theorem CategoryTheory.Limits.IsLimit.fac_assoc :
    ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃}
      [inst_1 : CategoryTheory.Category.{v₃, u₃} C] {F : CategoryTheory.Functor J C} {t : CategoryTheory.Limits.Cone F}
      (self : CategoryTheory.Limits.IsLimit t) (s : CategoryTheory.Limits.Cone F) (j : J) {Z : C} (h : F.obj j ⟶ Z),
      CategoryTheory.CategoryStruct.comp (self.lift s) (CategoryTheory.CategoryStruct.comp (t.π.app j) h) =
        CategoryTheory.CategoryStruct.comp (s.π.app j) h :=
  by sorry

The theorem `CategoryTheory.Limits.IsLimit.fac_assoc` is a statement about category theory, specifically about the concept of a "limit" in a category. Given a category `J` and a functor `F` from `J` to a category `C`, and given a cone `t` over `F` and another cone `s` over `F`, if `t` is a limit cone, then for any object `j` in `J` and any morphism `h` from `F.obj j` to any object `Z` in `C`, the composition of the morphism `self.lift s` with the composition of the morphism `t.π.app j` and `h` is equal to the composition of the morphism `s.π.app j` and `h`. This theorem essentially formalizes the universal property of limits in a category in terms of morphism composition.

Given a limit cone `t` and another cone `s` over a functor `F` from a category `J` to `C`, if `t` is a limit cone, then for any object `j` in `J` and any morphism `h` from `F j` to any object `Z` in `C`, the composition of `s.π.app j` with `h` is equal to the composition of `t.π.app j` with `h` and `self.lift s h`.


theorem Set.prod_subset_preimage_snd :
    ∀ {α : Type u_1} {β : Type u_2} (s : Set α) (t : Set β), s ×ˢ t ⊆ Prod.snd ⁻¹' t := by sorry

This theorem states that for any two sets `s` and `t`, where `s` is a set of type `α` and `t` is a set of type `β`, the Cartesian product of `s` and `t` (`s ×ˢ t`) is a subset of the preimage of `t` under the function `Prod.snd`. In other words, every pair `(a, b)` in the Cartesian product, where `a` is from `s` and `b` is from `t`, maps to an element in `t` under the function `Prod.snd`, which extracts the second component of the pair.

For all sets `α` and `β`, the image of the Cartesian product `s × t` under the second projection `Prod.snd` is contained in `t`.


MeasureTheory.Memℒp.add

theorem MeasureTheory.Memℒp.add :
    ∀ {α : Type u_1} {E : Type u_2} {m : MeasurableSpace α} [inst : NormedAddCommGroup E] {p : ENNReal}
      {μ : MeasureTheory.Measure α} {f g : α → E},
      MeasureTheory.Memℒp f p μ → MeasureTheory.Memℒp g p μ → MeasureTheory.Memℒp (f + g) p μ :=
  by sorry

The theorem `MeasureTheory.Memℒp.add` states that, for any measure space `α`, any normed additive commutative group `E`, any extended nonnegative real number `p`, any measure `μ` on `α`, and any two functions `f` and `g` from `α` to `E`, if `f` and `g` both satisfy the Memℒp property with respect to `p` and `μ`, then the function `f + g` (the pointwise sum of `f` and `g`) also satisfies the Memℒp property with respect to `p` and `μ`.

In other words, the Memℒp property, which captures a certain kind of "integrability", is preserved under pointwise addition of functions.

If functions $f$ and $g$ are integrable with respect to measure $\mu$ with exponent $p$ in the measure space $\alpha$ over the normed additive commutative group $E$, then their pointwise sum $f + g$ is also integrable with respect to $\mu$ with exponent $p$ in $E$.


theorem MvPolynomial.C_1 : ∀ {R : Type u} {σ : Type u_1} [inst : CommSemiring R], MvPolynomial.C 1 = 1 := by sorry

The theorem `MvPolynomial.C_1` states that for any commutative semiring `R` and any type `σ`, the constant polynomial with value `1` in the multivariate polynomial ring over `R` in variables from `σ` is equal to `1`. In other words, when we consider the constant polynomial that takes the value `1`, it acts as the multiplicative identity in the ring of multivariate polynomials, just as `1` does in the base ring `R`.

For any commutative semiring R and type σ, the constant polynomial in the multivariate polynomial ring over R with variables from σ equals the multiplicative identity.


/-- Adding a vector in the direction to a point in the subspace produces a point in the
subspace.  -/
theorem AffineSubspace.vadd_mem_of_mem_direction :
    ∀ {k : Type u_1} {V : Type u_2} {P : Type u_3} [inst : Ring k] [inst_1 : AddCommGroup V] [inst_2 : Module k V]
      [inst_3 : AddTorsor V P] {s : AffineSubspace k P} {v : V},
      v ∈ AffineSubspace.direction s → ∀ {p : P}, p ∈ s → v +ᵥ p ∈ s :=
  by sorry

The theorem `AffineSubspace.vadd_mem_of_mem_direction` states that for any ring `k`, additive commutative group `V`, and affine torsor `P`, if we have an affine subspace `s` of `P` and a vector `v` in the direction of this subspace, then for any point `p` in `s`, the vector `v` added to the point `p` (notated as `v +ᵥ p`) is also in the subspace `s`. In other words, if we move along the direction of an affine subspace from a point within the subspace, we remain within the subspace.

For any affine subspace `s` of an affine torsor `P` over a ring `k` and any vector `v` in the direction of `s`, if `p` is a point in `s`, then `v +ᵥ p` is also in `s`.


theorem not_tendsto_nhds_of_tendsto_atTop :
    ∀ {α : Type u} {β : Type v} [inst : Preorder α] [inst_1 : NoTopOrder α] [inst_2 : TopologicalSpace α]
      [inst_3 : ClosedIciTopology α] {l : Filter β} [inst_4 : Filter.NeBot l] {f : β → α},
      Filter.Tendsto f l Filter.atTop → ∀ (a : α), ¬Filter.Tendsto f l (nhds a) :=
  by sorry

This theorem states that for any types `α` and `β`, where `α` is a preorder without a top element, endowed with a topology for which every set of the form `{b | a ≤ b}` is closed, and `β` is associated with a filter `l` that is not the bottom filter, if a function `f` from `β` to `α` tends towards infinity (i.e., for any `b` in `β`, `f(b)` is arbitrarily large), then `f` cannot tend towards any particular value `a` in `α`. In other words, if the values of `f` become arbitrarily large as its argument changes according to the filter `l`, then `f` cannot settle down to any specific value.

Given a preorder `α` without a top element, endowed with a topology where every upper set is closed, and a filter `l` on a type `β` such that `l` is not the bottom filter, any function `f : β → α` that tends towards infinity cannot converge to any specific value in `α`.


/-- `(c • ·)` is a proper map.  -/
theorem isProperMap_smul :
    ∀ {M : Type u_1} (c : M) (X : Type u_2) [inst : SMul M X] [inst_1 : TopologicalSpace X] [h : ProperConstSMul M X],
      IsProperMap fun x => c • x :=
  by sorry

The theorem `isProperMap_smul` states that for any type `M`, any element `c` of `M`, and any type `X` such that `X` has a scalar multiplication operation by `M` and `X` has a topology, if `M` scalar multiplies `X` properly (specified by `ProperConstSMul M X`), then the function `fun x => c • x` is a proper map. In other words, scalar multiplication by a constant is a proper map, given that the scalar multiplication is properly defined. The term "proper map" in topology typically refers to a continuous function between topological spaces that is precompact, that is, the preimage of a compact set is also compact.

If `M` properly scalar multiplies a topological space `X`, then the function `x => c • x` is a continuous function for any constant `c` in `M`.


theorem ContDiffWithinAt.congr_of_eventuallyEq :
    ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {E : Type uE} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {F : Type uF} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {s : Set E}
      {f f₁ : E → F} {x : E} {n : ℕ∞},
      ContDiffWithinAt 𝕜 n f s x → f₁ =ᶠ[nhdsWithin x s] f → f₁ x = f x → ContDiffWithinAt 𝕜 n f₁ s x :=
  by sorry

The theorem `ContDiffWithinAt.congr_of_eventuallyEq` states that for every normed field `𝕜`, every normed additive commutative group `E`, every normed space over `𝕜` and `E`, every normed additive commutative group `F`, every normed space over `𝕜` and `F`, every set of elements from `E` called `s`, every two functions `f` and `f₁` from `E` to `F`, every element `x` from `E`, and every natural number or infinity `n`, if the function `f` is continuously differentiable within the set `s` at the point `x` up to order `n`, and if function `f₁` eventually equals function `f` at a neighborhood within the set `s` around the point `x`, and if the value of `f₁` at `x` equals the value of `f` at `x`, then the function `f₁` is also continuously differentiable within the set `s` at the point `x` up to order `n`. This theorem is crucial when we want to determine the differentiability of a function that is equal to another function on a neighborhood.

If a function is continuously differentiable within a set to order n at a point, and another function equals it eventually in a neighborhood of that point with the same value at the point, then the second function is also continuously differentiable within the set to order n at the point.


theorem MeasureTheory.integral_non_aestronglyMeasurable :
    ∀ {α : Type u_1} {G : Type u_5} [inst : NormedAddCommGroup G] [inst_1 : NormedSpace ℝ G] {m : MeasurableSpace α}
      {μ : MeasureTheory.Measure α} {f : α → G}, ¬MeasureTheory.AEStronglyMeasurable f μ → ∫ (a : α), f a ∂μ = 0 :=
  by sorry

The theorem `MeasureTheory.integral_non_aestronglyMeasurable` states that for any type `α`, and for any `G` which is a normed add commutative group and a normed space over the real numbers, given a measurable space `m` and a measure `μ` on `α`, and a function `f` from `α` to `G`, if `f` is not almost everywhere strongly measurable with respect to measure `μ`, then the integral of `f` with respect to `μ` is zero. In other words, if a function cannot be approximated almost everywhere by a sequence of simple functions, its integral is zero.

If a function from a measurable space to a normed add commutative group, with respect to a given measure, is not almost everywhere strongly measurable, then its integral with respect to that measure is zero.


theorem Multiset.union_le : ∀ {α : Type u_1} [inst : DecidableEq α] {s t u : Multiset α}, s ≤ u → t ≤ u → s ∪ t ≤ u :=
  by sorry

This theorem states that for any type `α` with decidable equality, and any three multisets `s`, `t`, and `u` of type `α`, if `s` and `t` are both subsets of `u` (represented by `s ≤ u` and `t ≤ u`), then the union of `s` and `t` (represented by `s ∪ t`) is also a subset of `u`. In other words, this theorem asserts the property that the union of two subsets of a multiset is still a subset of the original multiset.

For any type `α` with decidable equality, if `s`, `t` are multisets of type `α` with `s ≤ u` and `t ≤ u`, then `s ∪ t ≤ u`. (The union of two subsets of a multiset is a subset of the multiset.)


theorem Nat.one_le_of_lt : ∀ {a b : ℕ}, a < b → 1 ≤ b := by sorry

This theorem states that for any two natural numbers `a` and `b`, if `a` is less than `b`, then `b` is greater than or equal to 1. In other words, if a natural number is greater than another natural number, then it is always at least 1.

For all natural numbers `a` and `b`, if `a < b`, then `b >= 1`.


theorem IsPGroup.comap_of_ker_isPGroup :
    ∀ {p : ℕ} {G : Type u_1} [inst : Group G] {H : Subgroup G},
      IsPGroup p ↥H →
        ∀ {K : Type u_2} [inst_1 : Group K] (ϕ : K →* G),
          IsPGroup p ↥(MonoidHom.ker ϕ) → IsPGroup p ↥(Subgroup.comap ϕ H) :=
  by sorry

The theorem `IsPGroup.comap_of_ker_isPGroup` states that for any natural number `p`, any group `G`, any subgroup `H` of `G`, if `H` is a p-group (i.e., every element of `H` has order a power of `p`), and for any group `K` and any monoid homomorphism `ϕ` from `K` to `G`, if the kernel of `ϕ` is also a p-group, then the preimage of `H` under `ϕ`, which is a subgroup of `K`, is also a p-group. In other words, the preimage of a p-group under a monoid homomorphism is also a p-group, provided that the kernel of the homomorphism is a p-group.

If `H` is a p-group subgroup of a group `G`, and `ϕ` is a monoid homomorphism from a group `K` to `G` with p-group kernel, then the preimage of `H` under `ϕ` is a p-group subgroup of `K`.


theorem norm_sub_norm_le : ∀ {E : Type u_6} [inst : SeminormedAddGroup E] (a b : E), ‖a‖ - ‖b‖ ≤ ‖a - b‖ := by sorry

This theorem states that for any type `E` that is a seminormed add group, for any elements `a` and `b` of `E`, the absolute value of the difference of their norms (‖a‖ - ‖b‖) is less than or equal to the norm of their difference (‖a - b‖). This is a property related to the triangle inequality in the context of normed spaces.

For any seminormed add group `E` and elements `a` and `b` in `E`, |‖a‖ - ‖b‖| ≤ ‖a - b‖.


theorem IsOpenMap.of_nhds_le :
    ∀ {X : Type u_1} {Y : Type u_2} {f : X → Y} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y],
      (∀ (x : X), nhds (f x) ≤ Filter.map f (nhds x)) → IsOpenMap f :=
  by sorry

This theorem states that for any two topological spaces `X` and `Y`, and a function `f` from `X` to `Y`, if for every element `x` in `X`, the neighborhood filter of `f(x)` is less than or equal to the filter obtained by mapping `f` over the neighborhood filter of `x`, then `f` is an open map. An open map is a function where for any open set in `X`, its image under `f` is an open set in `Y`.

If for every x in X, the neighborhood filter of f(x) is contained in the filter obtained by mapping f over the neighborhood filter of x, then f is an open map.


theorem isIntegral_algHom_iff :
    ∀ {R : Type u_1} [inst : CommRing R] {A : Type u_5} {B : Type u_6} [inst_1 : Ring A] [inst_2 : Ring B]
      [inst_3 : Algebra R A] [inst_4 : Algebra R B] (f : A →ₐ[R] B),
      Function.Injective ⇑f → ∀ {x : A}, IsIntegral R (f x) ↔ IsIntegral R x :=
  by sorry

The theorem `isIntegral_algHom_iff` has the following statement:

For all commutative rings `R`, rings `A` and `B`, and algebras `A` and `B` over `R`, suppose `f` is an algebra homomorphism from `A` to `B`. If the function `f` is injective, then for any element `x` in `A`, `x` is integral over `R` if and only if the image of `x` under `f` is integral over `R`. In other words, the property of being integral is preserved under the action of an injective algebra homomorphism.

If `f` is an injective algebra homomorphism between commutative rings `R`, algebras `A` and `B`, then for all `x` in `A`, `x` is integral over `R` if and only if the image of `x` under `f` is integral over `R`.


theorem Set.injective_iff_injOn_univ :
    ∀ {α : Type u_1} {β : Type u_2} {f : α → β}, Function.Injective f ↔ Set.InjOn f Set.univ := by sorry

The theorem `Set.injective_iff_injOn_univ` states that for all types `α` and `β` and a function `f` from `α` to `β`, the function `f` is injective (meaning that if `f x = f y`, then `x = y`) if and only if `f` is injective on the universal set of `α` (meaning that for all elements `x₁` and `x₂` in the set of all elements of `α`, if `f x₁ = f x₂`, then `x₁ = x₂`). This theorem thus provides a relationship between the general concept of function injectivity and the more specific concept of injectivity on a particular set, namely the universal set containing all elements of a type.

A function between types is injective if and only if it is injective when restricted to the universal set.


theorem Polynomial.degree_map :
    ∀ {R : Type u} {S : Type v} [inst : DivisionRing R] [inst_1 : Semiring S] [inst_2 : Nontrivial S] (p : Polynomial R)
      (f : R →+* S), Polynomial.degree (Polynomial.map f p) = Polynomial.degree p :=
  by sorry

This theorem, `Polynomial.degree_map`, states that for any division ring `R`, semiring `S` with nontrivial element, any polynomial `p` of type `R`, and any ring homomorphism `f` from `R` to `S`, the degree of the polynomial obtained by mapping `p` with `f` is equal to the degree of the original polynomial `p`. In other words, the process of mapping a polynomial across a ring homomorphism does not change its degree. This suggests that the degree of a polynomial is invariant under the homomorphism.

For any division ring R, semiring S with nontrivial element, polynomial p over R, and ring homomorphism f from R to S, the degree of the polynomial f(p) is equal to the degree of p.


theorem Finsupp.equivMapDomain_single :
    ∀ {α : Type u_1} {β : Type u_2} {M : Type u_5} [inst : Zero M] (f : α ≃ β) (a : α) (b : M),
      (Finsupp.equivMapDomain f fun₀ | a => b) = fun₀ | f a => b :=
  by sorry

The theorem `Finsupp.equivMapDomain_single` states that for any given types `α`, `β` and `M`, where `M` is equipped with a zero element, any equivalence `f` from `α` to `β`, and any elements `a` of `α` and `b` of `M`, mapping the domain of the single-valued function, that assigns `b` to `a` and zero to anything else, using `f` (i.e., applying `Finsupp.equivMapDomain f`) results in a single-valued function that assigns `b` to `f(a)` and zero to anything else. In other words, the resulting function's support is just `{f(a)}` where it assigns `b`, and zero elsewhere.

For any equivalence `f` from type `α` to type `β` and any `a ∈ α` and `b ∈ M`, the function `Finsupp.equivMapDomain f (λ (x : α), if h : x = a then b else 0)` is the single-valued function that assigns `b` to `f(a)` and zero elsewhere.


theorem Real.sinh_le_sinh : ∀ {x y : ℝ}, Real.sinh x ≤ Real.sinh y ↔ x ≤ y := by sorry

This theorem states that for any two real numbers `x` and `y`, the real hyperbolic sine of `x` is less than or equal to the real hyperbolic sine of `y` if and only if `x` is less than or equal to `y`. This establishes the order preservation property of the real hyperbolic sine function.

The real hyperbolic sine function is order-preserving: for all real numbers x and y, sinh(x) ≤ sinh(y) if and only if x ≤ y.


theorem exists_countable_separating :
    ∀ (α : Type u_1) (p : Set α → Prop) (t : Set α) [h : HasCountableSeparatingOn α p t],
      ∃ S, Set.Countable S ∧ (∀ s ∈ S, p s) ∧ ∀ x ∈ t, ∀ y ∈ t, (∀ s ∈ S, x ∈ s ↔ y ∈ s) → x = y :=
  by sorry

The theorem `exists_countable_separating` states that for any type `α` and any property `p` on sets of `α`, along with any set `t` of `α` that has a countable separating sequence based on `p`, there exists a countable set `S` such that every element in `S` satisfies `p` and for any two elements `x` and `y` in `t`, if they belong to the same sets in `S`, then `x` equals `y`. In other words, `S` is a countable collection of sets that separates elements of `t` based on their membership in these sets and each set in `S` satisfies the property `p`.

Given a type `α`, a property `p` on sets of `α`, and a countable separating sequence `t` for `p`, there exists a countable collection `S` of sets satisfying `p` such that elements in the same sets of `S` are equal.


theorem ZeroAtInftyContinuousMap.coe_neg :
    ∀ {α : Type u} {β : Type v} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] [inst_2 : AddGroup β]
      [inst_3 : TopologicalAddGroup β] (f : ZeroAtInftyContinuousMap α β), ⇑(-f) = -⇑f :=
  by sorry

This theorem states that for any zero-at-infinity continuous map `f` from a topological space `α` to a topological add group `β`, applying the negation operation to `f` and then applying the result to an element is the same as applying `f` to the element and then applying the negation operation. In other words, the negation operation commutes with the application of the zero-at-infinity continuous map.

For any zero-at-infinity continuous map `f` from a topological space `α` to a topological add group `β`, we have `- (f (x)) = f (-x)` for all `x` in `α`.


/-- A vector of length `0` is a `nil` vector.  -/
theorem Vector.eq_nil : ∀ {α : Type u} (v : Vector α 0), v = Vector.nil := by sorry

This theorem states that for any type `α`, any vector of length `0` of type `α` is the same as the `nil` vector of type `α`. In other words, there is only one vector of length `0` for any given type `α`, and that is the `nil` vector. This is because a vector of length `0` cannot contain any elements, so it must be empty, which is exactly what the `nil` vector is.

For any type `α`, the unique vector of length 0 is equal to the nil vector of type `α`.


theorem Hyperreal.coe_lt_coe : ∀ {x y : ℝ}, ↑x < ↑y ↔ x < y := by sorry

This theorem states that for every pair of real numbers `x` and `y`, the proposition that the hyperreal representation of `x` is less than the hyperreal representation of `y` is equivalent to the proposition that `x` is less than `y`. In other words, the ordering of real numbers is preserved when they are embedded into the hyperreal numbers.

The hyperreal representation of real number `x` is less than the hyperreal representation of real number `y` if and only if `x` is less than `y`.


/-- The kernel of `algebraMap` is contained in the annihilator of `M`;
it is then equal to the annihilator by `map_units'`  -/
theorem IsLocalization.eq_iff_exists :
    ∀ {R : Type u_1} [inst : CommSemiring R] (M : Submonoid R) (S : Type u_2) [inst_1 : CommSemiring S]
      [inst_2 : Algebra R S] [inst_3 : IsLocalization M S] {x y : R},
      (algebraMap R S) x = (algebraMap R S) y ↔ ∃ c, ↑c * x = ↑c * y :=
  by sorry

The theorem `IsLocalization.eq_iff_exists` states that for any commutative semiring `R`, submonoid `M` of `R`, another commutative semiring `S`, and an algebra structure from `R` to `S`, if `S` is a localization of `R` at `M`, then for any two elements `x` and `y` of `R`, the image of `x` under the algebra map to `S` is equal to the image of `y` under the same map if and only if there exists an element `c` in `M` such that `c` times `x` equals `c` times `y`.
This theorem asserts that two elements map to the same value under the algebra map if they can be made equivalent by multiplication with an element from the localizing submonoid.

For any commutative semirings R, S, a commutative algebra structure from R to S, and a submonoid M of R such that S is a localization of R at M, x and y in R map to the same image under the algebra map if and only if there exists m in M such that x = my/m.


theorem Nat.lt_add_right : ∀ {a b : ℕ} (c : ℕ), a < b → a < b + c := by sorry

This theorem states that for all natural numbers `a`, `b`, and `c`, if `a` is less than `b`, then `a` is also less than the sum of `b` and `c`. This corresponds to the property in ordinary arithmetic where adding a number on one side of an inequality does not affect the inequality, provided the added number is non-negative, which is always the case for natural numbers.

For all natural numbers `a`, `b`, and `c`, if `a` < `b` then `a` < `(b + c)`.


/-- Definition of `IsBigO` in terms of filters.  -/
theorem Asymptotics.isBigO_iff :
    ∀ {α : Type u_1} {E : Type u_3} {F : Type u_4} [inst : Norm E] [inst_1 : Norm F] {f : α → E} {g : α → F}
      {l : Filter α}, f =O[l] g ↔ ∃ c, ∀ᶠ (x : α) in l, ‖f x‖ ≤ c * ‖g x‖ :=
  by sorry

The theorem `Asymptotics.isBigO_iff` states that for any types `α`, `E`, and `F`, and for any functions `f : α → E` and `g : α → F`, given a filter `l` on `α`, the statement "function `f` is Big O of function `g` at filter `l`" is equivalent to the existence of a constant `c` such that, eventually for every `x` in filter `l`, the norm of `f(x)` is less than or equal to `c` times the norm of `g(x)`. This is a formal description of the concept of Big O notation in terms of filters and norms in the context of Asymptotic analysis.

For functions `f : α → E` and `g : α → F` over type `α`, and filter `l` on `α`, the functions `f` is Big O of `g` at `l` if and only if there exists a constant `c` such that, for all `x` in `l`, the norm of `f(x)` is less than or equal to `c` times the norm of `g(x)`.


theorem Int.ofNat_ne_zero : ∀ {n : ℕ}, ↑n ≠ 0 ↔ n ≠ 0 := by sorry

This theorem states that for any natural number `n`, the integer representation of `n` (denoted as `↑n`) is not equal to zero if and only if `n` itself is not equal to zero. In other words, a natural number and its integer equivalent share the same zero-nonzero status.

For any natural number `n`, the integer `↑n` is non-zero if and only if `n` is non-zero.


List.Perm.subperm

theorem List.Perm.subperm : ∀ {α : Type u_1} {l₁ l₂ : List α}, List.Perm l₁ l₂ → List.Subperm l₁ l₂ := by sorry

This theorem states that for any type `α` and any two lists `l₁` and `l₂` of that type, if `l₁` is a permutation of `l₂`, then `l₁` is a sub-permutation of `l₂`. In other words, if `l₁` can be rearranged to get `l₂`, then `l₁` is a sublist of some permutation of `l₂`. This is analogous to saying that `l₁` is a subset of `l₂`, but with respect to the multiplicities of the elements, and is used to represent the "less than or equal to" relation on multisets.

If `l₁` is a permutation of `l₂`, then `l₁` is a sublist of some permutation of `l₂`.


theorem mul_self_le_mul_self_iff :
    ∀ {α : Type u} [inst : LinearOrderedSemiring α] {a b : α}, 0 ≤ a → 0 ≤ b → (a ≤ b ↔ a * a ≤ b * b) := by sorry

This theorem, `mul_self_le_mul_self_iff`, states that for any type `α` that is a linearly ordered semiring and for any two elements `a` and `b` of this type, if `a` and `b` are both non-negative, then `a` is less than or equal to `b` if and only if `a` squared (or `a * a`) is less than or equal to `b` squared (or `b * b`).

For any linearly ordered semiring type `α` and elements `a, b` of type `α` that are non-negative, `a ≤ b` if and only if `a * a ≤ b * b`.


ContDiffOn.mono

theorem ContDiffOn.mono :
    ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {E : Type uE} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {F : Type uF} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {s : Set E}
      {f : E → F} {n : ℕ∞}, ContDiffOn 𝕜 n f s → ∀ {t : Set E}, t ⊆ s → ContDiffOn 𝕜 n f t :=
  by sorry

The theorem `ContDiffOn.mono` states that for any nontrivially normed field `𝕜`, normed additive commutative groups `E` and `F`, and normed spaces over `𝕜` for `E` and `F`, if a function `f` from `E` to `F` is continuously differentiable on a set `s` up to order `n`, then it is also continuously differentiable on any subset `t` of `s` up to the same order. In mathematical terms, if $f : E \to F$ is $C^n$ on a set $s \subseteq E$, then for any $t \subseteq s$, $f$ is also $C^n$ on $t$.

If a function is continuously differentiable up to order n on a set, then it is also continuously differentiable up to the same order on any subset of that set.


theorem MeasureTheory.Measure.map_congr :
    ∀ {α : Type u_1} {β : Type u_2} {m0 : MeasurableSpace α} [inst : MeasurableSpace β] {μ : MeasureTheory.Measure α}
      {f g : α → β},
      f =ᶠ[MeasureTheory.Measure.ae μ] g → MeasureTheory.Measure.map f μ = MeasureTheory.Measure.map g μ :=
  by sorry

The theorem `MeasureTheory.Measure.map_congr` states that for any two functions `f` and `g` from a type `α` to a type `β`, and a measure `μ` on the measurable space `α`, if `f` and `g` are equal almost everywhere (i.e., they are equal except possibly on a set of measure zero), then the pushforward of the measure `μ` by the function `f` is equal to the pushforward of the measure `μ` by the function `g`. Here, a pushforward of a measure by a function is a new measure that counts how much of the original measure is sent by the function to each part of its range.

If measurable functions `f` and `g` from a measurable space `(α, Σ, μ)` to another measurable space `(β, τ)` are equal almost everywhere, then the pushforwards `f ♯ μ` and `g ♯ μ` of the measure `μ` under `f` and `g`, respectively, are equal.


theorem Mathlib.Algebra.Order.Field.Basic._auxLemma.7 :
    ∀ {α : Type u_2} [inst : LinearOrderedSemifield α] {a : α}, (a / 2 < a) = (0 < a) := by sorry

This theorem, `Mathlib.Algebra.Order.Field.Basic._auxLemma.7`, states that for any type `α`, which is a linear ordered semifield, and for any element `a` of type `α`, the inequality `a / 2 < a` is equivalent to `0 < a`. In other words, it's saying that a number is greater than half of itself if and only if it is greater than zero.

For any linear ordered semifield `α`, the inequality `a / 2 < a` holds if and only if `0 < a` for any `a` in `α`.


theorem AddCircle.norm_eq : ∀ (p : ℝ) {x : ℝ}, ‖↑x‖ = |x - ↑(round (p⁻¹ * x)) * p| := by sorry

This theorem states that for any real number `p` and for any `x` in the real numbers, the norm of `x` (written as `‖↑x‖`) is equal to the absolute value of `x` subtracted by the product of `p` and the nearest integer to `p⁻¹ * x`, i.e., `round (p⁻¹ * x)`, where `round` is a function that rounds a given number to the nearest integer. This result is valid in the context of a linear ordered ring and a floor ring.

For any real number `p` and `x`, the norm of `x` equals the absolute value of `x` minus `p` times the nearest integer to `p⁻¹ * x`.


theorem Polynomial.roots_X_sub_C :
    ∀ {R : Type u} [inst : CommRing R] [inst_1 : IsDomain R] (r : R),
      Polynomial.roots (Polynomial.X - Polynomial.C r) = {r} :=
  by sorry

This theorem states that for any commutative ring `R`, which is also an integral domain, and any element `r` from `R`, the roots of the polynomial `X - r` is a multiset containing only the element `r`. In mathematical terms, if `R` is a commutative ring and `r` is an element of `R`, then the root of the polynomial `X - r` is exactly `r`. This is consistent with the well-known fact from algebra that the root of a linear polynomial `X - a` is `a`.

For any commutative ring `R` being an integral domain and any `r` in `R`, the polynomial `X - r` has exactly the root `r`.


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

The theorem `Set.Finite.isCompact_biUnion` states that, for an arbitrary type `X` with a topological space structure, a set `s` of an arbitrary type `ι`, and a function `f` from `ι` to a set of `X`, if `s` is finite and each set `f(i)` for `i` in `s` is compact, then the union of all the sets `f(i)` for `i` in `s` is also compact. In other words, the finite union of compact sets is also compact.

If `X` is a topological space, `s` is a finite set, and each `f(i)` is a compact subset of `X` for all `i` in `s`, then the union of `{f(i) | i ∈ s}` is a compact subset of `X`.


theorem ClosureOperator.le_closure_iff :
    ∀ {α : Type u_1} [inst : PartialOrder α] {c : ClosureOperator α} {x y : α}, x ≤ c y ↔ c x ≤ c y := by sorry

This theorem states that for any type `α` that has a `PartialOrder` structure, and for any `ClosureOperator` on `α`, and any elements `x` and `y` of type `α`, `x` is less than or equal to the closure of `y` if and only if the closure of `x` is less than or equal to the closure of `y`. In other words, this theorem illustrates an important property of closure operators in the context of partially ordered sets: it establishes the relationship between the order of the elements and their closures.

For any type `α` with a `PartialOrder` structure and any `ClosureOperator` on `α`, the closure of `x` is less than or equal to the closure of `y` if and only if `x` is less than or equal to `y`.


theorem ProbabilityTheory.kernel.measurable_coe :
    ∀ {α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β}
      (κ : ↥(ProbabilityTheory.kernel α β)) {s : Set β}, MeasurableSet s → Measurable fun a => ↑↑(κ a) s :=
  by sorry

This theorem states that for any given types `α` and `β`, each associated with measurable spaces `mα` and `mβ` respectively, and a kernel `κ` from `α` to `β` in the probability theory context, if `s` is a measurable set of type `β`, then the function that maps each element `a` of type `α` to the measure of the set `s` under the distribution `κ a` is measurable. This means that for any measurable set in the codomain, its preimage under this function is a measurable set in the domain.

For any measurable spaces `α` and `β`, kernel `κ` from `α` to `β` in probability theory, and measurable set `s` of type `β`, the function mapping each `α` to the measure of `s` under `κ a` is measurable.