theorem CancelDenoms.neg_subst : ∀ {α : Type u_1} [inst : Ring α] {n e t : α}, n * e = t → n * -e = -t := by sorry

This theorem states that for any ring `α`, and any three elements 'n', 'e', and 't' of this ring, if 'n' times 'e' equals 't', then 'n' times the additive inverse of 'e' (i.e., '-e') equals the additive inverse of 't' (i.e., '-t'). Essentially, it asserts that multiplication by a negative element in a ring flips the sign of the product.

For any ring `α`, if `n * e = t`, then `n * (-e) = -t`.


theorem GaloisConnection.l_csSup :
    ∀ {α : Type u_1} {β : Type u_2} [inst : ConditionallyCompleteLattice α] [inst_1 : ConditionallyCompleteLattice β]
      {l : α → β} {u : β → α},
      GaloisConnection l u → ∀ {s : Set α}, Set.Nonempty s → BddAbove s → l (sSup s) = ⨆ x, l ↑x :=
  by sorry

This theorem states that for any conditionally complete lattices `α` and `β`, and a pair of functions `l : α → β` and `u : β → α` that form a Galois connection, if we have a non-empty set `s` of `α` that is bounded above, then the value of function `l` at the supremum of set `s` is equal to the supremum of the set obtained by applying function `l` to each element of `s`. In essence, this theorem is asserting that in the context of a Galois connection, the function `l` preserves the operation of taking supremum from set `s` to the image set under function `l`.

Given any conditionally complete lattices `α` and `β`, and a Galois connection `l : α → β` and `u : β → α`, if `s` is a non-empty bounded above subset of `α`, then `l (sup s) = sup (map l s)`.


theorem aeSeq.proof_1 : ∀ {ι : Sort u_3} {α : Type u_2} {β : Type u_1} {f : ι → α → β}, ι → α → Nonempty β := by sorry

This theorem states that for any sort `ι`, any types `α` and `β`, and any function `f` mapping from `ι` and `α` to `β`, there exists a value in `β` for any given `ι` and `α`. In other words, no matter the specifics of `ι`, `α`, `β`, and `f`, it's assured that we can always find a value in `β` when provided with any `ι` and `α`.

For any sort `ι`, types `α` and `β`, and function `f`: ∀ (i : ι) (x : α), ∃ y : β, f i x.


theorem CategoryTheory.GrothendieckTopology.sheafify_isSheaf :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (J : CategoryTheory.GrothendieckTopology C) {D : Type w}
      [inst_1 : CategoryTheory.Category.{max v u, w} D] [inst_2 : CategoryTheory.ConcreteCategory D]
      [inst_3 : CategoryTheory.Limits.PreservesLimits (CategoryTheory.forget D)]
      [inst_4 :
        ∀ (P : CategoryTheory.Functor Cᵒᵖ D) (X : C) (S : CategoryTheory.GrothendieckTopology.Cover J X),
          CategoryTheory.Limits.HasMultiequalizer (CategoryTheory.GrothendieckTopology.Cover.index S P)]
      [inst_5 : ∀ (X : C), CategoryTheory.Limits.HasColimitsOfShape (CategoryTheory.GrothendieckTopology.Cover J X)ᵒᵖ D]
      [inst_6 :
        (X : C) →
          CategoryTheory.Limits.PreservesColimitsOfShape (CategoryTheory.GrothendieckTopology.Cover J X)ᵒᵖ
            (CategoryTheory.forget D)]
      [inst_7 : CategoryTheory.ReflectsIsomorphisms (CategoryTheory.forget D)] (P : CategoryTheory.Functor Cᵒᵖ D),
      CategoryTheory.Presheaf.IsSheaf J (CategoryTheory.GrothendieckTopology.sheafify J P) :=
  by sorry

The theorem `CategoryTheory.GrothendieckTopology.sheafify_isSheaf` states that for any category `C` with a Grothendieck topology `J`, and any category `D` that is a concrete category and whose forgetful functor preserves limits, if for any functor `P` from the opposite category of `C` to `D`, any object `X` in `C`, and any cover `S` of `X` with respect to `J`, the multicospan associated with the indexing of the cover by `P` has a limit (multiequalizer), and if for any object `X` in `C`, `D` has colimits of the shape of the opposite category of the poset of covers of `X` with respect to `J`, and the forgetful functor of `D` preserves these colimits, and if the forgetful functor of `D` reflects isomorphisms, then the sheafification of `P` with respect to `J` is a sheaf.

If a functor from the opposite category of a category with a Grothendieck topology to a concrete category preserves limits and colimits of certain shapes, and the forgetful functor reflects isomorphisms, then the sheafification of the functor with respect to the topology is a sheaf.


theorem List.subperm_cons :
    ∀ {α : Type u_1} (a : α) {l₁ l₂ : List α}, List.Subperm (a :: l₁) (a :: l₂) ↔ List.Subperm l₁ l₂ := by sorry

The theorem `List.subperm_cons` states that for any type `α`, any element `a` of type `α`, and any lists `l₁` and `l₂` of type `α`, the list `a :: l₁` is a sub-permutation of the list `a :: l₂` if and only if `l₁` is a sub-permutation of `l₂`. Here, a sub-permutation is defined as a sublist of a permutation of another list. This theorem implies that the sub-permutation relation between `a :: l₁` and `a :: l₂` is determined by the sub-permutation relation between `l₁` and `l₂`, irrespective of the element `a`.

For any type `α`, lists `l₁` and `l₂` of type `α`, and element `a` of type `α`, the lists `a :: l₁` and `a :: l₂` are sub-permutations of each other if and only if `l₁` is a sub-permutation of `l₂`.


theorem Set.mem_op : ∀ {α : Type u_1} {s : Set α} {a : αᵒᵖ}, a ∈ Set.op s ↔ a.unop ∈ s := by sorry

This theorem states that for any type `α`, any set `s` of type `α`, and any element `a` of the opposite type of `α`, `a` is a member of the opposite set of `s` (that is, the set obtained by taking the opposite of each member of `s`) if and only if the "unop-ed" version of `a` (that is, `a` with the operation of taking the opposite reversed) is a member of `s`. In other words, we can check set membership for an entity in an opposite set by "reversing" the entity back to its original form and checking its membership in the original set.

For any type `α`, set `s` of `α`, and its opposite element `a`, `a` is in the opposite set of `s` if and only if the opposition of `a` is in `s`.


/-- **Alias** of `Classical.axiomOfChoice`.

---

the axiom of choice  -/
theorem Classical.axiom_of_choice :
    ∀ {α : Sort u} {β : α → Sort v} {r : (x : α) → β x → Prop}, (∀ (x : α), ∃ y, r x y) → ∃ f, ∀ (x : α), r x (f x) :=
  by sorry

This theorem, `Classical.axiom_of_choice`, is an alias of the Axiom of Choice. In simple terms, it states that for any two types `α` and `β`, and a property `r` defined on these types, if for every element of type `α` there exists an element of type `β` such that the property `r` holds, then there exists a function `f` from `α` to `β` such that for every element of type `α`, the property `r` holds between `α` and `f(α)`. This is a fundamental principle in set theory and has important implications in many areas of mathematics.

For any types `α` and `β` and property `r` on `α × β`, if for every `a ∈ α`, there exists `b ∈ β` such that `r(a, b)` holds, then there exists a function `f : α → β` such that for all `a ∈ α`, `r(a, f(a))` holds.


theorem one_div_ne_zero : ∀ {G₀ : Type u_3} [inst : GroupWithZero G₀] {a : G₀}, a ≠ 0 → 1 / a ≠ 0 := by sorry

This theorem states that for any non-zero element `a` in a Group with Zero structure `G₀`, the reciprocal of `a`, i.e., `1 / a`, is not equal to zero. Here, a Group with Zero `G₀` is a mathematical structure that combines the properties of a group and the existence of a zero element, with the zero element not having a multiplicative inverse.

In a Group with Zero structure, the reciprocal of a non-zero element does not equal the zero element.


theorem LocalRing.of_isUnit_or_isUnit_one_sub_self :
    ∀ {R : Type u} [inst : CommRing R] [inst_1 : Nontrivial R], (∀ (a : R), IsUnit a ∨ IsUnit (1 - a)) → LocalRing R :=
  by sorry

This theorem states that for any type `R` which is a commutative ring with at least two distinct elements (a nontrivial ring), if every element `a` in `R` satisfies the property that either `a` is a unit (has a multiplicative inverse) or `1 - a` is a unit, then `R` is a local ring. In mathematical terms, a ring `R` is local if it has exactly one maximal ideal.

If every non-zero element in a commutative ring `R` with at least two elements is a unit or the opposite of a unit, then `R` is a local ring.


theorem MeasureTheory.LocallyIntegrable.locallyIntegrableOn :
    ∀ {X : Type u_1} {E : Type u_3} [inst : MeasurableSpace X] [inst_1 : TopologicalSpace X]
      [inst_2 : NormedAddCommGroup E] {f : X → E} {μ : MeasureTheory.Measure X},
      MeasureTheory.LocallyIntegrable f μ → ∀ (s : Set X), MeasureTheory.LocallyIntegrableOn f s μ :=
  by sorry

This theorem states that if a function `f` from a type `X` to a type `E` is locally integrable with respect to a measure `μ`, then the function `f` is also locally integrable on any subset `s` of `X` with respect to the same measure `μ`. Here, `X` is a measurable space and a topological space, and `E` is a normed additive commutative group. Local integrability of a function means that it is integrable within any neighborhood of every point in its domain.

If a function `f` from a measurable space and topological space `X` to a normed additive commutative group `E` is locally integrable with respect to measure `μ`, then `f` is locally integrable on any subset of `X` with respect to `μ`.


Nat.lt.step

theorem Nat.lt.step : ∀ {n m : ℕ}, n < m → n < Nat.succ m := by sorry

This theorem states that for all natural numbers 'n' and 'm', if 'n' is less than 'm', then 'n' is also less than the successor of 'm' (i.e., 'm' plus one). It is a fundamental property of natural numbers in order theory, asserting that if a number is less than another, it remains less than the next number in the sequence as well.

For all natural numbers n and m, if n < m then n < m+1.


theorem spectrum.singleton_add_eq :
    ∀ {R : Type u} {A : Type v} [inst : CommRing R] [inst_1 : Ring A] [inst_2 : Algebra R A] (a : A) (r : R),
      {r} + spectrum R a = spectrum R ((algebraMap R A) r + a) :=
  by sorry

This theorem states that for any commutative ring `R`, any `R`-algebra `A`, any element `a` from `A`, and any element `r` from `R`, the set obtained by adding the singleton set `{r}` to the spectrum of `a` in `R` is equal to the spectrum of the sum of `a` and the image of `r` under the algebraic embedding from `R` to `A`. In other words, shifting the spectrum by a fixed element in the base ring corresponds to adding that element's image under the algebraic embedding to the original element in the algebra.

For any commutative ring `R`, `R`-algebra `A`, element `a` in `A`, and element `r` in `R`, the spectrum of `a + r • a` in `A` equals the set obtained by adding `{r}` to the spectrum of `a` in `R`.


theorem Ordinal.lift_inj : ∀ {a b : Ordinal.{v}}, Ordinal.lift.{u, v} a = Ordinal.lift.{u, v} b ↔ a = b := by sorry

The theorem `Ordinal.lift_inj` states that for any two ordinals `a` and `b` in the universe `v`, the lift operation `Ordinal.lift` which embeds `Ordinal.v` as a proper initial segment of `Ordinal.{max v u}` for `u > v`, is injective. This means, `Ordinal.lift` applied to `a` equals `Ordinal.lift` applied to `b` if and only if `a` equals `b`. This ensures the uniqueness of the lift operation's result, implying no two different ordinals can have the same lift.

The `Ordinal.lift` function maps distinct ordinals to distinct lifted ordinals in `Ordinal.{max v u}`.


theorem Mathlib.Data.Seq.Computation._auxLemma.5 :
    ∀ {α : Type u} {β : Type v} (R : α → β → Prop) (a : α) (b : β),
      Computation.LiftRel R (Computation.pure a) (Computation.pure b) = R a b :=
  by sorry

This theorem states that for any types `α` and `β` and a relation `R` between them, and for any elements `a` of type `α` and `b` of type `β`, the `Computation.LiftRel` of the relation `R` and the computations which immediately terminate with `a` and `b` respectively, is equivalent to the relation `R` holding between `a` and `b`. In other words, it says that lifting the relation `R` through the computations that yield `a` and `b` simply boils down to checking the relation `R` on `a` and `b` directly.

For any types `α`, `β` and relation `R` between them, the computational lifting of `R` on elements `a : α` and `b : β` is equivalent to `R(a)` holding.


theorem MeasureTheory.Measure.prod_restrict :
    ∀ {α : Type u_1} {β : Type u_3} [inst : MeasurableSpace α] [inst_1 : MeasurableSpace β]
      {μ : MeasureTheory.Measure α} {ν : MeasureTheory.Measure β} [inst_2 : MeasureTheory.SFinite ν]
      [inst_3 : MeasureTheory.SFinite μ] (s : Set α) (t : Set β),
      MeasureTheory.Measure.prod (μ.restrict s) (ν.restrict t) = (MeasureTheory.Measure.prod μ ν).restrict (s ×ˢ t) :=
  by sorry

This theorem, from the field of measure theory, states that for any two types `α` and `β` which are measurable spaces and for any two sigma-finite measures `μ` and `ν` defined on these spaces, along with any sets `s` of type `α` and `t` of type `β`, the product measure of the restrictions of `μ` and `ν` to the sets `s` and `t` respectively, is equal to the restriction of the product measure of `μ` and `ν` to the cartesian product of the sets `s` and `t`. This is essentially a statement about how measures behave under restrictions and products.

For any measurable spaces `(α, Σα, μ)` and `(β, Σβ, ν)` with sigma-finite measures `μ` and `ν`, the product measure of `μ` restricted to a set `s ∈ Σα` and `ν` restricted to a set `t ∈ Σβ` equals the restriction of the product measure of `μ` and `ν` to the cartesian product `s × t`.


/-- If the distance between any two points in a set is bounded by some non-negative constant,
this constant bounds the diameter.  -/
theorem Metric.diam_le_of_forall_dist_le :
    ∀ {α : Type u} [inst : PseudoMetricSpace α] {s : Set α} {C : ℝ},
      0 ≤ C → (∀ x ∈ s, ∀ y ∈ s, dist x y ≤ C) → Metric.diam s ≤ C :=
  by sorry

This theorem states that in any pseudo-metric space, if the distance between any two points in a given set is bounded by some non-negative constant, then this constant also bounds the diameter of the set. Given a type `α` that is a pseudo-metric space, a set `s` of type `α`, and a non-negative real number `C`, if for every pair of points `x` and `y` in the set `s`, the distance between `x` and `y` is less than or equal to `C`, then the diameter of the set `s` is also less than or equal to `C`.

In a pseudo-metric space, if the distance between any two points in a set is bounded by a constant, then that constant is an upper bound for the diameter of the set.


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

The theorem `norm_add_sq` states that for any two vectors `x` and `y` in an inner product space over a field `𝕜` (which is also a normed commutative additive group and satisfies the ring-complex-like property), the square of the norm of the sum of the vectors equals the sum of the square of the norm of `x`, twice the real part of the inner product of `x` and `y`, and the square of the norm of `y`. This is essentially the Pythagorean theorem generalized to inner product spaces.

In an inner product space over a field, the norm of the sum of two vectors equals the sum of their norms squared, plus twice the real part of their inner product.


theorem HasFDerivAtFilter.tendsto_nhds :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {f : E → F}
      {f' : E →L[𝕜] F} {x : E} {L : Filter E},
      L ≤ nhds x → HasFDerivAtFilter f f' x L → Filter.Tendsto f L (nhds (f x)) :=
  by sorry

The theorem `HasFDerivAtFilter.tendsto_nhds` states that for any non-trivially normed field `𝕜`, normed additive commutative groups `E` and `F`, and normed spaces over `E` and `F`. Given a function `f : E → F`, its Frechet derivative `f' : E →L[𝕜] F` at a point `x : E` and a filter `L` on `E` that is less than or equal to the neighborhood filter at `x`, if `f` has its Frechet derivative `f'` at `x` with respect to filter `L`, then the function `f` tends to the neighborhood of `f(x)` along the filter `L`. In other words, the values of `f` get arbitrarily close to `f(x)` for all points in a set that becomes arbitrarily close to `x` (as defined by the filter `L`).

Given a non-trivially normed field `𝕜`, normed additive commutative groups `E` and `F`, a function `f : E → F`, its Frechet derivative `f' : E →L[𝕜] F` at a point `x : E`, and a filter `L` on `E` with `L ≤` neighborhood filter at `x`, if `f` has its Frechet derivative `f'` at `x` with respect to filter `L`, then `f` tends to `f(x)` along the filter `L`, i.e., for all `ε > 0`, there exists a neighborhood `N` of `x` in `E` such that `x' ∈ N ∩ L` implies `|f(x') - f(x)| < ε`.


/-- There is an irrational number `r` between any two reals `x < r < y`.  -/
theorem exists_irrational_btwn : ∀ {x y : ℝ}, x < y → ∃ r, Irrational r ∧ x < r ∧ r < y := by sorry

This theorem states that for any two real numbers `x` and `y` such that `x` is less than `y`, there exists an irrational number `r` such that `r` is greater than `x` and less than `y`. In other words, between any two distinct real numbers, there is an irrational number.

Between any two distinct real numbers, there exists an irrational number.


theorem Mathlib.Data.Set.Basic._auxLemma.80 : ∀ {α : Type u} {s t : Set α}, (s ⊂ t) = ∃ a ∉ s, insert a s ⊆ t := by
  sorry

This theorem states that for any type `α` and any two sets `s` and `t` of type `α`, the proposition that `s` is a proper subset of `t` is equivalent to the existence of an element `a` of type `α` that is not in `s` but when added to `s`, the resulting set is a subset of `t`. In mathematical terms, we say that "$s$ is a proper subset of $t$" if and only if there exists an element $a$ such that $a$ is not an element of $s$ and the set $s$ union with $\{a\}$ is a subset of $t$.

A set `s` is a proper subset of set `t` if and only if there exists an element `a` not in `s` such that `s ∪ {a} ⊆ t`.


theorem Mathlib.Data.Set.Basic._auxLemma.81 : ∀ {α : Type u} {s t u : Set α}, (s ⊆ t \ u) = (s ⊆ t ∧ Disjoint s u) := by
  sorry

This theorem states that for any type `α` and any sets `s`, `t`, and `u` of type `α`, the statement "the set `s` is a subset of the difference of sets `t` and `u`" is equivalent to the conjunction of two statements: "the set `s` is a subset of `t`" and "the set `s` is disjoint with `u`". Here, two sets are called disjoint if their intersection is the empty set.

For any type `α` and sets `s`, `t`, and `u` of type `α`, the set `s` is a subset of `t - u` if and only if `s` is a subset of `t` and `s` is disjoint with `u`.


theorem Mathlib.Data.Set.Basic._auxLemma.84 : ∀ {α : Type u} [inst : Nontrivial α] (x : α), Set.Nonempty {x}ᶜ = True :=
  by sorry

This theorem states that for any type `α` which is nontrivial (i.e., it contains at least two distinct elements), and for any element `x` of type `α`, the complement `{x}ᶜ` (set of all elements not equal to `x`) is nonempty. The theorem is always true regardless of the chosen `x` or nontrivial type `α`. In terms of mathematical language, it asserts that for every nontrivial set `α` and any element `x` in `α`, there exists at least one element in `α` that is not equal to `x`.

For any nontrivial type `α` and element `x` in `α`, the set of elements in `α` not equal to `x` is nonempty.


theorem Mathlib.Data.Set.Basic._auxLemma.28 : ∀ {α : Type u} {s t r : Set α}, (r ⊆ s ∩ t) = (r ⊆ s ∧ r ⊆ t) := by sorry

This theorem states that for any type `α`, and any sets `s`, `t`, and `r` of type `α`, the property of `r` being a subset of the intersection of `s` and `t` is equivalent to `r` being a subset of `s` and `r` being a subset of `t`. In terms of set theory, this expresses the fact that a subset of the intersection of two sets is also a subset of each of the intersecting sets.

For any type `α` and sets `s`, `t` of type `α`, `r ⊆ s ∩ t` if and only if `r ⊆ s` and `r ⊆ t`.


theorem Mathlib.Data.Set.Basic._auxLemma.29 : ∀ {α : Type u} {s t : Set α}, (s ∩ t = s) = (s ⊆ t) := by sorry

This theorem, `Mathlib.Data.Set.Basic._auxLemma.29`, states that for any type `α` and for any two sets `s` and `t` of type `α`, the statement that the intersection of `s` and `t` equals `s` is equivalent to the statement that `s` is a subset of `t`. In other words, a set `s` is a subset of another set `t` if and only if all elements of `s` are also in `t`, which is exactly when the intersection of `s` and `t` gives `s` back.

The theorem asserts that for any sets `s` and `t` of type `α`, `s ⊆ t` if and only if `s = s ∩ t`.


theorem Int.emod_eq_emod_iff_emod_sub_eq_zero : ∀ {m n k : ℤ}, m % n = k % n ↔ (m - k) % n = 0 := by sorry

This theorem states that for any three integers `m`, `n`, and `k`, `m` modulo `n` equals `k` modulo `n` if and only if the modulus of the difference of `m` and `k` with respect to `n` equals zero. In mathematical notation, this theorem says that for all integers m, n, and k, m mod n = k mod n if and only if (m - k) mod n = 0.

For integers m, n, and k, m congruent to k modulo n if and only if (m - k) is a multiple of n. (Or using the mathematical notation: m ≡ k (mod n) if and only if (m - k) is in the congruence class of 0 modulo n.)


theorem Mathlib.Data.Set.Basic._auxLemma.27 : ∀ {α : Type u} (s t : Set α), (s ∩ t ⊆ t) = True := by sorry

The theorem `Mathlib.Data.Set.Basic._auxLemma.27` states that for any type `α` and any two sets `s` and `t` of type `α`, the intersection of the sets `s` and `t` (denoted by `s ∩ t`) is always a subset of the set `t`. This is a fundamental property of set theory, expressed in the language of Lean theorem prover. In symbols, this can be written as ∀s,t ∈ ℘(α), (s ∩ t) ⊆ t.

For any types `α` and sets `s` and `t` of type `α`, the intersection `s ∩ t` is a subset of `t`. In symbols, `(s ∩ t) ⊆ t`.


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

The theorem states that for any nontrivially normed field `𝕂` and any normed ring `𝔸` that is also a normed algebra over `𝕂`, if a point `x` lies within the ball centered at 0 with radius equal to the radius of convergence of the exponential series of `𝕂` and `𝔸`, then the series formed by taking the norm of the `n`-th term of the exponential series evaluated at `x` is summable. In other words, there exists a real number to which the infinite series converges. This theorem links the concept of an exponential series in a normed algebra, the metric space notion of a ball, and the property of a series being summable.

For any nontrivially normed field `𝕂` and normed ring `𝔸` that is also a normed algebra over `𝕂`, if an element `x` lies within the ball of radius equal to the radius of convergence of the exponential series in `𝔸` around 0, then the series of the norms of the `n`-th term of the exponential series evaluated at `x` is convergent.


ExpChar.exists

theorem ExpChar.exists : ∀ (R : Type u) [inst : Ring R] [inst_1 : IsDomain R], ∃ q, ExpChar R q := by sorry

This theorem states that for any type `R` which has a ring structure and is a domain, there exists an exponential characteristic `q` of `R`. Here, `q` is a positive natural number (`ℕ+`) or zero (`0`), representing the characteristic of the exponential function in the ring `R`.

For any commutative ring `R` that is a domain, there exists a positive natural number or zero denoted as the exponential characteristic `q` of `R`, such that the exponential function `exp : R → R^R` satisfies `exp(x) = ∑ i = 0^∞ (x^i / i!) = 1 + x + x^2 / 2! + ...` with characteristic `q`.


theorem Finset.union_sdiff_self_eq_union :
    ∀ {α : Type u_1} [inst : DecidableEq α] {s t : Finset α}, s ∪ t \ s = s ∪ t := by sorry

The theorem `Finset.union_sdiff_self_eq_union` says that for any type `α` with decidable equality and any two finite sets `s` and `t` of type `α`, the union of `s` and the set difference `t \ s` is equal to the union of `s` and `t`. That is, adding all elements of `s` to the set obtained by removing all elements of `s` from `t` results in the same set as simply uniting `s` and `t`. This is expressed in the language of set theory, where `\` denotes set difference, and `∪` denotes union.

For any type `α` with decidable equality and finite sets `s` and `t` of type `α`, `(s ∪ (t \ s)) = (s ∪ t)`.


theorem codisjoint_hnot_left : ∀ {α : Type u_2} [inst : CoheytingAlgebra α] {a : α}, Codisjoint (￢a) a := by sorry

The theorem `codisjoint_hnot_left` states that for any type `α` that is a co-heyting algebra, and for any element `a` of this type, the element `a` and its negation `￢a` are codisjoint. In the context of lattice theory, two elements are codisjoint if their supremum (or join) is the top element of the lattice. In other words, no matter what element `x` we choose in `α`, if both `a` and `￢a` are less than or equal to `x`, then the top element of the lattice `⊤` must also be less than or equal to `x`.

For any co-heyting algebra type `α` and its elements `a` and `¬a`, if `a` and `¬a` are less than or equal to any element `x` in `α`, then their supremum (join) equals the top element `⊤` in `α`.


theorem Filter.eventuallyEq_set :
    ∀ {α : Type u} {s t : Set α} {l : Filter α}, s =ᶠ[l] t ↔ ∀ᶠ (x : α) in l, x ∈ s ↔ x ∈ t := by sorry

This theorem states that for any given type `α`, any two sets `s` and `t` of type `α`, and any filter `l` over `α`, the condition of `s` being eventually equal to `t` given the filter `l` (denoted by `s =ᶠ[l] t`) is equivalent to the condition that for all elements `x` of type `α` that "eventually" lie in the filter `l` (expressed by the `∀ᶠ (x : α) in l` notation), `x` belongs to set `s` if and only if `x` belongs to set `t`. Essentially, it says that two sets are eventually equal under some filter if and only if, under that filter, membership in one set implies membership in the other set (and vice versa) for all elements "eventually".

For any type `α`, sets `s` and `t` of type `α`, and filter `l` over `α`, sets `s` and `t` are eventually equal under filter `l` if and only if for all `x` in `l`, `x` is in `s` if and only if `x` is in `t`.


theorem List.Pairwise.forall_of_forall :
    ∀ {α : Type u_1} {R : α → α → Prop} {l : List α},
      Symmetric R → (∀ x ∈ l, R x x) → List.Pairwise R l → ∀ ⦃x : α⦄, x ∈ l → ∀ ⦃y : α⦄, y ∈ l → R x y :=
  by sorry

The theorem `List.Pairwise.forall_of_forall` states that for all types `α`, all binary relations `R` on `α`, and all lists `l` of type `α`, if `R` is a symmetric relation and for every element `x` in the list `l`, `x` is related to itself under `R`, and if `l` is a pairwise R-list, then for any two elements `x` and `y` in the list `l`, `x` is related to `y` under `R`.

In other words, this theorem is saying if a relation is symmetric and each element in the list is related to itself via this relation, and if every pair of distinct elements in the list are related via this relation (pairwise property), then every two elements in the list are related via this relation.

If `R` is a symmetric relation on type `α` such that for all `x` in list `l` of type `α`, `x` is related to itself under `R` and `l` is a pairwise `R`-list, then for all `x` and `y` in `l`, `x` is related to `y` under `R`.


DiffContOnCl.differentiableAt

theorem DiffContOnCl.differentiableAt :
    ∀ {𝕜 : Type u_1} {E : Type u_2} {F : Type u_3} [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedAddCommGroup F] [inst_3 : NormedSpace 𝕜 E] [inst_4 : NormedSpace 𝕜 F] {f : E → F} {s : Set E}
      {x : E}, DiffContOnCl 𝕜 f s → IsOpen s → x ∈ s → DifferentiableAt 𝕜 f x :=
  by sorry

The theorem `DiffContOnCl.differentiableAt` states the following: For any field `𝕜` with a non-trivial norm, and any normed additive commutative groups `E` and `F` over `𝕜`, given a function `f` from `E` to `F`, a set `s` of points in `E`, and a point `x` in `E`, if the function `f` is continuously differentiable on the closure of `s`, and `s` is an open set, then if `x` is an element of `s`, the function `f` is differentiable at the point `x`.

If `f:` `E` -> `F` is a continuously differentiable function on the closed set `s` ⊆ `E` (in the topology induced by the norms), and `x` ∈ `s` is an interior point, then `f` is differentiable at `x`.


theorem Cardinal.nat_lt_lift_iff : ∀ {n : ℕ} {a : Cardinal.{u}}, ↑n < Cardinal.lift.{v, u} a ↔ ↑n < a := by sorry

This theorem, `Cardinal.nat_lt_lift_iff`, states that for any natural number `n` and any cardinal number `a` of any type `u`, the embedding of `n` into the cardinal numbers is less than the universe lift of `a` to `max v u` if and only if the embedding of `n` is less than `a`. In other words, lifting a cardinal to a higher universe level does not change its comparison with a natural number.

For any natural number `n` and cardinal number `a` of type `u`, `n < a` if and only if `nat_cast n < lift_card a (max v u)` in Lean 4.


theorem Filter.unbounded_of_tendsto_atTop :
    ∀ {α : Type u_3} {β : Type u_4} [inst : Nonempty α] [inst : SemilatticeSup α] [inst_1 : Preorder β]
      [inst_2 : NoMaxOrder β] {f : α → β}, Filter.Tendsto f Filter.atTop Filter.atTop → ¬BddAbove (Set.range f) :=
  by sorry

This theorem states that for any function `f` from a type `α`, which is nonempty and has a semilattice structure with supremum, to another type `β`, which has a preorder structure and no maximum element, if `f` tends to infinity (represented by `Filter.atTop`) as its argument tends to infinity, then the range of `f` is not bounded above. In other words, if `f` grows without bound as its input grows without bound, there is no upper bound for the values of `f`.

If `f` is a function from a nonempty, supremum-preserving `α` to a preordered `β` without a maximum element, and `f` grows without bound as `α` approaches infinity, then the range of `f` has no upper bound.


/-- A set of linearly independent vectors in a module `M` over a semiring `K` is also linearly
independent over a subring `R` of `K`.
The implementation uses minimal assumptions about the relationship between `R`, `K` and `M`.
The version where `K` is an `R`-algebra is `LinearIndependent.restrict_scalars_algebras`.
  -/
theorem LinearIndependent.restrict_scalars :
    ∀ {ι : Type u'} {R : Type u_2} {K : Type u_3} {M : Type u_4} {v : ι → M} [inst : Semiring R]
      [inst_1 : AddCommMonoid M] [inst_2 : Module R M] [inst_3 : Semiring K] [inst_4 : SMulWithZero R K]
      [inst_5 : Module K M] [inst_6 : IsScalarTower R K M],
      (Function.Injective fun r => r • 1) → LinearIndependent K v → LinearIndependent R v :=
  by sorry

This theorem, `LinearIndependent.restrict_scalars`, states that if we have a set of vectors `v` that is linearly independent over a semiring `K` in a module `M`, these vectors remain linearly independent when we look at them over a subring `R` of `K`. The function that maps each element of `R` to its scalar multiplication with 1 must be injective for this to hold. This theorem operates under minimal assumptions about how `R`, `K`, and `M` interact. There is a different version of this theorem, `LinearIndependent.restrict_scalars_algebras`, for the case where `K` is an `R`-algebra.

If `v` is a linearly independent set of vectors in the module `M` over the semiring `K`, and the inclusion map from the subring `R` to `K` is an injection, then `v` is also linearly independent in `M` over `R`.


/-- Special case of the sandwich theorem; see `tendsto_of_tendsto_of_tendsto_of_le_of_le`
and `tendsto_of_tendsto_of_tendsto_of_le_of_le'` for the general case.  -/
theorem squeeze_zero :
    ∀ {α : Type u_3} {f g : α → ℝ} {t₀ : Filter α},
      (∀ (t : α), 0 ≤ f t) → (∀ (t : α), f t ≤ g t) → Filter.Tendsto g t₀ (nhds 0) → Filter.Tendsto f t₀ (nhds 0) :=
  by sorry

The `squeeze_zero` theorem is a special variant of the squeeze theorem. In the context of real-valued functions `f` and `g` and a filter `t₀` on an arbitrary type `α`, the theorem states that if `f` is always non-negative and never exceeds `g`, and if `g` converges to zero along the filter `t₀`, then `f` also converges to zero along `t₀`. In other words, if `0 ≤ f(t) ≤ g(t)` for all `t` in `α`, and `g` tends towards zero as `t` approaches `t₀`, then `f` will also tend towards zero.

If `f(t)` is a non-negative real-valued function that is pointwise bounded above by another function `g(t)` that converges to zero along a filter `t₀`, then `f(t)` converges to zero along `t₀`.


theorem Finpartition.card_eq_of_mem_parts_equitabilise :
    ∀ {α : Type u_1} [inst : DecidableEq α] {s t : Finset α} {m a b : ℕ} {P : Finpartition s}
      {h : a * m + b * (m + 1) = s.card}, t ∈ (Finpartition.equitabilise h).parts → t.card = m ∨ t.card = m + 1 :=
  by sorry

The theorem `Finpartition.card_eq_of_mem_parts_equitabilise` states that for any type `α` with decidable equality, any finsets `s` and `t` of `α`, any natural numbers `m`, `a`, `b`, and any finpartition `P` of `s` such that `a * m + b * (m + 1) = s.card`, if `t` is a member of the parts of the equitabilised finpartition `P` through `h`, then the cardinality of `t` is either `m` or `m + 1`.
In simpler terms, it says that when we balance the partition `P` of a finset `s`, any set `t` in this balanced partition has a size that's either `m` or `m+1`, where `m` is a factor of the size of `s`.

For any finset `s` with decidable equality, given a finpartition `P` of `s` with a cardinality `m` factor that balances `s`, any set `t` in the equitabilised partition `P` has cardinality either `m` or `m+1`.


/-- **Alias** of `Left.inv_le_one_iff`.

---

Uses `left` co(ntra)variant.  -/
theorem inv_le_one' :
    ∀ {α : Type u} [inst : Group α] [inst_1 : LE α]
      [inst_2 : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1] {a : α}, a⁻¹ ≤ 1 ↔ 1 ≤ a :=
  by sorry

This theorem, `inv_le_one'`, establishes an equivalence between the statement that the inverse of an element `a` from a group `α` is less than or equal to `1`, and the statement that `1` is less than or equal to `a`. This relationship is valid for any group `α` that is equipped with a less than or equal to (`LE`) relation and satisfies the covariant class property with respect to multiplication and this ordering. The theorem serves as an alias of `Left.inv_le_one_iff` and employs the left covariant property.

The theorem `inv_le_one` states that for any group `α` with a `LE` relation satisfying the covariant property, the inverse of an element `a` is less than or equal to 1 if and only if 1 is less than or equal to `a`.


CategoryTheory.Functor.hext

/-- Proving equality between functors using heterogeneous equality.  -/
theorem CategoryTheory.Functor.hext :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂}
      [inst_1 : CategoryTheory.Category.{v₂, u₂} D] {F G : CategoryTheory.Functor C D},
      (∀ (X : C), F.obj X = G.obj X) → (∀ (X Y : C) (f : X ⟶ Y), HEq (F.map f) (G.map f)) → F = G :=
  by sorry

This theorem, `CategoryTheory.Functor.hext`, establishes that two functors, F and G, from a category C to a category D are equal if and only if two conditions are met. First, for every object X in category C, the image of X under functor F is equal to the image of X under functor G. Second, for every pair of objects X and Y in category C and every morphism f from X to Y, the image of f under functor F is heterogeneously equal to the image of f under functor G. Here, heterogeneous equality (HEq) allows for equality between elements of potentially different types, necessary because category theory often deals with objects and morphisms of different types.

Two functors F and G from a category C to a category D are equal if and only if they map each object and morphism in C heterogeneously equal.


theorem Equiv.Perm.cycleFactorsFinset_eq_finset :
    ∀ {α : Type u_2} [inst : DecidableEq α] [inst_1 : Fintype α] {σ : Equiv.Perm α} {s : Finset (Equiv.Perm α)},
      Equiv.Perm.cycleFactorsFinset σ = s ↔
        (∀ f ∈ s, Equiv.Perm.IsCycle f) ∧
          ∃ (h : Set.Pairwise (↑s) Equiv.Perm.Disjoint), Finset.noncommProd s id ⋯ = σ :=
  by sorry

This theorem establishes an equivalence for any type `α` with decidable equality and finite type, and any permutation `σ` on `α`. It states that a permutation `σ` is expressible as the cycle factors of a finset `s` if and only if every element `f` in `s` is a cycle and there exists a pairwise disjoint relation amongst the elements of `s` such that the non-commutative product of `s` equals `σ`. In other words, the permutation `σ` can be factored into a set of disjoint cycles.

A permutation `σ` on a finite type `α` with decidable equality is equivalently expressible as a set of disjoint cycles if and only if every element in the set is a cycle and the non-commutative product of the cycles equals `σ`.


theorem Int.subNatNat_of_le : ∀ {m n : ℕ}, n ≤ m → Int.subNatNat m n = ↑(m - n) := by sorry

This theorem, `Int.subNatNat_of_le`, states that for any two natural numbers `m` and `n`, if `n` is less than or equal to `m`, then the result of the function `Int.subNatNat` applied to `m` and `n` is equal to the pure integer (using the coercion `↑`) of the difference between `m` and `n`. In other words, when `n` is less than or equal to `m`, subtracting `n` from `m` in the `Int.subNatNat` function behaves just like normal subtraction in natural numbers.

For all natural numbers `m` and `n`, if `n ≤ m`, then `Int.subNatNat m n = ↑(m - n)`.


theorem Int.subNatNat_of_lt : ∀ {m n : ℕ}, m < n → Int.subNatNat m n = Int.negSucc (Nat.pred (n - m)) := by sorry

This theorem, `Int.subNatNat_of_lt`, states that for every pair of natural numbers `m` and `n` where `m` is less than `n`, the subtraction of `m` from `n` in the domain of integers, as defined by the function `Int.subNatNat`, is equivalent to the negative of the successor of the predecessor of the difference of `n` and `m`. In other words, if `m` is less than `n`, subtracting `m` from `n` yields the negative of the successor of the result you get when you decrement `n - m` by 1. This is done using the natural numbers predecessor function `Nat.pred`. The theorem provides a specific case for the function `Int.subNatNat` when the first argument is smaller than the second one.

For natural numbers `m` and `n` with `m < n`, `Int.subNatNat m n` equals the negative of the successor of `(n - m - 1)`.


theorem Mathlib.Order.Bounds.Basic._auxLemma.32 :
    ∀ {α : Type u} [inst : Preorder α] [inst_1 : OrderTop α] (s : Set α), BddAbove s = True := by sorry

This theorem states that for any given type `α` which has a preorder and is an ordered top, every set `s` of type `α` is bounded above. In other words, given any set `s` in this context, there exists an upper bound for this set. This is demonstrated by the fact that `BddAbove s` is always True.

Every non-empty set in an ordered type with a greatest element is bounded above.


theorem CircleDeg1Lift.translationNumber_le_of_le_add_int :
    ∀ (f : CircleDeg1Lift) {x : ℝ} {m : ℤ}, f x ≤ x + ↑m → CircleDeg1Lift.translationNumber f ≤ ↑m := by sorry

This theorem states that for any instance 'f' of the type 'CircleDeg1Lift' and for any real number 'x' and integer 'm', if 'f x' is less than or equal to 'x' plus the real part of 'm', then the translation number of 'f' is less than or equal to the real part of 'm'. Here, the translation number of a 'CircleDeg1Lift', denoted by 'τ(f)', is defined as the limit of the sequence 'f^{2^n}(0) / 2^n' as 'n' approaches infinity.

For any 'CircleDeg1Lift' function 'f' and real numbers 'x' and 'm', if 'f(x) ≤ x + Re(m)' then 'τ(f) ≤ Re(m)'. Here, 'τ(f)' is the limit of 'f(0).2^n / 2^n' as 'n' approaches infinity.


/-- Given a Localization map `f : M →+ N` for a Submonoid `S ⊆ M`, if an
`AddCommMonoid` map `g : M →+ P` induces a map `f.lift hg : N →+ P` then for all
`z : N, v : P`, we have `f.lift hg z = v ↔ g x = g y + v`, where `x : M, y ∈ S` are such that
`z + f y = f x`. -/
theorem AddSubmonoid.LocalizationMap.lift_spec :
    ∀ {M : Type u_1} [inst : AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [inst_1 : AddCommMonoid N]
      {P : Type u_3} [inst_2 : AddCommMonoid P] (f : AddSubmonoid.LocalizationMap S N) {g : M →+ P}
      (hg : ∀ (y : ↥S), IsAddUnit (g ↑y)) (z : N) (v : P),
      (AddSubmonoid.LocalizationMap.lift f hg) z = v ↔
        g (AddSubmonoid.LocalizationMap.sec f z).1 = g ↑(AddSubmonoid.LocalizationMap.sec f z).2 + v :=
  by sorry

The theorem `AddSubmonoid.LocalizationMap.lift_spec` states that for a given localization map `f: M →+ N` for a submonoid `S ⊆ M`, if an additive commutative monoid map `g : M →+ P` induces another map `f.lift hg : N →+ P`, then for any elements `z : N` and `v : P`, the statement `f.lift hg z = v` is equivalent to `g x = g y + v`, where `x : M` and `y ∈ S` are elements fulfilling the condition `z + f y = f x`.

Here, `M`, `N`, and `P` are types representing additive commutative monoids, `f : M →+ N` is a localization map, `S` is a submonoid of `M`, and `g : M →+ P` is an additive commutative monoid map. The function `f.lift hg : N →+ P` is a map induced by `g` such that for any `y` in `S`, `g y` is an add unit. The term `AddSubmonoid.LocalizationMap.sec f z` provides a pair of elements `(x, y)` from `M × S` such that `z + f y = f x`.

Given a localization map `f : M → N` for a submonoid `S ⊆ M`, if there exists an additive commutative monoid map `g : M → P` such that `f.lift (g) (z) = v` if and only if `g(x) = g(y) + v` for some `x ∈ M` and `y ∈ S` with `z + f(y) = f(x)`, then `f.lift (g)` is the unique additive commutative monoid map from `N` to `P` making the diagram commute.


theorem div_self_mul_self' : ∀ {G₀ : Type u_3} [inst : GroupWithZero G₀] (a : G₀), a / (a * a) = a⁻¹ := by sorry

This theorem asserts that for every element `a` in a group with zero `G₀`, the result of dividing `a` by the product of `a` with itself (`a * a`) is equal to the inverse of `a`. In mathematical notation, this theorem is saying that for any `a` in the group with zero `G₀`, it follows that `a / (a * a) = a⁻¹`. It's important to note that this theorem is only valid in the context of a group with zero, which is a mathematical structure that extends the concept of a group by including a zero element.

In a group with zero, for all `a` in the group, `a / (a * a) = a⁻¹`.


theorem sq_eq_zero_iff :
    ∀ {M₀ : Type u_2} [inst : MonoidWithZero M₀] {a : M₀} [inst_1 : NoZeroDivisors M₀], a ^ 2 = 0 ↔ a = 0 := by sorry

This theorem states that for any type `M₀` that is a Monoid with zero and has no zero divisors, the square of an element `a` from `M₀` equals to zero if and only if `a` equals to zero. In other words, in a given Monoid with zero and no zero divisors, the only square that is zero is the zero itself.

In a Monoid with zero and no zero divisors, the square of any element equals zero if and only if the element is the zero.


theorem Set.mulIndicator_mulSupport :
    ∀ {α : Type u_1} {M : Type u_4} [inst : One M] {f : α → M}, Set.mulIndicator (Function.mulSupport f) f = f := by
  sorry

The theorem `Set.mulIndicator_mulSupport` states that for any type `α`, any type `M` equipped with a multiplicative identity element, and any function `f` from `α` to `M`, the function obtained by applying the `Set.mulIndicator` operation to the `Function.mulSupport` of `f` and `f` itself is equivalent to `f`. In other words, when we restrict `f` to the set of points where `f` is not equal to the multiplicative identity (the `Function.mulSupport` of `f`), and define this restricted function to return `f x` for `x` in this set and `1` otherwise (the `Set.mulIndicator` operation), we get back the original function `f`.

For any type `α` and any function `f` from `α` to a type `M` with multiplicative identity, the restricted function obtained by applying `Set.mulIndicator` to the support of `f` is equal to `f` itself.


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

The theorem `Zsqrtd.nonnegg_pos_neg` states that for any natural numbers `c`, `d`, `a`, and `b`, the condition `Zsqrtd.Nonnegg c d (↑a) (-↑b)` is equivalent to `Zsqrtd.SqLe b c a d`. In simpler terms, it says that `a √c - b √d ≥ 0` if and only if `b√c ≤ a√d`.

The theorem `Zsqrtd.nonnegg_pos_neg` in Lean 4 asserts that for natural numbers `c`, `d`, `a`, and `b`, `a√c - b√d ≥ 0` if and only if `b√c ≤ a√d`.


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

The theorem `Polynomial.map_eq_zero` states that for any type `R` that is a Division Ring, a type `S` that is a Semiring and is nontrivial, a polynomial `p` of type `R`, and a ring homomorphism `f` from `R` to `S`, the mapping of the polynomial `p` across the ring homomorphism `f` results in the zero polynomial if and only if the original polynomial `p` is the zero polynomial. In other words, a polynomial maps to the zero polynomial under a ring homomorphism if and only if it is the zero polynomial.

For any Division Ring R, Semiring S (nontrivial), polynomial p in R, and ring homomorphism f from R to S, p maps to the zero polynomial in S if and only if p is the zero polynomial in R.


/-- `lift.{max v u, u}` equals `lift.{v, u}`.  -/
theorem Cardinal.lift_umax' : Cardinal.lift.{max v u, u} = Cardinal.lift.{v, u} := by sorry

This theorem states that the lift operation on cardinals, when applied to the maximum of two universes `v` and `u` and then `u`, is the same as when it is applied to the universes `v` and `u` directly. In other words, the order of lifting doesn't matter when we are taking the maximum of the two universes.

The lift operation on cardinals commutes with taking the maximum, i.e., `card.lift v (max u v) = max (card.lift u v) (card.lift u v)`.


ProperCone.isClosed

theorem ProperCone.isClosed :
    ∀ {𝕜 : Type u_1} [inst : OrderedSemiring 𝕜] {E : Type u_2} [inst_1 : AddCommMonoid E] [inst_2 : TopologicalSpace E]
      [inst_3 : Module 𝕜 E] (K : ProperCone 𝕜 E), IsClosed ↑K :=
  by sorry

The theorem `ProperCone.isClosed` states that for any given proper cone `K` in a module `E` over an ordered semi-ring `𝕜`, with `E` being a topological space and an additive commutative monoid, the set underlying `K` is closed in the topology of `E`. In other words, for any such mathematical structure, the theorem asserts that the proper cone `K` is a closed set.

A proper cone in an ordered semi-ring module endowed with the topology of a topological space and being an additive commutative monoid is a closed set.


/-- A separable uniform space with countably generated uniformity filter is second countable:
one obtains a countable basis by taking the balls centered at points in a dense subset,
and with rational "radii" from a countable open symmetric antitone basis of `𝓤 α`. We do not
register this as an instance, as there is already an instance going in the other direction
from second countable spaces to separable spaces, and we want to avoid loops.  -/
theorem UniformSpace.secondCountable_of_separable :
    ∀ (α : Type u) [uniformSpace : UniformSpace α] [inst : Filter.IsCountablyGenerated (uniformity α)]
      [inst : TopologicalSpace.SeparableSpace α], SecondCountableTopology α :=
  by sorry

This theorem states that a separable uniform space, whose uniformity filter is countably generated, is second countable. In other words, we can obtain a countable basis for such a space by considering the balls centered at points in a dense subset, with "radii" from a countable, open, symmetric, antitone basis of the uniformity on the space. Note that this is not registered as an instance, because there is already an instance that transforms second countable spaces to separable spaces, and we want to avoid loops.

A separable uniform space with a countably generated uniformity filter is second countable.


theorem PNat.find_spec : ∀ {p : ℕ+ → Prop} [inst : DecidablePred p] (h : ∃ n, p n), p (PNat.find h) := by sorry

The theorem `PNat.find_spec` states that for every predicate `p` on positive natural numbers, given that the predicate `p` is decidable (meaning, for each positive natural number, we can decide whether `p` holds or not), if there exists at least one positive natural number for which the predicate `p` holds, then the predicate `p` also holds for the positive natural number obtained by applying the function `PNat.find` to the proof of existence. In other words, `PNat.find` delivers a positive natural number that satisfies the predicate `p`.

If `p` is a decidable predicate on positive natural numbers with at least one positive natural number satisfying `p`, then `p` holds for the number `PNat.find p`.


theorem MeasureTheory.SimpleFunc.memℒp_iff :
    ∀ {α : Type u_1} {E : Type u_4} [inst : MeasurableSpace α] [inst_1 : NormedAddCommGroup E]
      {μ : MeasureTheory.Measure α} {p : ENNReal} {f : MeasureTheory.SimpleFunc α E},
      p ≠ 0 → p ≠ ⊤ → (MeasureTheory.Memℒp (↑f) p μ ↔ ∀ (y : E), y ≠ 0 → ↑↑μ (↑f ⁻¹' {y}) < ⊤) :=
  by sorry

The theorem `MeasureTheory.SimpleFunc.memℒp_iff` states that for any measure space `α`, any normed, additive commutative group `E`, any measure `μ` on `α`, any extended nonnegative real number `p` that is neither zero nor infinity, and any simple function `f` from `α` to `E`, the function `f` belongs to the space of `p`-integrable functions (i.e., `MeasureTheory.Memℒp`) if and only if for all nonzero elements `y` of `E`, the measure of the preimage of the set `{y}` under `f` is finite (i.e., is not infinity). This theorem essentially characterizes `p`-integrable functions in terms of the measure of the preimages of singletons.

A simple function from a measure space to a normed, additive commutative group is `p`-integrable if and only if the measure of the preimage of every nonzero element is finite.


theorem specializes_rfl : ∀ {X : Type u_1} [inst : TopologicalSpace X] {x : X}, x ⤳ x := by sorry

This theorem, "specializes_rfl," states that for every type `X` equipped with a topological space structure, and for any element `x` of `X`, `x` specializes to itself. In other words, for any point in a given topological space, the specialization relation is reflexive. This relation essentially establishes that the closure of the set containing the point includes the point itself.

For every topological space (X, top), and for all x ∈ X, x belongs to the closure of {x}.


theorem EuclideanSpace.norm_eq :
    ∀ {𝕜 : Type u_8} [inst : RCLike 𝕜] {n : Type u_9} [inst_1 : Fintype n] (x : EuclideanSpace 𝕜 n),
      ‖x‖ = Real.sqrt (Finset.sum Finset.univ fun i => ‖x i‖ ^ 2) :=
  by sorry

The theorem `EuclideanSpace.norm_eq` states that for any number system `𝕜` that behaves like the real or complex numbers (as indicated by `RCLike 𝕜`), and for any finite type `n` (which effectively denotes the dimension of our Euclidean space), given any point `x` in the `n`-dimensional Euclidean space over `𝕜`, the norm of `x` (denoted by `‖x‖`) is equal to the square root of the sum of squares of the norms of its coordinates. The sum is taken over all coordinates, represented as the elements of the universal finite set denoted by `Finset.univ`. In mathematical terms, if `x` is a point in an `n`-dimensional Euclidean space, the norm of `x` is given by `‖x‖ = sqrt(∑_{i ∈ univ} ‖x_i‖^2)`, where `sqrt` denotes the square root, `∑` denotes the summation and `x_i` are the coordinates of `x`.

For any number system `𝕜` with `RCLike` structure and any point `x` in an `n`-dimensional Euclidean space over `𝕜`, the norm of `x` is equal to the square root of the sum of the squares of its coordinates' norms.


/-- Given a Localization map `f : M →+ N` for a Submonoid `S ⊆ M` and a map of
`AddCommMonoid`s `g : M →+ P` such that `g y` is invertible for all `y : S`, the homomorphism
induced from `N` to `P` maps `f x - f y` to `g x - g y` for all `x : M, y ∈ S`. -/
theorem AddSubmonoid.LocalizationMap.lift_mk' :
    ∀ {M : Type u_1} [inst : AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [inst_1 : AddCommMonoid N]
      {P : Type u_3} [inst_2 : AddCommMonoid P] (f : AddSubmonoid.LocalizationMap S N) {g : M →+ P}
      (hg : ∀ (y : ↥S), IsAddUnit (g ↑y)) (x : M) (y : ↥S),
      (AddSubmonoid.LocalizationMap.lift f hg) (AddSubmonoid.LocalizationMap.mk' f x y) =
        g x + ↑(-(IsAddUnit.liftRight (AddMonoidHom.restrict g S) hg) y) :=
  by sorry

This theorem states that given a localization map `f : M →+ N` for a submonoid `S ⊆ M`, and a homomorphism `g : M →+ P` of additively commutative monoids such that the image `g y` is invertible for every `y` in `S`, the induced homomorphism from `N` to `P` maps the difference of images `f x - f y` to the difference of images `g x - g y` for every `x` in `M` and `y` in `S`. In other words, this theorem shows that the mapping behaves well under the subtraction operation in the context of additive localization.

Given a localization map `f : M →+ N` of a submonoid `S ⊆ M` and a homomorphism `g : M →+ P` with invertible images `g(S)`, the induced homomorphism `fⁱ : N →+ P` satisfies `fⁱ(fx - fy) = gx - gy` for all `x ∈ M` and `y ∈ S`.


theorem List.of_mem_filter : ∀ {α : Type u} {p : α → Bool} {a : α} {l : List α}, a ∈ List.filter p l → p a = true := by
  sorry

The theorem `List.of_mem_filter` states that for any type `α`, any predicate function `p` from `α` to Boolean, any element `a` of type `α` and any list `l` of type `α`, if `a` is an element of the list obtained by filtering `l` with the predicate `p`, then the predicate `p` applied to `a` must be true. In other words, any element present in the filtered list must satisfy the condition laid out by the filtering function.

For any type `α`, list `l` of `α`, element `a` in the filtered list `l|p`, the predicate `p(a)` holds true.


theorem OrderIso.bddBelow_image :
    ∀ {α : Type u} {β : Type v} [inst : Preorder α] [inst_1 : Preorder β] (e : α ≃o β) {s : Set α},
      BddBelow (⇑e '' s) ↔ BddBelow s :=
  by sorry

This theorem states that for any two types 'α' and 'β' with a pre-order relation, and an order isomorphism 'e' between them, a set 's' of type 'α' is bounded below if and only if the image of 's' under 'e' is also bounded below. In other words, the property of having a lower bound is preserved under an order isomorphism.

For any pre-orders on types 'α' and 'β' with an order isomorphism between them, if a subset of 'α' has a lower bound, then its image under the isomorphism has a lower bound in 'β'.


theorem closed_nhds_basis :
    ∀ {X : Type u_1} [inst : TopologicalSpace X] [inst_1 : RegularSpace X] (x : X),
      Filter.HasBasis (nhds x) (fun s => s ∈ nhds x ∧ IsClosed s) id :=
  by sorry

This theorem states that for any type `X`, given that `X` is a topological space and is also a regular space, and for any element `x` of `X`, the neighborhood filter at `x` has a basis formed by the sets that belong to the neighborhood of `x` and are also closed. A basis for a filter is a collection of sets such that every set in the filter contains an element of the basis. In other words, this theorem guarantees that we can always find a closed neighborhood around each point in a regular topological space.

In a regular topological space, for every point, the filter of its neighborhoods has a basis composed of closed sets.


Irreducible.squarefree

theorem Irreducible.squarefree : ∀ {R : Type u_1} [inst : CommMonoid R] {x : R}, Irreducible x → Squarefree x := by
  sorry

This theorem states that for any type `R` that forms a commutative monoid, and any element `x` of `R`, if `x` is irreducible then it is squarefree. In terms of mathematics, for a given irreducible element in a commutative monoid, the only squares that divide it are the squares of units. In other words, the element is squarefree if it cannot be divided by the square of any non-unit element.

For any commutative monoid `R` and irreducible element `x` in `R`, `x` is squarefree, i.e., the only squares dividing `x` are those of units in `R`.


theorem DFinsupp.extendWith_none :
    ∀ {ι : Type u} {α : Option ι → Type v} [inst : (i : Option ι) → Zero (α i)] (f : Π₀ (i : ι), α (some i))
      (a : α none), (DFinsupp.extendWith a f) none = a :=
  by sorry

The theorem `DFinsupp.extendWith_none` states that for any type `ι`, any function `α` from `Option ι` to a type, a Direct-sum Finite-support function `f` from `ι` to `α (some i)`, and a term `a` of type `α none`, if we extend `f` with the term `a` to get a Direct-sum Finite-support function from `Option ι` to `α i` using the `DFinsupp.extendWith` function, then the value of this extended function at `none` is `a`. In other words, `DFinsupp.extendWith` correctly integrates the term `a` into the direct-sum finite-support function at the index `none`.

For any type `ι`, function `α : Option ι → Type`, Direct-sum Finite-support function `f : ι → α (some i)`, and term `a : α none`, `DFinsupp.extendWith f a` is the extension of `f` with `a` as the value at index `none`. Thus, `DFinsupp.extendWith_none f a = a`.


theorem MvPolynomial.support_monomial :
    ∀ {R : Type u} {σ : Type u_1} {a : R} {s : σ →₀ ℕ} [inst : CommSemiring R] [h : Decidable (a = 0)],
      MvPolynomial.support ((MvPolynomial.monomial s) a) = if a = 0 then ∅ else {s} :=
  by sorry

This theorem states that for any type `R`, any type `σ`, any element `a` of type `R`, and any function `s` from `σ` to natural numbers `ℕ` in a commutative semiring `R`, if we can decide whether `a` is zero or not, then the support of the multivariate polynomial monomial `a` with exponents given by `s` is either an empty set if `a` is zero, or a set containing just `s` if `a` isn't zero. The support of a multivariate polynomial is the finite set of all `m : σ →₀ ℕ` such that `X^m` has a non-zero coefficient.

For any commutative semiring R, type σ, element a of R, and function s from σ to natural numbers, if a is zero then the support of the multivariate polynomial monomial a with exponents given by s is empty, otherwise it is a singleton set containing s.


theorem AlgebraicGeometry.Scheme.Pullback.p1.proof_3 :
    ∀ {X Y Z : AlgebraicGeometry.Scheme} (𝒰 : AlgebraicGeometry.Scheme.OpenCover X) (f : X ⟶ Z) (g : Y ⟶ Z)
      [inst : ∀ (i : 𝒰.J), CategoryTheory.Limits.HasPullback (CategoryTheory.CategoryStruct.comp (𝒰.map i) f) g]
      (a : (CategoryTheory.GlueData.diagram (AlgebraicGeometry.Scheme.Pullback.gluing 𝒰 f g).toGlueData).L),
      CategoryTheory.CategoryStruct.comp
          ((CategoryTheory.GlueData.diagram (AlgebraicGeometry.Scheme.Pullback.gluing 𝒰 f g).toGlueData).fst a)
          (CategoryTheory.CategoryStruct.comp CategoryTheory.Limits.pullback.fst
            (𝒰.map
              ((CategoryTheory.GlueData.diagram (AlgebraicGeometry.Scheme.Pullback.gluing 𝒰 f g).toGlueData).fstFrom
                a))) =
        CategoryTheory.CategoryStruct.comp
          ((CategoryTheory.GlueData.diagram (AlgebraicGeometry.Scheme.Pullback.gluing 𝒰 f g).toGlueData).snd a)
          (CategoryTheory.CategoryStruct.comp CategoryTheory.Limits.pullback.fst
            (𝒰.map
              ((CategoryTheory.GlueData.diagram (AlgebraicGeometry.Scheme.Pullback.gluing 𝒰 f g).toGlueData).sndFrom
                a))) :=
  by sorry

The theorem `AlgebraicGeometry.Scheme.Pullback.p1.proof_3` states the following: Given three schemes X, Y, and Z, an open cover 𝒰 of the scheme X, morphisms f: X → Z and g: Y → Z, and for all i in the indexing set of 𝒰, there is a chosen pullback of the composition of the 𝒰's i-th map and f with g, and an element a from the set of left objects in the diagram associated with the glue data of the pullback glueing of 𝒰, f, and g. Then, the composition of the first morphism associated with a and the composition of the first projection of the pullback and the 𝒰 map corresponding to the first object from a is the same as the composition of the second morphism associated with a and the composition of the first projection of the pullback and the 𝒰 map corresponding to the second object from a. In layman's terms, this theorem is about the commutativity of a certain diagram involving pullbacks and the glueing process in the context of algebraic geometry.

Given morphisms between schemes and an open cover, the compositions of certain morphisms in the commutative diagram of pullbacks are equal.


theorem Mathlib.LinearAlgebra.Pi._auxLemma.1 :
    ∀ {α : Sort u_1} {β : α → Sort u_4} {f₁ f₂ : (x : α) → β x}, (f₁ = f₂) = ∀ (a : α), f₁ a = f₂ a := by sorry

This theorem, named `_auxLemma.1` in the `LinearAlgebra.Pi` namespace of Mathlib, states that for any two functions `f₁` and `f₂` of arbitrary types `β x` over a domain `α`, the equality of these two functions is equivalent to the equality of their values at every point `a` in the domain `α`. In mathematical terms, for all functions `f₁` and `f₂` from `α` to `β x`, `f₁` is equal to `f₂` if and only if `f₁(a) = f₂(a)` for every `a` in `α`.

For functions `f₁` and `f₂` from a domain `α` to a type `β x`, `f₁` equals `f₂` if and only if for all `a` in `α`, `f₁(a)` equals `f₂(a)`.


theorem Mathlib.Algebra.Pointwise.Stabilizer._auxAddLemma.10 :
    ∀ {G : Type u_1} {α : Type u_3} [inst : AddGroup G] [inst_1 : AddAction G α] {a : G} {s : Set α},
      (a ∈ AddAction.stabilizer G s) = ∀ (b : α), a +ᵥ b ∈ s ↔ b ∈ s :=
  by sorry

The given theorem, referred to as `Mathlib.Algebra.Pointwise.Stabilizer._auxAddLemma.10`, states that for any additive group `G` and any type `α` which has an additive action by `G`, and given an element `a` of `G` and a set `s` of elements of type `α`, `a` is in the stabilizer of `s` if and only if for every element `b` of type `α`, the result of the additive action of `a` on `b` (`a +ᵥ b`) is in `s` if and only if `b` is in `s`.  In other words, `a` stabilizes `s` under the additive action `+ᵥ` if applying `a` to any element `b` of `s` results in another element of `s`, and conversely, if `b` is in `s`, then `a +ᵥ b` is also in `s`.

An element `a` in an additive group `G` stabilizes a set `s` of elements in a type `α` under the additive action `+ᵥ` if and only if for all `b` in `s`, `a +ᵥ b` is also in `s`.


/-- The complex sine function is everywhere strictly differentiable, with the derivative `cos x`.  -/
theorem Complex.hasStrictDerivAt_sin : ∀ (x : ℂ), HasStrictDerivAt Complex.sin (Complex.cos x) x := by sorry

The theorem `Complex.hasStrictDerivAt_sin` states that the complex sine function is strictly differentiable at every point in the complex plane. Furthermore, the derivative of the complex sine function at any point `x` is given by the complex cosine function evaluated at `x`. In mathematical terms, this is written as `f'(x) = cos(x)` for the complex sine function `f(x)`.

The complex sine function is complex differentiable with derivative equal to the complex cosine function at every point in the complex plane.


theorem Nat.div_lt_of_lt_mul : ∀ {m n k : ℕ}, m < n * k → m / n < k := by sorry

This theorem states that for any three natural numbers `m`, `n`, and `k`, if `m` is less than the product of `n` and `k`, then the integer division of `m` by `n` is less than `k`. In other words, this theorem establishes a relationship between multiplication and division in the context of less-than comparisons in natural numbers.

If `m` < `n` * `k` in the natural numbers, then `m / n` < `k`.


theorem uniformContinuous_dist : ∀ {α : Type u} [inst : PseudoMetricSpace α], UniformContinuous fun p => dist p.1 p.2 :=
  by sorry

The theorem `uniformContinuous_dist` states that for any pseudo-metric space `α`, the distance function, which takes a pair of points in `α` and returns the distance between them, is uniformly continuous. In other words, given any two points `(x, y)` in `α`, as `(x, y)` gets arbitrarily close to some other pair `(a, b)`, the distances `dist(x, y)` and `dist(a, b)` also get arbitrarily close. This holds true regardless of the particular location of `(x, y)` and `(a, b)` in the metric space `α`.

The distance function in a pseudo-metric space is uniformly continuous.


theorem Subalgebra.range_subset :
    ∀ {R : Type u} {A : Type v} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A]
      (S : Subalgebra R A), Set.range ⇑(algebraMap R A) ⊆ ↑S :=
  by sorry

The theorem `Subalgebra.range_subset` states that for any commutative semiring `R`, any semiring `A` and any algebra structure over `R` and `A`, and for any subalgebra `S` of `A` over `R`, the range of the algebra map from `R` to `A` is a subset of `S`. The algebra map refers to the embedding given by the algebra structure. This theorem is essentially stating that all the elements in `R` that are mapped to `A` via the algebra structure are included in the given subalgebra `S` of `A`.

For any commutative semiring R, semiring A, algebra structure over R and A, and subalgebra S of A, the image of R under the algebra map is contained in S.


/-- The **deduction theorem** in the Heyting algebra model of intuitionistic logic:
an implication holds iff the conclusion follows from the hypothesis.  -/
theorem himp_eq_top_iff : ∀ {α : Type u_2} [inst : GeneralizedHeytingAlgebra α] {a b : α}, a ⇨ b = ⊤ ↔ a ≤ b := by sorry

This is the **deduction theorem** in the framework of a Generalized Heyting Algebra model for intuitionistic logic. For any two elements `a` and `b` in any type `α` that forms a Generalized Heyting Algebra, the implication from `a` to `b` holds if and only if `a` is less than or equal to `b`. Here the implication is represented as `a ⇨ b`, and `⊤` represents the top element or the truth value in the algebraic structure; the statement `a ⇨ b = ⊤` is asserting that the implication from `a` to `b` is true.

In a Generalized Heyting Algebra, an implication from element `a` to `b` holds if and only if `a` is below `b` in the lattice structure.


theorem exists_mem_nhds_isClosed_subset :
    ∀ {X : Type u_1} [inst : TopologicalSpace X] [inst_1 : RegularSpace X] {x : X} {s : Set X},
      s ∈ nhds x → ∃ t ∈ nhds x, IsClosed t ∧ t ⊆ s :=
  by sorry

This theorem states that for any topological space `X` that also has the property of being a regular space, for any element `x` from `X` and for any set `s` of elements from `X` that is a neighborhood of `x`, there exists a subset `t` that is also a neighborhood of `x`, is a closed set in the topological sense, and is a subset of `s`. The theorem is expressing a property related to the interaction of open and closed sets in a regular space, a type of topological space with certain separation properties.

In a regular topological space, for every point `x` and neighboring open set `s`, there exists a closed neighborhood `t` of `x` contained in `s`.


theorem Finsupp.erase_of_not_mem_support :
    ∀ {α : Type u_1} {M : Type u_5} [inst : Zero M] {f : α →₀ M} {a : α}, a ∉ f.support → Finsupp.erase a f = f := by
  sorry

The theorem `Finsupp.erase_of_not_mem_support` states that for any type `α` and any type `M` with a zero element (indicated by `Zero M`), if you have a finitely supported function `f : α →₀ M` and an element `a : α` that is not in the support of `f` (i.e., `f(a) = 0`), then erasing `a` from `f` using the `Finsupp.erase` function does not change `f`. In other words, if `a` does not contribute to the finitely supported function `f`, then removing `a` leaves `f` unchanged.

For any type `α` and type `M` with a zero element, if `f : α →₀ M` is a finitely supported function and `a : α` is not in the support of `f`, then `Finsupp.erase a f = f`.


Option.exists

theorem Option.exists : ∀ {α : Type u_1} {p : Option α → Prop}, (∃ x, p x) ↔ p none ∨ ∃ x, p (some x) := by sorry

This theorem, `Option.exists`, is a statement about options in Lean 4. It states that for all types `α` and all propositions `p` of type `Option α → Prop`, there exists an `x` such that `p x` holds if and only if either `p none` holds or there exists an `x` such that `p (some x)` holds. Essentially, it expresses that an existential quantifier over an option type can be decomposed into the disjunction of the proposition applied to `none` and the existence of an element of the underlying type that satisfies the proposition when wrapped with `some`.

For any type `α` and proposition `p` over `Option α`, `Option.exists x, p x ↔ p none ∨ ∃x, p (some x)` holds. (In other words, an option `x` satisfies proposition `p` if and only if `p` holds for the `none` option or there exists an element `x` in the underlying type making `p (some x)` true.)


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

This theorem states that for any type α which forms a linear ordered semifield, given three positive elements a, b, and c, the division of a by b is less than or equal to the division of a by c if and only if c is less than or equal to b. So it essentially encapsulates a property of division in the context of linear ordered semifields.

In a linear ordered semifield, for positive elements a, b, and c, a/b <= a/c if and only if b >= c.


theorem transitive_of_trans : ∀ {α : Type u} (r : α → α → Prop) [inst : IsTrans α r], Transitive r := by sorry

This theorem states that for any type `α` and for any relation `r` on `α`, if `r` is a transitive relation (i.e., `r` fulfills the condition that for any three elements `x`, `y`, and `z` of `α`, if `x` is related to `y` by `r` and `y` is related to `z` by `r`, then `x` is also related to `z` by `r`), then `r` satisfies the property of being `Transitive`. In other words, if `r` is transitive, then `r` fulfills the property that for all `x`, `y`, and `z`, if `r x y` and `r y z`, then `r x z`.

If `r` is a transitive relation on type `α`, then for all `x`, `y`, and `z` in `α`, `x` related to `y` by `r` and `y` related to `z` by `r` implies `x` related to `z` by `r`.


theorem Submonoid.coe_one : ∀ {M : Type u_1} [inst : MulOneClass M] (S : Submonoid M), ↑1 = 1 := by sorry

This theorem, `Submonoid.coe_one`, states that for any given type `M` that is an instance of the `MulOneClass` (i.e., a type with multiplication and a multiplicative identity element), and for any submonoid `S` of `M`, the multiplicative identity element of the submonoid, when lifted (or coerced) to the type `M`, remains the multiplicative identity. In other words, coercing the identity element `1` of the submonoid `S` to the type `M` gives back the identity element `1` of `M`.

For any submonoid `S` of a type `M` with multiplicative identity `1` as an instance of `MulOneClass`, the lifted (or coerced) identity element `1` of `S` is equal to the identity element `1` of `M`.


theorem Polynomial.natTrailingDegree_C :
    ∀ {R : Type u} [inst : Semiring R] (a : R), Polynomial.natTrailingDegree (Polynomial.C a) = 0 := by sorry

The theorem `Polynomial.natTrailingDegree_C` states that for any type `R` that forms a semiring (a structure with two binary operations that generalizes the arithmetic operations of addition and multiplication), and any element `a` of this type `R`, the natural trailing degree of the constant polynomial `a` is zero. In other words, when a constant is treated as a polynomial (with coefficients in `R`), its trailing degree (the lowest power of the indeterminate with a non-zero coefficient) is zero.

For any semiring `R` and its element `a`, the constant polynomial `a` has trailing degree zero as a polynomial in `R`.


theorem Matrix.rank_mul_le_left :
    ∀ {m : Type u_2} {n : Type u_3} {o : Type u_4} {R : Type u_5} [inst : Fintype n] [inst_1 : Fintype o]
      [inst_2 : CommRing R] [inst_3 : StrongRankCondition R] (A : Matrix m n R) (B : Matrix n o R),
      Matrix.rank (A * B) ≤ Matrix.rank A :=
  by sorry

The theorem `Matrix.rank_mul_le_left` states that for any commutative ring `R` with a strong rank condition and any two matrices `A` and `B` with entries in `R`, where `A` has type `Matrix m n R` and `B` has type `Matrix n o R` (`m`, `n`, and `o` are types that index the rows and columns of the matrices, and `Fintype n` and `Fintype o` indicate that `n` and `o` are finite), the rank of the product `A * B` is less than or equal to the rank of `A`. In other words, the rank of the product of two matrices can never exceed the rank of the first matrix.

The rank of the product of two matrices over a commutative ring with a strong rank condition is less than or equal to the rank of the first matrix.


theorem Finset.truncatedInf_of_not_mem :
    ∀ {α : Type u_1} [inst : SemilatticeInf α] [inst_1 : BoundedOrder α] [inst_2 : DecidableRel fun x x_1 => x ≤ x_1]
      {s : Finset α} {a : α}, a ∉ upperClosure ↑s → Finset.truncatedInf s a = ⊥ :=
  by sorry

The theorem `Finset.truncatedInf_of_not_mem` states that for any given type `α` with a semi-lattice structure and a bounded order, along with a decidable relation for less than or equal to, for any finite set `s` of type `α` and any element `a` of type `α`, if `a` is not in the upper closure of `s`, then the truncated infimum of `s` and `a` is the bottom element of the bounded order. In other words, if `a` is not an upper bound of any element in `s`, the greatest element of `s` that is less than or equal to `a` does not exist, so we return the smallest possible value.

If `α` is a type with a semi-lattice structure and a decidable order relation, and `s` is a finite set of `α`, then `∀a ∈ α, a ∉ ⨆s �Rightarrow ⨋s ⊥`. Here, `⨆s` is the upper closure of `s`, `⨋s` is the infimum of `s`, and `⊥` is the bottom element of the bounded order on `α`.


theorem Polynomial.nthRoots_zero :
    ∀ {R : Type u} [inst : CommRing R] [inst_1 : IsDomain R] (r : R), Polynomial.nthRoots 0 r = 0 := by sorry

The theorem `Polynomial.nthRoots_zero` states that for any ring `R` which is a commutative ring and an integral domain, and for any element `r` of `R`, the set of zeroth roots of `r` is zero. In other words, there are no solutions to the equation `x^0 = r` in the ring `R`.

In a commutative ring and integral domain, there are no zeroth roots other than the additive identity for any element.


theorem MeasureTheory.memℒp_congr_ae :
    ∀ {α : Type u_1} {E : Type u_2} {m0 : MeasurableSpace α} {p : ENNReal} {μ : MeasureTheory.Measure α}
      [inst : NormedAddCommGroup E] {f g : α → E},
      f =ᶠ[MeasureTheory.Measure.ae μ] g → (MeasureTheory.Memℒp f p μ ↔ MeasureTheory.Memℒp g p μ) :=
  by sorry

This theorem is stating that for any types `α` and `E`, with `α` being a measurable space and `E` being a normed add commutative group, for any extended nonnegative real number `p`, for any measure `μ` on `α`, and for any two functions `f` and `g` from `α` to `E`, if `f` and `g` are equal "almost everywhere" (that is, they are equal except on a set of measure zero), then `f` satisfies the `Memℒp` property (which means that `f` is almost everywhere strongly measurable and its p-th power norm integrated with respect to μ is finite) if and only if `g` also satisfies the `Memℒp` property. This theorem basically confirms that the `Memℒp` property is preserved under changes on sets of measure zero.

For measurable spaces `α` and normed add commutative groups `E`, if functions `f` and `g` from `α` to `E` are almost everywhere equal and satisfy the `Memℒp` property for some extended nonnegative real number `p`, then they have interchangeable `Memℒp` status.


/-- `index_exists` asserts there is some `i` with `j < c.size_up_to (i+1)`.
In the next definition `index` we use `nat.find` to produce the minimal such index.
 -/
theorem Composition.index_exists :
    ∀ {n : ℕ} (c : Composition n) {j : ℕ},
      j < n → ∃ i, j < Composition.sizeUpTo c (Nat.succ i) ∧ i < Composition.length c :=
  by sorry

The theorem `index_exists` establishes that for any natural number `n`, any composition `c` of `n`, and any natural number `j` that is less than `n`, there exists an index `i` such that `j` is less than the sum of the sizes of the blocks in the composition up to `i+1`, and `i` is less than the number of blocks in the composition. In other words, this theorem states that for any particular `j` within the range of the composition, we can always find a segment of the composition (up to a certain block `i+1`) where the total size of the blocks is greater than `j`, and that this `i` is within the length of the composition.

For any composition `c` of a natural number `n` and any `0 < j < n`, there exists an index `i < n` such that the sum of the sizes of the first `i+1` blocks in `c` is greater than `j`.


theorem Set.preimage_union :
    ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {s t : Set β}, f ⁻¹' (s ∪ t) = f ⁻¹' s ∪ f ⁻¹' t := by sorry

The theorem `Set.preimage_union` states that for all types `α` and `β`, for every function `f` from `α` to `β`, and for any two sets `s` and `t` of type `β`, the preimage of the union of `s` and `t` under the function `f` is equal to the union of the preimages of `s` and `t` under `f`. In mathematical notation, this can be written as $f^{-1}(s \cup t) = f^{-1}(s) \cup f^{-1}(t)$. This means that the set of all elements in `α` that map to elements in either `s` or `t` is the same as the set of all elements in `α` that map to elements in `s` combined with those that map to elements in `t`.

For all types `α` and `β`, given functions `f` from `α` to `β`, and sets `s` and `t` in `β`, the preimage of `s ∪ t` under `f` equals the union of `f⁻¹(s)` and `f⁻¹(t)`.


theorem MeasureTheory.Measure.MutuallySingular.zero_right :
    ∀ {α : Type u_1} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α},
      MeasureTheory.Measure.MutuallySingular μ 0 :=
  by sorry

The theorem `MeasureTheory.Measure.MutuallySingular.zero_right` states that for any measure space `α` and any measure `μ` defined on this space, the measure `μ` and the zero measure are mutually singular. In the context of measure theory, two measures are said to be mutually singular if there exists a measurable set such that one measure is zero on this set and the other measure is zero on the complement of this set. In this case, any measure `μ` and the zero measure are mutually singular because you can consider the whole set as the measurable set where the zero measure is zero, and consequently, the `μ` measure is zero at the complement of the whole set which is the empty set.

For any measure space and measure, the measure and the zero measure are mutually singular.


/-- Given `f : β → ℝ≥0∞`, if `f` sends `{i | p i}` to a set of positive numbers
accumulating to zero, then `f i`-neighborhoods of the diagonal form a basis of `𝓤 α`.

For specific bases see `uniformity_basis_edist`, `uniformity_basis_edist'`,
`uniformity_basis_edist_nnreal`, and `uniformity_basis_edist_inv_nat`.  -/
theorem EMetric.mk_uniformity_basis :
    ∀ {α : Type u} [inst : PseudoEMetricSpace α] {β : Type u_2} {p : β → Prop} {f : β → ENNReal},
      (∀ (x : β), p x → 0 < f x) →
        (∀ (ε : ENNReal), 0 < ε → ∃ x, p x ∧ f x ≤ ε) →
          Filter.HasBasis (uniformity α) p fun x => {p | edist p.1 p.2 < f x} :=
  by sorry

This theorem states that for any pseudo-emetric space `α` and any function `f: β → [0, ∞]`, if `f` maps the set of elements `{i | p i}` to a set of positive numbers that accumulate to zero, then the collection of `f i`-neighborhoods of the diagonal forms a basis for the uniformity of `α`. In other words, given any positive extended non-negative real number `ε`, there exists an `x` such that `p x` holds and `f x` is less than or equal to `ε`, and for these `x`, we can find a neighborhood with elements `{p | edist p.1 p.2 < f x}` that will constitute a basis for the uniform structure on `α`.

Given any pseudo-metric space `α` and a function `f: β → [0, ∞]` such that the set of elements `{i | p i}` maps to positive accumulating numbers, the collection of `f i`-neighborhoods of the diagonal forms a basis for the uniformity of `α`.


/-- If two additive homomorphisms from `α →₀ M` are equal on each `single a b`,
then they are equal.

We formulate this using equality of `AddMonoidHom`s so that `ext` tactic can apply a type-specific
extensionality lemma after this one.  E.g., if the fiber `M` is `ℕ` or `ℤ`, then it suffices to
verify `f (single a 1) = g (single a 1)`.  -/
theorem Finsupp.addHom_ext' :
    ∀ {α : Type u_1} {M : Type u_5} {N : Type u_7} [inst : AddZeroClass M] [inst_1 : AddZeroClass N]
      ⦃f g : (α →₀ M) →+ N⦄,
      (∀ (x : α), AddMonoidHom.comp f (Finsupp.singleAddHom x) = AddMonoidHom.comp g (Finsupp.singleAddHom x)) →
        f = g :=
  by sorry

This theorem states that if there are two additive homomorphisms from `α →₀ M` to `N`, denoted as `f` and `g`, and for every `x` in `α`, the composition of `f` with `Finsupp.singleAddHom x` is equal to the composition of `g` with `Finsupp.singleAddHom x`, then `f` and `g` must be equal.

The theorem is formulated using equality of `AddMonoidHom`s, which means it is particularly amenable to the `ext` tactic. This tactic can apply a type-specific extensionality lemma after applying this theorem. For example, if the fiber `M` is `ℕ` or `ℤ`, it is enough to verify that `f` and `g` are equal on elements of the form `single a 1`.

If two additive homomorphisms from one additive monoid to another satisfy the condition that the composition of each homomorphism with the additive homomorphism defined by a single element is equal, then the two homomorphisms are equal.


theorem MeasureTheory.set_lintegral_mono :
    ∀ {α : Type u_1} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} {s : Set α} {f g : α → ENNReal},
      Measurable f → Measurable g → (∀ x ∈ s, f x ≤ g x) → ∫⁻ (x : α) in s, f x ∂μ ≤ ∫⁻ (x : α) in s, g x ∂μ :=
  by sorry

The theorem `MeasureTheory.set_lintegral_mono` states that for any measurable space `α`, any measure `μ` on that space, any subset `s` of `α`, and any two functions `f` and `g` from `α` to the extended nonnegative real numbers (where extended nonnegative real numbers, denoted as [0, ∞], are used as the codomain of a measure), if both `f` and `g` are measurable and for every element `x` in `s`, `f(x)` is less than or equal to `g(x)`, then the set integral of `f` over `s` with respect to `μ` is less than or equal to the set integral of `g` over `s` with respect to `μ`. In mathematical terms, the theorem is stating that if `f` and `g` are measurable functions and `f(x) ≤ g(x)` for all `x` in a set `s`, then the Lebesgue integral of `f` over the set `s` is less than or equal to the Lebesgue integral of `g` over the same set `s`.

If `f` and `g` are measurable functions on a measurable space `(α, Σ, μ)` with `f(x) ≤ g(x)` for all `x` in a set `s`, then ∫[s](f)dμ ≤ ∫[s](g)dμ. (Here, ∫[s](f)dμ denotes the set integral of `f` over `s` with respect to `μ`.)


theorem Mathlib.Algebra.Order.Archimedean._auxLemma.2 :
    ∀ {α : Type u} [inst : AddCommGroup α] [inst_1 : LT α]
      [inst_2 : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x < x_1] {a b c : α},
      (a - b < c) = (a < b + c) :=
  by sorry

This theorem states that for any type `α`, if `α` is an additive commutative group and has an order (`<`) that is covariant with respect to addition, then for any elements `a`, `b`, and `c` of `α`, the statement "the difference of `a` and `b` is less than `c`" is equivalent to the statement " `a` is less than the sum of `b` and `c`". This provides a kind of distributive property for the less-than relation over subtraction and addition.

For any additive commutative group `α` with covariant order `<`, the relation `a < b => a + c < b + c` holds for all `a, b, c ∈ α`.


theorem Part.eq_none_iff' : ∀ {α : Type u_1} {o : Part α}, o = Part.none ↔ ¬o.Dom := by sorry

The theorem `Part.eq_none_iff'` states that for any type `α` and any partial function `o` of type `Part α`, `o` is equivalent to `Part.none` if and only if the domain of `o` is not true. Here, `Part.none` is a partial function that has a `False` domain and an empty function. In other words, a partial function is the same as `Part.none` precisely when its domain is not true.

A partial function `o` of type `Part α` is equal to `Part.none` if and only if the domain of `o` is false.


theorem Finsupp.support_onFinset_subset :
    ∀ {α : Type u_1} {M : Type u_5} [inst : Zero M] {s : Finset α} {f : α → M} {hf : ∀ (a : α), f a ≠ 0 → a ∈ s},
      (Finsupp.onFinset s f hf).support ⊆ s :=
  by sorry

The theorem `Finsupp.support_onFinset_subset` states that for any type `α`, any type `M` with a zero element, any finite set `s` of elements of type `α`, and any function `f` from `α` to `M` with the property that `f` is zero outside of `s`, the support of the `Finsupp` function produced by `Finsupp.onFinset` applied to `s`, `f`, and the mentioned property, is a subset of `s`. In simpler terms, the theorem tells us that the set of nonzero elements in the `Finsupp` representation created from a function restricted to a finite set is always a subset of the original finite set.

For any finite set `s` and function `f` from a type `α` to a type `M` with a zero element, the support of the `Finsupp` function produced from `s`, `f`, and `f` being zero outside of `s`, is contained in `s`.


theorem FirstOrder.Language.Theory.models_iff_not_satisfiable :
    ∀ {L : FirstOrder.Language} {T : FirstOrder.Language.Theory L} (φ : FirstOrder.Language.Sentence L),
      T ⊨ᵇ φ ↔ ¬FirstOrder.Language.Theory.IsSatisfiable (T ∪ {FirstOrder.Language.Formula.not φ}) :=
  by sorry

The theorem `FirstOrder.Language.Theory.models_iff_not_satisfiable` in Lean 4, states that for any First-Order Language `L` and any theory `T` of that language, along with a sentence `φ` of that language, `T` models `φ` if and only if the theory that includes `T` and the negation of `φ` is not satisfiable. In simpler terms, a sentence is true in a theory if there is no model where both the theory and the negation of the sentence hold.

For any First-Order language L, theory T, and sentence φ in L, T models φ if and only if the theory T ∪ {~φ} is unsatisfiable. (Here, {~φ} denotes the set containing the negation of φ.)


SimpleGraph.Subgraph.Connected.mono

theorem SimpleGraph.Subgraph.Connected.mono :
    ∀ {V : Type u} {G : SimpleGraph V} {H H' : SimpleGraph.Subgraph G},
      H ≤ H' → H.verts = H'.verts → SimpleGraph.Subgraph.Connected H → SimpleGraph.Subgraph.Connected H' :=
  by sorry

This theorem states that for any type `V` and a simple graph `G` of that type, if we have two subgraphs `H` and `H'` of `G`, then if `H` is a subgraph of `H'` and the vertices of `H` are the same as the vertices of `H'`, and if `H` is a connected subgraph, then `H'` is also a connected subgraph. In mathematical terms, it says that the connectivity of a subgraph is preserved under taking a supergraph, assuming the vertices remain the same.

If `H` is a connected subgraph of simple graph `G` with the same vertices as a larger subgraph `H'` of `G`, then `H'` is also a connected subgraph.


theorem Subgroup.card_mul_index :
    ∀ {G : Type u_1} [inst : Group G] (H : Subgroup G), Nat.card ↥H * Subgroup.index H = Nat.card G := by sorry

This theorem states that for any group `G` and any subgroup `H` of `G`, the product of the cardinality of `H` (represented as a natural number) and the index of `H` in `G` (also represented as a natural number) equals the cardinality of `G`. In other words, if we denote the cardinality of a set `X` as `|X|`, the theorem asserts that `|H| * [G : H] = |G|`, where `[G : H]` denotes the index of the subgroup `H` in `G`. This is a generalization of Lagrange's Theorem for finite groups to possibly infinite groups, with the understanding that the cardinality and index are interpreted as natural numbers, and an "infinite" cardinality is represented by the natural number 0.

For any group `G` and subgroup `H`, the product of the cardinalities of `H` and its index in `G` equals the cardinality of `G`.


theorem Real.log_nonpos : ∀ {x : ℝ}, 0 ≤ x → x ≤ 1 → Real.log x ≤ 0 := by sorry

The theorem `Real.log_nonpos` states that for all real numbers `x`, if `x` is greater than or equal to 0 and less than or equal to 1, then the logarithm of `x` (as defined by the function `Real.log`) is less than or equal to 0. This is consistent with the properties of the logarithm function in real analysis, where the logarithm of a number between 0 and 1 (exclusive) is negative.

For all real numbers `x` with `0 ≤ x < 1`, `Real.log x ≤ 0`.


theorem Mathlib.Topology.MetricSpace.Thickening._auxLemma.8 :
    ∀ {α : Type u} [inst : PseudoEMetricSpace α] {δ : ℝ} {s : Set α} {x : α},
      (x ∈ Metric.cthickening δ s) = (EMetric.infEdist x s ≤ ENNReal.ofReal δ) :=
  by sorry

This theorem, `Mathlib.Topology.MetricSpace.Thickening._auxLemma.8`, is a statement about the relationship between a point and a certain set in a pseudo emetric space. Specifically, for any pseudo metric space `α`, any real number `δ`, any set `s` of type `α`, and any point `x` of type `α`, the theorem establishes that the point `x` is in the `δ`-thickening of the set `s` if and only if the infimum extended distance from the point `x` to the set `s` is less than or equal to the extended non-negative real representation of `δ`. In other words, it connects the concept of a `δ`-thickening of a set (which includes all points within a certain "thickness" or distance from the set) with the concept of the infimum extended distance of a point from a set.

In a pseudo metric space, a point is in the `δ`-thickening of a set if and only if the infimum extended distance from the point to the set is less than or equal to the extended non-negative real representation of `δ`.


theorem Equiv.Perm.length_toList :
    ∀ {α : Type u_1} [inst : Fintype α] [inst_1 : DecidableEq α] (p : Equiv.Perm α) (x : α),
      List.length (Equiv.Perm.toList p x) = (Equiv.Perm.support (Equiv.Perm.cycleOf p x)).card :=
  by sorry

The theorem `Equiv.Perm.length_toList` states that for any finite type `α` with decidable equality and given any permutation `p` of `α` and any element `x` of `α`, the length of the list produced by repeatedly applying the permutation `p` to `x` until a cycle is reached, is equal to the cardinality of the set of non-fixed points of the cycle of the permutation `p` to which `x` belongs. In mathematical terms, if we denote the operation of creating a list from a permutation and a starting point as `toList`, and the operation of getting the cycle of a permutation as `cycleOf`, the theorem states that for any permutation `p` and starting point `x`, `|toList(p, x)| = |support(cycleOf(p, x))|`, where `|A|` denotes the cardinality of the set `A`.

For any finite type `α` with decidable equality, given a permutation `p` and an element `x` of `α`, the length of the list obtained by applying `p` repeatedly to `x` until reaching a cycle equals the cardinality of the support of the cycle containing `x`.


theorem Ring.inverse_one : ∀ (M₀ : Type u_2) [inst : MonoidWithZero M₀], Ring.inverse 1 = 1 := by sorry

This theorem states that for any type `M₀` which carries a structure of a monoid with zero, the `Ring.inverse` of the multiplicative identity `1` is `1` itself. This essentially means that `1` is its own multiplicative inverse in any monoid with zero structure.

In any monoid with zero, the multiplicative identity has itself as its multiplicative inverse.


theorem Orientation.areaForm_to_volumeForm :
    ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : InnerProductSpace ℝ E]
      [inst_2 : Fact (FiniteDimensional.finrank ℝ E = 2)] (o : Orientation ℝ E (Fin 2)) (x y : E),
      ((Orientation.areaForm o) x) y = (Orientation.volumeForm o) ![x, y] :=
  by sorry

This theorem, `Orientation.areaForm_to_volumeForm`, states that for any oriented real inner product space `E` of dimension 2, any orientation `o` of `E`, and any two vectors `x` and `y` in `E`, the value obtained by applying the area form to `x` and `y` is equal to the value obtained by applying the volume form to the ordered list of vectors `[x, y]`. The area form gives the oriented area of the parallelogram spanned by `x` and `y`, while the volume form gives a nonvanishing top-dimensional alternating form uniquely defined by compatibility with the orientation and inner product structure.

For any oriented 2-dimensional real inner product space `E`, orientation `o`, and vectors `x` and `y` in `E`, the area form `o(x, y)` equals the volume form's value on the ordered list `[x, y]`.


/-- **First moment method**. An integrable function is smaller than its mean on a set of positive
measure.  -/
theorem MeasureTheory.measure_le_setAverage_pos :
    ∀ {α : Type u_1} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} {s : Set α} {f : α → ℝ},
      ↑↑μ s ≠ 0 → ↑↑μ s ≠ ⊤ → MeasureTheory.IntegrableOn f s μ → 0 < ↑↑μ {x | x ∈ s ∧ f x ≤ ⨍ (a : α) in s, f a ∂μ} :=
  by sorry

This theorem is referred to as the "First Moment Method". It states that for any given set of type `α`, measurable space `m0`, measure `μ`, set `s`, and real-valued function `f`, if the measure of the set `s` is not zero or infinity, and the function `f` is integrable on the set `s` with measure `μ`, then the measure of the subset of `s` where `f` is less than or equal to its average over `s` (computed with respect to `μ`) is positive. This means that an integrable function `f` is smaller than its mean on a set of positive measure.

For any measurable set `s` with finite measure and integrable function `f` on `s`, the subset of `s` where `f` is less than or equal to the average of `f` over `s` has positive measure.


theorem orderOf_eq_zero : ∀ {G : Type u_1} [inst : Monoid G] {x : G}, ¬IsOfFinOrder x → orderOf x = 0 := by sorry

The theorem `orderOf_eq_zero` states that for any type `G` that forms a monoid, and any element `x` of type `G`, if `x` is not of finite order (meaning, there doesn't exist a positive natural number `n` such that `x` raised to the power `n` equals the identity element), then the order of `x` is zero. In other words, if an element of a monoid does not have a finite order, its order by convention is zero.

If a monoid element has no finite order, then its order is 0.


Con.symm

/-- Congruence relations are symmetric.  -/
theorem Con.symm : ∀ {M : Type u_1} [inst : Mul M] (c : Con M) {x y : M}, c x y → c y x := by sorry

This theorem states that congruence relations are symmetric in the context of a multiplication operation on a type `M`. Specifically, for any type `M` with a multiplication operation, and for any congruence relation `c` on `M`, if `x` and `y` are elements of `M` such that `x` is congruent to `y` under the relation `c`, then `y` is also congruent to `x` under the same relation. In other words, if `c x y` is true, then `c y x` is also true, confirming the symmetry of the congruence relation.

If `x` is congruent to `y` under a congruence relation `c` on a type `M` with multiplication operation, then `y` is congruent to `x` under the same relation. (i.e., `c x y` implies `c y x`)


theorem finprod_mem_def :
    ∀ {α : Type u_1} {M : Type u_5} [inst : CommMonoid M] (s : Set α) (f : α → M),
      (finprod fun a => finprod fun h => f a) = finprod fun a => Set.mulIndicator s f a :=
  by sorry

The theorem `finprod_mem_def` states that for any set `s` of a certain type `α` and any function `f` from `α` to a type `M` (where `M` has a `CommMonoid` structure), the product of `f(x)` for each `x` in `s` is the same as the product of `f(x)` if `x` is in `s` and `1` otherwise. In other words, the finite product over the set `s` (using the function `f`) is equal to the finite product over all elements, where each element not in `s` contributes a multiplicative identity (`1`) to the product. This is computed using the `Set.mulIndicator` function, which returns the value of the function `f` at a point if the point is in the set, and `1` otherwise.

For any set `s` and function `f` from a type `α` to a commutative monoid `M`, the finite product of `f(x)` over `s` equals the product of `f(x)` for `x` in `s` and `1` for `x` not in `s`.


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

This theorem is about asymptotic notation, specifically Big O notation, in the context of function analysis. It provides a condition under which we can replace one function with another in a Big O statement. Specifically, it states that for any two functions `f₁` and `f₂` mapping from some arbitrary type `α` to another type `E`, and another function `g` mapping from `α` to a third type `F` (with both `E` and `F` being types that have a norm), if `f₁` is Big O of `g` with respect to some filter `l`, and every output of `f₁` is equal to the corresponding output of `f₂`, then `f₂` is also Big O of `g` with respect to the same filter.

If `f₁` is Big O of `g` with respect to filter `l` and `f₁(x) = f₂(x)` for all `x`, then `f₂` is Big O of `g` with respect to `l`.


Set.Finite.diff

theorem Set.Finite.diff : ∀ {α : Type u} {s : Set α}, Set.Finite s → ∀ (t : Set α), Set.Finite (s \ t) := by sorry

The theorem `Set.Finite.diff` states that for any type 'α' and for any set 's' of type 'α', if 's' is a finite set, then for every other set 't' of type 'α', the difference of 's' and 't' (denoted as 's \ t'), which is the set of elements in 's' not in 't', is also a finite set. In other words, the operation of set difference preserves finiteness: subtracting elements from a finite set always results in a finite set.

If 's' is a finite set, then the set difference 's \ t' between 's' and any set 't' is also a finite set.


theorem Cardinal.lift_down :
    ∀ {a : Cardinal.{u}} {b : Cardinal.{max u v}}, b ≤ Cardinal.lift.{v, u} a → ∃ a', Cardinal.lift.{v, u} a' = b := by
  sorry

The theorem `Cardinal.lift_down` states that for any two cardinal numbers `a` and `b`, where `a` is from universe `u` and `b` is from the maximum universe of `u` and `v`, if `b` is less than or equal to the lift of `a` (which is the cardinality of the universe `u` lifted to the maximum universe of `u` and `v`), then there exists a cardinal number `a'` such that the lift of `a'` equals `b`. In other words, the theorem guarantees the existence of a cardinal number `a'` in the lower universe `v` that when lifted to the higher universe matches `b`, provided `b` does not exceed the lift of `a`.

Given any cardinal numbers `a` from universe `u` and `b` from the maximum universe of `u` and `v`, if `b` is less than or equal to the lift of `a`, then there exists a cardinal number `a'` in `v` such that the lift of `a'` equals `b`.