UniformContinuousOn.tendstoUniformly

theorem UniformContinuousOn.tendstoUniformly :
    ∀ {α : Type u} {β : Type v} {γ : Type w} [inst : UniformSpace β] [inst_1 : UniformSpace α] [inst_2 : UniformSpace γ]
      {x : α} {U : Set α},
      U ∈ nhds x → ∀ {F : α → β → γ}, UniformContinuousOn (↿F) (U ×ˢ Set.univ) → TendstoUniformly F (F x) (nhds x) :=
  by sorry

This theorem states that for all types `α`, `β`, and `γ` equipped with uniform spaces, given a point `x` of type `α` and a set `U` of type `α` which is a neighborhood of `x`, and a function `F` from `α` to the space of functions from `β` to `γ`, if `F` is uniformly continuous on the product of the set `U` and the universal set of `β`, then the sequence of functions `F` converges uniformly to the function `F(x)` with respect to the neighborhood filter of `x`.

In simpler terms, if `F` is uniformly continuous when `x` is in a neighborhood `U`, then as `x` gets closer and closer to a point in the neighborhood, `F(x)` will get closer and closer to a limit function at a uniform rate, regardless of where `x` is in the neighborhood.

If `F` is a uniformly continuous function from the product of a neighborhood `U` of a point `x` in type `α` and the universal set of `β` to the space of functions from `β` to `γ`, then `F` converges uniformly to `F(x)` with respect to the neighborhood filter of `x`.


theorem IsClopen.connectedComponent_subset :
    ∀ {α : Type u} [inst : TopologicalSpace α] {s : Set α} {x : α}, IsClopen s → x ∈ s → connectedComponent x ⊆ s := by
  sorry

This theorem states that for any type `α` endowed with a topological space structure and any subset `s` of `α` that is clopen (both closed and open), if a point `x` is a member of `s`, then the connected component of `x` is a subset of `s`. The connected component of a point is the largest preconnected set containing that point. In the context of topological spaces, a set is preconnected if it cannot be represented as the union of two disconnected non-empty open sets.

If `α` is a topological space, `s` is a clopen subset of `α`, and `x` is an element of `s`, then the connected component of `x` is contained in `s`.


theorem lipschitzWith_max : LipschitzWith 1 fun p => max p.1 p.2 := by sorry

The theorem `lipschitzWith_max` states that the function that takes a pair of points `p` and returns the maximum of the two points `p.1` and `p.2` is Lipschitz continuous with a Lipschitz constant of `1`. In other words, for any two pairs of points `x` and `y`, the distance between `max x.1 x.2` and `max y.1 y.2` is less than or equal to the distance between `x` and `y`.

The function that maps a pair of real numbers to their maximum is 1-Lipschitz continuous.


/-- `vectorSpan` is monotone.  -/
theorem vectorSpan_mono :
    ∀ (k : Type u_1) {V : Type u_2} {P : Type u_3} [inst : Ring k] [inst_1 : AddCommGroup V] [inst_2 : Module k V]
      [inst_3 : AddTorsor V P] {s₁ s₂ : Set P}, s₁ ⊆ s₂ → vectorSpan k s₁ ≤ vectorSpan k s₂ :=
  by sorry

The theorem `vectorSpan_mono` asserts the monotonicity of the `vectorSpan` function. In particular, it states that for any ring `k`, additive commutative group `V`, and additive torsor `P`, and any two sets `s₁` and `s₂` of elements of `P` such that `s₁` is a subset of `s₂`, the vector span of `s₁` is a submodule of, or equal to, the vector span of `s₂`. This means that expanding the set of points from which we form differences to compute the vector span only results in a larger (or equal) spanned submodule.

For any additive torsor P over a commutative ring k, if s1 is a subset of s2 in P, then the vector span of s1 is contained in the vector span of s2.


/-- If `0 : ℕ` is not in the support of `f : ℕ →₀ ℕ` then `0 < ∏ x in f.support, x ^ (f x)`.  -/
theorem Nat.prod_pow_pos_of_zero_not_mem_support :
    ∀ {f : ℕ →₀ ℕ}, 0 ∉ f.support → 0 < Finsupp.prod f fun x x_1 => x ^ x_1 := by sorry

The theorem `Nat.prod_pow_pos_of_zero_not_mem_support` states that for any function `f` mapping from natural numbers to natural numbers, if the value `0` is not in the support of `f` (meaning `f` does not map any element to `0`), then the product of each element in the support of `f`, raised to the power of its corresponding image under `f`, is strictly greater than zero. This product is taken over all elements `x` in the support of `f` with each term being `x` to the power of `f(x)`.

If a function `f` from natural numbers to natural numbers maps no element to `0`, then the product of each element in the support of `f` raised to the power of its image under `f` is strictly positive.


theorem Set.Icc_infinite :
    ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : DenselyOrdered α] {a b : α}, a < b → Set.Infinite (Set.Icc a b) := by
  sorry

The theorem `Set.Icc_infinite` states that for any type `α` that is equipped with a preorder and is densely ordered, and for any two elements `a` and `b` of `α` where `a` is strictly less than `b`, the left-closed right-closed interval from `a` to `b` (denoted `Set.Icc a b`) is infinite. In other words, there are infinitely many elements in the interval between `a` and `b`.

For any densely ordered type `α` with a preorder, every strictly increasing interval `I = {x : α | a ≤ x ≤ b}` is infinite.


theorem Homeomorph.funSplitAt_symm_apply :
    ∀ (Y : Type u_2) [inst : TopologicalSpace Y] {ι : Type u_6} [inst_1 : DecidableEq ι] (i : ι)
      (f : (fun a => Y) i × ((j : { j // j ≠ i }) → (fun a => Y) ↑j)) (j : ι),
      (Homeomorph.symm (Homeomorph.funSplitAt Y i)) f j = if h : j = i then f.1 else f.2 { val := j, property := ⋯ } :=
  by sorry

This theorem states that for any type `Y` that has a structure of a topological space, any type `ι` with decidable equality, and any index `i` of type `ι`, the inverse of the homeomorphism `funSplitAt` applied to a pair consisting of a point in `Y` and a function from the set of indices not equal to `i` to `Y`, evaluated at any index `j` of type `ι`, is equal to the first component of the pair if `j` is equal to `i`, and the second component of the pair evaluated at `j` otherwise. In other words, it undoes the splitting operation performed by `funSplitAt`.

For any topological space `Y`, decidable type `ι`, and homeomorphism `f` of `Y × (ι → Y)` to `Y × ι` (denoted `funSplitAt`), `f.symm (f x (fun i => if h: i ≠ i then i := i, i := x.2 i)) = if h: i = i then x else x.2 i`.


theorem Bornology.isBounded_biUnion :
    ∀ {ι : Type u_1} {α : Type u_2} [inst : Bornology α] {s : Set ι} {f : ι → Set α},
      Set.Finite s → (Bornology.IsBounded (⋃ i ∈ s, f i) ↔ ∀ i ∈ s, Bornology.IsBounded (f i)) :=
  by sorry

This theorem states that for any type `α` with a given bornology and any finite set `s` of elements of type `ι`, the union of the sets `f i` (where `i` ranges over `s`) is bounded in the bornology iff each individual set `f i` is bounded in the bornology. In other words, a finite union of sets is bounded if and only if each of the constituent sets is bounded, given the bornology structure on the underlying type.

For any bornology on a type `α` and finite set `s` of `ι`, the union of the bounded sets `f i` (where `i` ranges over `s`) is bounded if and only if each `f i` is bounded.


theorem PartialHomeomorph.image_source_eq_target :
    ∀ {X : Type u_1} {Y : Type u_3} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y]
      (e : PartialHomeomorph X Y), ↑e '' e.source = e.target :=
  by sorry

This theorem states that for any given partial homeomorphism `e` between two topological spaces `X` and `Y`, the image of the source set of `e` under the function `e` is equal to the target set of `e`. In other words, if you apply the partial homeomorphism `e` to every point in its source set, you'll get exactly the target set. This is a fundamental property that reflects the idea of a homeomorphism being a bijective correspondence between two topological spaces that preserves the structure of the spaces.

For any partial homeomorphism between topological spaces, the image of its domain is equal to the range.


theorem Set.iUnion₂_eq_univ_iff :
    ∀ {α : Type u_1} {ι : Sort u_4} {κ : ι → Sort u_7} {s : (i : ι) → κ i → Set α},
      ⋃ i, ⋃ j, s i j = Set.univ ↔ ∀ (a : α), ∃ i j, a ∈ s i j :=
  by sorry

The theorem `Set.iUnion₂_eq_univ_iff` states that for any type `α` and any type functions `ι` and `κ` determined by `ι`, and for any function `s` that maps each pair of elements `(i : ι)` and `(j : κ i)` to a set of elements of type `α`, the double indexed union over `i` and `j` of `s i j` is equal to the universal set of `α` if and only if for every element `a` of type `α`, there exist `i` and `j` such that `a` is an element of `s i j`. In mathematical terms, this theorem says that a double union of sets covers the entire universe of discourse if and only if every element of the universe is in at least one of the sets in the union.

A double indexed union of sets equals the universe if and only if each element of the universe belongs to at least one set in the union.


theorem Set.not_mem_uIcc_of_lt :
    ∀ {α : Type u_1} [inst : LinearOrder α] {a b c : α}, c < a → c < b → c ∉ Set.uIcc a b := by sorry

The theorem `Set.not_mem_uIcc_of_lt` states that for any type `α` that has a linear order and for any three elements `a`, `b`, and `c` of this type, if `c` is less than `a` and `c` is also less than `b`, then `c` does not belong to the set `uIcc a b`. The set `uIcc a b` is defined as the set of all elements that lie between `a` and `b`, inclusive of `a` and `b` themselves. In other words, `c` cannot be in the set `uIcc a b` if `c` is less than both `a` and `b`.

For any type `α` with a linear order and any elements `a`, `b`, and `c` of `α`, if `c` is strictly less than both `a` and `b`, then `c` is not in the interval `[a, b]` (denoted `uIcc a b` in Lean) consisting of elements between `a` and `b` inclusive.


theorem Fin.succ_ne_last_iff : ∀ {n : ℕ} (a : Fin (n + 1)), Fin.succ a ≠ Fin.last (n + 1) ↔ a ≠ Fin.last n := by sorry

This theorem, `Fin.succ_ne_last_iff`, states that for any natural number `n` and a finite ordinal `a` of `n+1`, the successor of `a` is not equal to the greatest value of `Fin (n+1)` if and only if `a` is not equal to the greatest value of `Fin n`. In other words, incrementing a finite ordinal does not result in the maximum finite ordinal of the next type if and only if the original finite ordinal was not the maximum of its type.

The successor of a finite ordinal is not the maximum value of the next type if and only if the ordinal is not the maximum value of its type.


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

This theorem states that for any group `G` and subgroup `H` of `G`, the index of `H` in `G` is equal to one if and only if `H` is the entire group `G`. Here, the index of a subgroup is defined as the number of distinct cosets of the subgroup in the group, and the symbol `⊤` represents the whole group. If the index is infinite, the index function returns 0.

A subgroup of a group is the entire group if and only if its index is equal to 1. (In other words, a subgroup is the identity subgroup if and only if every coset is identical to the group itself.)


theorem IsAlgClosed.exists_pow_nat_eq :
    ∀ {k : Type u} [inst : Field k] [inst_1 : IsAlgClosed k] (x : k) {n : ℕ}, 0 < n → ∃ z, z ^ n = x := by sorry

This theorem states that for any type `k` which forms a field and is algebraically closed, and for any element `x` of type `k` and natural number `n` greater than zero, there exists an element `z` in `k` such that `z` raised to the power `n` equals `x`. Essentially, the theorem guarantees the existence of `nth` roots in an algebraically closed field.

In an algebraically closed field, every non-zero element has a root of any positive integer power.


theorem eq_min :
    ∀ {α : Type u} [inst : LinearOrder α] {a b c : α},
      c ≤ a → c ≤ b → (∀ {d : α}, d ≤ a → d ≤ b → d ≤ c) → c = min a b :=
  by sorry

This theorem states that for any type `α` that has a linear order, given three instances `a`, `b`, and `c` of this type, if `c` is less than or equal to both `a` and `b`, and for all `d` of type `α`, if `d` is less than or equal to `a` and `b`, then `d` is also less than or equal to `c`, it follows that `c` is equal to the minimum of `a` and `b`. In terms of mathematical language, given $c \leq a$ and $c \leq b$ and for all $d$, $d \leq a$ and $d \leq b$ implies $d \leq c$, then $c = \min(a, b)$.

If `α` is a type with a linear order and `c` is between `a` and `b` with `c` less than or equal to all `d` in `α` that are less than or equal to `a` and `b`, then `c` is the minimum of `a` and `b`. In mathematical notation: $c \in \{\min(a, b)\} \iff c \leq a, c \leq b \land \forall d \in \alpha, d \leq a, d \leq b \implies d \leq c$.


theorem AddSubgroup.coe_neg : ∀ {G : Type u_1} [inst : AddGroup G] (H : AddSubgroup G) (x : ↥H), ↑(-x) = -↑x := by sorry

This theorem states that for any specific AddGroup `G` and any element `x` in an AddSubgroup `H` of `G`, the negation of `x` in the group (expressed as `-x`) when coerced (or converted) back to its underlying type is equal to the negative of the coercion of `x` (expressed as `-↑x`). Essentially, this theorem asserts that the negation operation in the subgroup is consistent with the negation operation in the larger group.

For any AddGroup `G`, AddSubgroup `H` within `G`, and element `x` in `H`, the negation of `x` in `H` (`-x`) is equal to the negative of `x` in `G` coerced back to `H` (`-↑x`).


theorem ONote.fastGrowing_succ :
    ∀ (o : ONote) {a : ONote},
      ONote.fundamentalSequence o = Sum.inl (some a) → ONote.fastGrowing o = fun i => (ONote.fastGrowing a)^[i] i :=
  by sorry

This theorem, `ONote.fastGrowing_succ`, states that for any ordinal notation `o` and another ordinal notation `a`, if the fundamental sequence of `o` is the left sum of `some a`, then the fast-growing function of `o` is equivalent to the `i`-th iterate of the fast-growing function of `a` evaluated at `i`. Essentially, it relates the fast-growing function of an ordinal with the fast-growing functions of its fundamental sequences.

For any ordinal notations `o` and `a`, if the fundamental sequence of `o` is the left sum of some `a`, then the fast-growing function of `o` is equivalent to the iterated fast-growing function of `a` evaluated at the index of the left sum.


theorem Mathlib.SetTheory.Ordinal.Exponential._auxLemma.5 :
    ∀ {α : Type u} [inst : Preorder α] (a : α), (a ≤ a) = True := by sorry

This theorem states that for any type `α` under a preorder, every element `a` of type `α` is less than or equal to itself. In mathematical terms, for all `a` in some set that is preordered, the statement `a ≤ a` is always true. This property is known as reflexivity, a fundamental aspect of preorders.

In any preorder, every element is refundlexive, i.e., for all `a`, `a ≤ a`.


theorem Mathlib.SetTheory.Ordinal.Exponential._auxLemma.6 : ∀ (o : Ordinal.{u_3}), (0 ≤ o) = True := by sorry

The theorem `Mathlib.SetTheory.Ordinal.Exponential._auxLemma.6` states that for every ordinal `o`, the property that `o` is greater than or equal to zero is always true. In other words, it asserts that no ordinal can be less than zero. This is analogous to the property of natural numbers in mathematics where every natural number is non-negative.


theorem MeasureTheory.le_trim :
    ∀ {α : Type u_1} {m m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} {s : Set α} (hm : m ≤ m0),
      ↑↑μ s ≤ ↑↑(μ.trim hm) s :=
  by sorry

The theorem `MeasureTheory.le_trim` states that for any type `α`, any two measurable spaces `m` and `m0` over `α`, any measure `μ` over `α`, and any set `s` of type `α`, if the measurable space `m` is a subset or equal to the measurable space `m0`, then the measure of the set `s` under the measure `μ` is less than or equal to the measure of the set `s` under the trimmed measure `μ.trim hm`. The trimming operation on the measure is based on the inclusion relation between the two measurable spaces.

For any measurable spaces `m` and `m0` over type `α`, measure `μ` over `α`, and set `s` of type `α`, if `m` is a subset or equal to `m0`, then `μ(s) ≤ μ.trim hm(s)`.


/-- **Alias** of the reverse direction of `Set.subset_compl_iff_disjoint_right`. -/
theorem Disjoint.subset_compl_right : ∀ {α : Type u} {s t : Set α}, Disjoint s t → s ⊆ tᶜ := by sorry

This theorem, named `Disjoint.subset_compl_right`, states that for any type `α` and any two sets `s` and `t` of type `α`, if `s` and `t` are disjoint, then `s` is a subset of the complement of `t`. In other words, if no element from `s` is found in `t`, then all elements of `s` must be outside of `t`, i.e., in `t`'s complement. The notion of disjointness here generalizes the concept of disjoint sets to any two elements of a lattice where their infimum (greatest lower bound) is the bottom element.

If sets `s` and `t` are disjoint in a lattice, then `s` is a subset of the complement of `t`.


theorem MeasureTheory.Measure.pi'_pi :
    ∀ {ι : Type u_1} {α : ι → Type u_3} [inst : Fintype ι] [inst_1 : (i : ι) → MeasurableSpace (α i)]
      (μ : (i : ι) → MeasureTheory.Measure (α i)) [inst_2 : Encodable ι]
      [inst_3 : ∀ (i : ι), MeasureTheory.SigmaFinite (μ i)] (s : (i : ι) → Set (α i)),
      ↑↑(MeasureTheory.Measure.pi' μ) (Set.pi Set.univ s) = Finset.prod Finset.univ fun i => ↑↑(μ i) (s i) :=
  by sorry

This theorem, `MeasureTheory.Measure.pi'_pi`, states that for a given index set `ι` and a family of types `α : ι → Type` where `ι` has a `Fintype` instance, and each `α i` has a `MeasurableSpace` instance, then given `μ` (a function that for each index `i` of type `ι` returns a measure on `α i`), and `s` (a function that for each index `i` of type `ι` returns a set of `α i`), if each measure `μ i` is sigma finite and `ι` is encodable, then the measure of the set of all possible functions (`Set.pi Set.univ s`) under the product measure (`MeasureTheory.Measure.pi' μ`) is equal to the product of the measures of all `s i` under their corresponding measures `μ i`. That is, the total measure of the set of all possible functions from `ι` to their corresponding sets `s i` (which are subsets of their corresponding `α i`) is the product of the measures of all `s i` under their corresponding measures `μ i`. This theorem is a formalization of the concept of the product measure in measure theory.

Given a family of measurable spaces `(α i : ι → Type)` indexed by a finite set `ι`, if each `μ i : MeasurableMeasure α i` is sigma-finite and `ι` is encodable, then `MeasureTheory.Measure.pi' μ (Set.pi Set.univ (λ i, s i)) = ∏ i : ι, μ i (s i)`.


theorem Submodule.span_eq_span :
    ∀ {R : Type u_1} {M : Type u_4} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {s t : Set M},
      s ⊆ ↑(Submodule.span R t) → t ⊆ ↑(Submodule.span R s) → Submodule.span R s = Submodule.span R t :=
  by sorry

This theorem states that for any semiring `R` and any additively commutative monoid `M` that forms a module over `R`, given two sets `s` and `t` of elements of `M`, if `s` is a subset of the span of `t` and `t` is a subset of the span of `s`, then the span of `s` is equal to the span of `t`. In other words, if two sets are each contained within the smallest subspace generated by the other, then the subspaces they generate are identical.

If `R` is a semiring, `M` is an additively commutative `R`-module, and `s` and `t` are subsets of `M` such that `s` is contained in the span of `t` and `t` is contained in the span of `s`, then the span of `s` equals the span of `t`.


theorem Set.not_mem_uIcc_of_gt :
    ∀ {α : Type u_1} [inst : LinearOrder α] {a b c : α}, a < c → b < c → c ∉ Set.uIcc a b := by sorry

This theorem states that for any type `α` with a linear order, and for any three elements `a`, `b`, and `c` of type `α`, if `c` is greater than both `a` and `b`, then `c` is not in the set `uIcc a b`. Here `uIcc a b` represents the set of elements lying between `a` and `b`, inclusive. In other words, if `c` is strictly greater than both ends of a closed interval, it does not belong to that interval.

For any linear order type `α` and elements `a`, `b`, `c` in `α`, if `c` is strictly greater than both `a` and `b`, then `c` is not in the closed interval `[a, b]`.


/-- **Alias** of `le_of_smul_le_smul_left`. -/
theorem le_of_smul_le_smul_of_pos_left :
    ∀ {α : Type u_1} {β : Type u_2} {a : α} {b₁ b₂ : β} [inst : SMul α β] [inst_1 : Preorder α] [inst_2 : Preorder β]
      [inst_3 : Zero α] [inst_4 : PosSMulReflectLE α β], a • b₁ ≤ a • b₂ → 0 < a → b₁ ≤ b₂ :=
  by sorry

The theorem `le_of_smul_le_smul_of_pos_left` states that, for any types `α` and `β`, given an instance of scalar multiplication (`SMul`) on `α` and `β`, preorder relationships on `α` and `β`, a zero element in `α`, and a property `PosSMulReflectLE` that reflects relation of `≤` across positive scalar multiplication, if the product of scalar `a` (where `a` is positive) and `β` value `b₁` is less than or equal to the product of `a` and another `β` value `b₂`, then `b₁` is less than or equal to `b₂`. In mathematical terms, for all positive `a`, if `a * b₁ ≤ a * b₂` then `b₁ ≤ b₂`.

For all types α and β with scalar multiplication, and for all positive a, if a * b₁ ≤ a * b₂ then b₁ ≤ b₂.


theorem AkraBazziRecurrence.isEquivalent_one_add_smoothingFn_one :
    Asymptotics.IsEquivalent Filter.atTop (fun x => 1 + AkraBazziRecurrence.smoothingFn x) fun x => 1 := by sorry

This theorem states that the function `1 + AkraBazziRecurrence.smoothingFn x`, where the smoothing function is defined as `1 / log x`, is asymptotically equivalent to the function `1` as `x` goes to infinity (symbolized by `Filter.atTop`). In more mathematical terms, it means that the difference between the two functions `(1 + 1 / log x) - 1` becomes infinitesimally small compared to `1` as `x` approaches infinity.

As x approaches infinity, the difference between `1 + 1 / log x` and `1` approaches 0.


theorem DFinsupp.support_eq_empty :
    ∀ {ι : Type u} {β : ι → Type v} [inst : DecidableEq ι] [inst_1 : (i : ι) → Zero (β i)]
      [inst_2 : (i : ι) → (x : β i) → Decidable (x ≠ 0)] {f : Π₀ (i : ι), β i}, DFinsupp.support f = ∅ ↔ f = 0 :=
  by sorry

This theorem, `DFinsupp.support_eq_empty`, states that for any types `ι` and `β` where `β` is a function from `ι` to some type, and given instances of decidable equality for `ι`, a zero for each `β i`, and decidable inequality from zero for each `β i`, a function `f` of type `Π₀ (i : ι), β i` (direct product of `β i` over `ι`) has an empty support (i.e., all elements of `f` are zero) if and only if `f` is the zero function. In other words, the support of `f` is empty if and only if `f` maps every element of `ι` to zero.

The theorem asserts that a function from a type ι to β has an empty support (i.e., maps every element to zero) if and only if it is the zero function, given decidable equality for ι, and decidable inequality from zero for each β i.


theorem fg_adjoin_of_finite :
    ∀ {R : Type u_1} {A : Type u_2} [inst : CommRing R] [inst_1 : CommRing A] [inst_2 : Algebra R A] {s : Set A},
      Set.Finite s → (∀ x ∈ s, IsIntegral R x) → Submodule.FG (Subalgebra.toSubmodule (Algebra.adjoin R s)) :=
  by sorry

The theorem `fg_adjoin_of_finite` states that for every commutative ring `R`, a commutative ring `A`, and a set `s` of `A`, if `s` is finite and every element `x` in `s` is integral over `R`, then the submodule obtained by applying the function `Subalgebra.toSubmodule` to the subalgebra generated by `s` over `R` (represented as `Algebra.adjoin R s`) is finitely generated. In other words, this theorem states that the subalgebra formed by adjoining a finite set of integral elements to a commutative ring forms a finitely generated submodule.

If `R` is a commutative ring, `A` is a commutative `R`-algebra, and `s` is a finite set of elements in `A` integral over `R`, then the submodule of `A` generated by `s` is finitely generated.


/-- If one multiplies by `c i` the coordinates in a finset `s`, then the image under a multilinear
map is multiplied by `∏ i in s, c i`. This is mainly an auxiliary statement to prove the result when
`s = univ`, given in `map_smul_univ`, although it can be useful in its own right as it does not
require the index set `ι` to be finite.  -/
theorem MultilinearMap.map_piecewise_smul :
    ∀ {R : Type uR} {ι : Type uι} {M₁ : ι → Type v₁} {M₂ : Type v₂} [inst : CommSemiring R]
      [inst_1 : (i : ι) → AddCommMonoid (M₁ i)] [inst_2 : AddCommMonoid M₂] [inst_3 : (i : ι) → Module R (M₁ i)]
      [inst_4 : Module R M₂] (f : MultilinearMap R M₁ M₂) [inst_5 : DecidableEq ι] (c : ι → R) (m : (i : ι) → M₁ i)
      (s : Finset ι), f (Finset.piecewise s (fun i => c i • m i) m) = (Finset.prod s fun i => c i) • f m :=
  by sorry

This theorem states that for a given multilinear map `f`, if we multiply the coordinates in a finset `s` by `c i` and apply `f` to the result, it is equivalent to multiplying the result of applying `f` to the original coordinates by the product of `c i` over all `i` in `s`. In more mathematical terms, `f((c i) * m i) = (∏ i in s, c i) * f(m)` for all `i` in `s`, where `m` is a function mapping from the index set `ι` to the modules `M₁ i`, `s` is a subset of `ι`, and `c` is a function mapping from `ι` to the ring `R`. This result does not require the index set `ι` to be finite.

For a multilinear map `f` and functions `c: ι -> R` and `m: ι -> M₁ i`, the equation `f(∑ i in s, c i * mi) = ∏ i in s, c i * f(mi)` holds for any subset `s` of the index set `ι`.


theorem Fintype.card_lt_of_injective_of_not_mem :
    ∀ {α : Type u_1} {β : Type u_2} [inst : Fintype α] [inst_1 : Fintype β] (f : α → β),
      Function.Injective f → ∀ {b : β}, b ∉ Set.range f → Fintype.card α < Fintype.card β :=
  by sorry

The theorem `Fintype.card_lt_of_injective_of_not_mem` states that for any two finite types `α` and `β` and a function `f` from `α` to `β`, if `f` is injective (meaning that equal outputs imply equal inputs) and there exists an element `b` in `β` that is not in the range of `f` (meaning that `b` is not the image of any element of `α` under `f`), then the cardinality (or size) of `α` is strictly less than the cardinality of `β`. In essence, this theorem is stating a property about the sizes of sets under certain conditions related to injective functions.

If `f` is an injective function from the finite type `α` to the finite type `β` with `β` containing an element not in the image of `f`, then `#α < #β`.


theorem Mathlib.Data.Finset.Grade._auxLemma.16 : ∀ {α : Type u_1} {s₁ s₂ : Finset α}, (s₁ = s₂) = (↑s₁ = ↑s₂) := by
  sorry

This theorem, named `Mathlib.Data.Finset.Grade._auxLemma.16`, states that for any type `α` and any two finite sets `s₁` and `s₂` of type `α`, `s₁` is equal to `s₂` if and only if the coercions of `s₁` and `s₂` to sets are equal. This is essentially saying that two finite sets are equal if their underlying set representations are equal.

Two finite sets of type `α` are equal if and only if their underlying set representations are equal.


HasSum.toNNReal

theorem HasSum.toNNReal :
    ∀ {α : Type u_1} {f : α → ℝ} {y : ℝ},
      (∀ (n : α), 0 ≤ f n) → HasSum f y → HasSum (fun x => Real.toNNReal (f x)) (Real.toNNReal y) :=
  by sorry

This theorem states that for any type `α`, any function `f` from `α` to the real numbers `ℝ`, and any real number `y`, if all values of `f` are non-negative (i.e., for every `n` in `α`, `f(n)` is greater than or equal to 0), and `f` has a sum `y`, then the function which converts each value of `f` to a non-negative real number using `Real.toNNReal` also has a sum, which is the non-negative real number corresponding to `y` obtained via `Real.toNNReal`. In essence, it asserts that summing a sequence of real numbers (which are all non-negative) and then converting the sum to a non-negative real number is the same as first converting every term in the sequence to a non-negative real number and then summing them.

For any function `f` from a type `α` to `ℝ` with non-negative values, and any `y` being the sum of `f`, the function `Real.toNNReal ∘ f` also has `Real.toNNReal y` as its sum.


theorem CategoryTheory.Functor.op_comp_isSheafOfTypes :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂}
      [inst_1 : CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor C D)
      (J : CategoryTheory.GrothendieckTopology C) (K : CategoryTheory.GrothendieckTopology D)
      [inst_2 : CategoryTheory.Functor.IsContinuous F J K] (G : CategoryTheory.SheafOfTypes K),
      CategoryTheory.Presieve.IsSheaf J (CategoryTheory.Functor.comp F.op G.val) :=
  by sorry

The theorem `CategoryTheory.Functor.op_comp_isSheafOfTypes` states that for any two categories `C` and `D` with respective Grothendieck topologies `J` and `K`, a functor `F` from `C` to `D` that is continuous with respect to these topologies, and a sheaf of types `G` on `D` (with respect to `K`), the composition of the functor's opposite `F.op` with `G.val` is a sheaf on `C` with respect to the topology `J`. This essentially means that applying a continuous functor to a sheaf of types and then taking the opposite results in a sheaf on the original category.

For any continuous functors F from category C with Grothendieck topology J to category D with topology K, the composition of F.op and a sheaf G on D is a sheaf on C with respect to J.


theorem MeasureTheory.condexp_mono :
    ∀ {α : Type u_1} {m m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} {E : Type u_5}
      [inst : NormedLatticeAddCommGroup E] [inst_1 : CompleteSpace E] [inst_2 : NormedSpace ℝ E]
      [inst_3 : OrderedSMul ℝ E] {f g : α → E},
      MeasureTheory.Integrable f μ →
        MeasureTheory.Integrable g μ →
          f ≤ᶠ[MeasureTheory.Measure.ae μ] g →
            MeasureTheory.condexp m μ f ≤ᶠ[MeasureTheory.Measure.ae μ] MeasureTheory.condexp m μ g :=
  by sorry

The theorem `MeasureTheory.condexp_mono` states that for any types `α` and `E`, any measurable spaces `m` and `m0`, any measure `μ` on `α`, and any two functions `f` and `g` from `α` to `E` (where `E` is a complete normed lattice-additive commutative group and a normed space over the real numbers), if `f` and `g` are both integrable with respect to measure `μ` and `f` is almost everywhere less than or equal to `g` (with respect to the measure's almost everywhere filter), then the conditional expectation of `f` is almost everywhere less than or equal to the conditional expectation of `g` (again, with respect to the measure's almost everywhere filter).

If `f` and `g` are integrable functions from a measurable space to a complete normed lattice-additive commutative group, with `f ≤ g` almost everywhere, then `E[f|m] ≤ E[g|m]` almost everywhere with respect to the measure's almost everywhere filter.


theorem Submodule.restrictScalars_injective :
    ∀ (S : Type u_1) (R : Type u_2) (M : Type u_3) [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Semiring S]
      [inst_3 : Module S M] [inst_4 : Module R M] [inst_5 : SMul S R] [inst_6 : IsScalarTower S R M],
      Function.Injective (Submodule.restrictScalars S) :=
  by sorry

The theorem `Submodule.restrictScalars_injective` states that for all Types `S`, `R`, `M`, given a semiring structure on `R`, an additive commutative monoid structure on `M`, a semiring structure on `S`, a module structure over `S` on `M`, a module structure over `R` on `M`, a scalar multiplication of `S` on `R` and a scalar tower of `S`, `R` and `M`, the function `Submodule.restrictScalars S` is injective. In other words, if `Submodule.restrictScalars S` is applied to two objects and gives the same result, then those two objects were already the same. This is a property of how scalar multiplication is restricted to a submodule.

Given a semiring `S`, a semiring `R`, an additive commutative monoid `M` with module structures over `S` and `R`, and a scalar multiplication of `S` on `R`, the restriction of scalar multiplication from `S` to a submodule of `M` is an injective function.


theorem Multiset.recOn_cons :
    ∀ {α : Type u_1} {C : Multiset α → Sort u_3} {C_0 : C 0} {C_cons : (a : α) → (m : Multiset α) → C m → C (a ::ₘ m)}
      {C_cons_heq :
        ∀ (a a' : α) (m : Multiset α) (b : C m),
          HEq (C_cons a (a' ::ₘ m) (C_cons a' m b)) (C_cons a' (a ::ₘ m) (C_cons a m b))}
      (a : α) (m : Multiset α),
      Multiset.recOn (a ::ₘ m) C_0 C_cons C_cons_heq = C_cons a m (Multiset.recOn m C_0 C_cons C_cons_heq) :=
  by sorry

The theorem `Multiset.recOn_cons` is about the recursion on multisets in Lean 4. For any type `α` and a function `C` from multisets of `α` to some type, along with a base case `C_0` for the empty multiset, a construction function `C_cons` for adding an element to a multiset, and a proof `C_cons_heq` of the compatibility of `C_cons` with the equivalence relation on multisets, this theorem states that the recursion on a multiset constructed by adding an element `a` to a multiset `m` is equal to applying `C_cons` to `a`, `m`, and the recursion on `m`. In more intuitive terms, it says that performing the recursion operation on a multiset `a ::ₘ m` is the same as first performing the recursion on `m` and then adding `a` to the result.

For any function `C` from multisets to a type with base case `C_0` and recursion step `C_cons` satisfying `C_cons_heq`, the recursion on a multiset `m` extended by an element `a` is equal to applying `C_cons` to `a`, `m`, and the recursion result on `m`. In mathematical notation: `(C _ _).rec (a ::ₘ m) = C_cons a (C _ m)`.


theorem List.prod_le_prod' :
    ∀ {ι : Type u_1} {M : Type u_5} [inst : Monoid M] [inst_1 : Preorder M]
      [inst_2 : CovariantClass M M (Function.swap fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1]
      [inst_3 : CovariantClass M M (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1] {l : List ι} {f g : ι → M},
      (∀ i ∈ l, f i ≤ g i) → List.prod (List.map f l) ≤ List.prod (List.map g l) :=
  by sorry

The theorem `List.prod_le_prod'` states that for all types `ι` and `M`, where `M` is a monoid and also has a preorder structure, if the multiplication operation in `M` is monotone when two factors are swapped and when they are not, then for any two functions `f` and `g` from `ι` to `M`, and any list `l` of type `ι`, if every element `i` in `l` satisfies the condition `f(i) ≤ g(i)`, then the product of the list resulting from mapping `f` over `l` is less than or equal to the product of the list resulting from mapping `g` over `l`. In simpler terms, the theorem states that if each output of `f` is less than or equal to the corresponding output of `g`, then the product of the outputs of `f` is less than or equal to the product of the outputs of `g`.

If `M` is a monoid with a preorder structure and the multiplication operation is monotone, then for any functions `f` and `g` from a type `ι` to `M`, and any list `l` of type `ι` such that `f(i) ≤ g(i)` for all `i` in `l`, we have `prod (map f l) ≤ prod (map g l)`.


theorem Matrix.smul_eq_diagonal_mul :
    ∀ {m : Type u_2} {n : Type u_3} {α : Type v} [inst : NonUnitalNonAssocSemiring α] [inst_1 : Fintype m]
      [inst_2 : DecidableEq m] (M : Matrix m n α) (a : α), a • M = (Matrix.diagonal fun x => a) * M :=
  by sorry

This theorem states that for any type `m` (indexing the rows) and `n` (indexing the columns), and any type `α` (the type of the matrix entries) where `α` is a non-unital and non-associative semiring, and where `m` is a finite type with decidable equality, given any matrix `M` of type `Matrix m n α` and any scalar 'a' of type `α`, scaling the matrix `M` by `a` (denoted as `a • M`) is equivalent to multiplying a diagonal matrix (where all the diagonal entries are `a`) with the matrix `M`. The diagonal matrix is defined by the function `(Matrix.diagonal fun x => a)`.

For any finite type `m` with decidable equality, type `α` of non-unital and non-associative semiring entries, and matrix `M` of type `Matrix m m α`, scaling `M` by a scalar `a` is equivalent to multiplying `M` with the diagonal matrix of `a`'s.


theorem Finset.sup'_eq_csSup_image :
    ∀ {ι : Type u_1} {α : Type u_2} [inst : ConditionallyCompleteLattice α] (s : Finset ι) (H : s.Nonempty) (f : ι → α),
      Finset.sup' s H f = sSup (f '' ↑s) :=
  by sorry

This theorem states that for any types `ι` and `α`, where `α` is a conditionally complete lattice, and any nonempty finite set `s` of type `ι`, and any function `f` from `ι` to `α`, the sup' of `s` under `f` is equal to the supremum (`sSup`) of the image of `s` under `f`. This means that the greatest element achieved by mapping the elements of the finite set `s` via the function `f` can also be obtained as the supremum of the image set of `s` under `f`.

For any conditionally complete lattice `α`, function `f` from a nonempty finite type `ι` to `α`, and set `s` of type `ι`, the image of the supremum of `s` under `f` is equal to the supremum of the image of `s` under `f`. In other words, `sup (map f s) = sSup`.


theorem le_of_forall_lt_rat_imp_le :
    ∀ {α : Type u_1} [inst : LinearOrderedField α] [inst_1 : Archimedean α] {x y : α},
      (∀ (q : ℚ), y < ↑q → x ≤ ↑q) → x ≤ y :=
  by sorry

This theorem states that for any type `α` that is a linear ordered field and is archimedean, if for every rational number `q` the property holds that whenever `y` is less than `q`, `x` is less or equal to `q`, then it follows that `x` is less or equal to `y`. This is essentially a property about the order relationship between `x` and `y` in the context of any rational number `q`.

For any archimedean linear ordered field `α`, if `x ≤ q` and `y < q` imply `x ≤ y`, then `α` is total ordered.


theorem IsLocalization.Away.mul_invSelf :
    ∀ {R : Type u_1} [inst : CommSemiring R] {S : Type u_2} [inst_1 : CommSemiring S] [inst_2 : Algebra R S] (x : R)
      [inst_3 : IsLocalization.Away x S], (algebraMap R S) x * IsLocalization.Away.invSelf x = 1 :=
  by sorry

The theorem `IsLocalization.Away.mul_invSelf` states that for any commutative semiring `R`, any commutative semiring `S` and any algebra structure from `R` to `S`, and for any element `x` of `R` such that `S` is a localization of `R` at the submonoid generated by `x`, the product of the image of `x` under the algebra's structure map and the inverse of `x` in the localization equals 1. In other words, this theorem establishes that the image of `x` under the algebra's structure map is a unit in the localization, and its inverse is `IsLocalization.Away.invSelf x`. This is analogous to the usual property in field theory that asserts the product of a non-zero element and its multiplicative inverse equals 1.

Given a commutative semiring `R`, a commutative semiring `S`, an algebra structure from `R` to `S`, and an element `x` in `R` such that `S` is a localization of `R` at the submonoid generated by `x`, then the image of `x` under the algebra's structure map and the inverse of `x` in the localization multiply to 1.


theorem Set.indicator_le_self :
    ∀ {α : Type u_2} {M : Type u_4} [inst : CanonicallyOrderedAddCommMonoid M] (s : Set α) (f : α → M),
      Set.indicator s f ≤ f :=
  by sorry

The theorem `Set.indicator_le_self` states that for any type `α` and any canonically ordered additive commutative monoid `M`, for any set `s` of `α` and any function `f` from `α` to `M`, the indicator function of the set `s` with respect to `f` is less than or equal to `f`. In other words, for all elements `x` of type `α`, the value of `Set.indicator s f x` is always less than or equal to the value of `f x`. If `x` belongs to the set `s`, the values are equal; otherwise, the value of the indicator function is zero, which is the least element in a canonically ordered additive commutative monoid.

For any set `s` and function `f`, the indicator function of `s` with respect to `f` in a canonically ordered additive commutative monoid is less than or equal to `f`.


theorem List.card_cons_of_mem :
    ∀ {α : Type u_1} [inst : DecidableEq α] {a : α} {as : List α}, a ∈ as → List.card (a :: as) = List.card as := by
  sorry

The theorem `List.card_cons_of_mem` states that for any type `α` that has decidable equality, given an element `a` of this type and a list `as` of elements of type `α`, if `a` is a member of `as`, then the cardinality (or length) of the list obtained by prepending `a` to `as` is equal to the cardinality of the original list `as`. In other words, if a list already contains an element, adding the same element to the list does not increase its cardinality according to the `List.card` function.

If `α` is a type with decidable equality and `a` is an element of `α` in a list `as`, then `List.card (a :: as) = List.card as`.


theorem DifferentiableWithinAt.add_const :
    ∀ {𝕜 : 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}
      {x : E} {s : Set E},
      DifferentiableWithinAt 𝕜 f s x → ∀ (c : F), DifferentiableWithinAt 𝕜 (fun y => f y + c) s x :=
  by sorry

The theorem `DifferentiableWithinAt.add_const` states that for all types `𝕜` with an instance of a non-trivially normed field, all types `E` and `F` with instances of a normed additive commutative group and a normed space over `𝕜`, any function `f` from `E` to `F`, any point `x` of type `E`, and any set `s` of elements of type `E`, if the function `f` is differentiable at the point `x` within the set `s`, then for any constant `c` of type `F`, the function `(fun y => f y + c)`, which adds the constant `c` to the value of `f` at any point `y`, is also differentiable at the point `x` within the set `s`. In short, this theorem guarantees that adding a constant to a differentiable function does not affect its differentiability.

If a function is differentiable at a point within a set, then the constant-added version of the function is also differentiable at that point within the same set.


theorem Mathlib.Order.BoundedOrder._auxLemma.4 :
    ∀ {α : Type u} [inst : Preorder α] [inst_1 : OrderTop α] {a : α}, (⊤ < a) = False := by sorry

This theorem asserts that for any type `α` which has a Preorder and OrderTop (meaning it has a greatest element denoted by ⊤), and for any instance `a` of `α`, the statement that the greatest element (⊤) is less than `a` is always false. In other words, there is no element in the order that is greater than the greatest element ⊤.

For any type equipped with a Preorder and OrderTop, the greatest element is not less than any other element.


theorem hasDerivAt_zpow :
    ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] (m : ℤ) (x : 𝕜),
      x ≠ 0 ∨ 0 ≤ m → HasDerivAt (fun x => x ^ m) (↑m * x ^ (m - 1)) x :=
  by sorry

The theorem `hasDerivAt_zpow` states that for any nontrivially normed field `𝕜` and any integer `m` and any element `x` of `𝕜`, if `x` is not equal to 0 or `m` is nonnegative, then the function `f(x) = x^m` has a derivative at `x`, and that derivative is `m * x^(m - 1)`. In mathematical notation, this says that if `x ≠ 0` or `m ≥ 0`, then `f'(x) = m * x^(m - 1)`.

For any nontrivially normed field and any nonzero element x and nonnegative integer m, the function f(x) = x^m has derivative f'(x) = m * x^(m-1).


theorem Filter.Tendsto.max_right :
    ∀ {α : Type u} {β : Type v} [inst : TopologicalSpace α] [inst_1 : LinearOrder α] [inst_2 : OrderClosedTopology α]
      {f : β → α} {l : Filter β} {a : α},
      Filter.Tendsto f l (nhds a) → Filter.Tendsto (fun i => max a (f i)) l (nhds a) :=
  by sorry

This theorem states that for any types `α` and `β`, given `α` as a topological space with a linear order that is closed under taking limits (`OrderClosedTopology`), if we have a function `f` from `β` to `α`, a filter `l` on `β`, and a point `a` in `α`, then, if `f` tends to `a` with respect to the filter `l` (i.e., `Filter.Tendsto f l (nhds a)`), then the function that maps each element of the domain to the maximum of `a` and `f` of that element also tends to `a` with respect to the filter `l` (i.e., `Filter.Tendsto (fun i => max a (f i)) l (nhds a)`). In simpler terms, if `f` approaches `a` in the limit, then taking the maximum of `a` and `f` at each point also approaches `a` in the limit.

If `f` tends to `a` with respect to filter `l` in a topological space `α` with an order-closed topology, then the function `g(x) = max(a, f(x))` also tends to `a` with respect to `l` in `α`.


theorem kstar_le_of_mul_le_left :
    ∀ {α : Type u_1} [inst : KleeneAlgebra α] {a b : α}, 1 ≤ b → b * a ≤ b → KStar.kstar a ≤ b := by sorry

The theorem `kstar_le_of_mul_le_left` is a statement about elements in a Kleene algebra, which is represented by the type variable `α`. Given any two elements `a` and `b` of this Kleene algebra, the theorem states that if the unit element `1` is less than or equal to `b` and the product `b * a` is also less than or equal to `b`, then it follows that the Kleene star of `a` (denoted by `KStar.kstar a`) is less than or equal to `b`. The Kleene star operation is a unary operation widely used in the theory of formal languages and automata, which in this context can be seen as a kind of "closure" operation.

If `1 ≤ b` and `b * a ≤ b` hold in a Kleene algebra, then `KStar.kstar a ≤ b`.


theorem Mathlib.MeasureTheory.Function.SimpleFunc._auxLemma.1 :
    ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] {f : MeasureTheory.SimpleFunc α β} {b : β},
      (b ∈ MeasureTheory.SimpleFunc.range f) = (b ∈ Set.range ↑f) :=
  by sorry

The theorem `Mathlib.MeasureTheory.Function.SimpleFunc._auxLemma.1` establishes an equivalence between the range of a simple function `f` in measure theory and the set range of `f`. More specifically, for any types `α` and `β`, given a measurable space instance on `α` and a simple function `f` from `α` to `β`, and any element `b` of `β`, it states that `b` is in the range of `f` (as defined in measure theory) if and only if `b` is in the set range of `f`.

For any measurable simple function $f$ from type $\alpha$ to type $\beta$ in measure theory, the range of $f$ equals the set range of $f$.


theorem MeasureTheory.IsStoppingTime.measurableSet_eq :
    ∀ {Ω : Type u_1} {ι : Type u_3} {m : MeasurableSpace Ω} [inst : LinearOrder ι] {f : MeasureTheory.Filtration ι m}
      {τ : Ω → ι} [inst_1 : TopologicalSpace ι] [inst_2 : OrderTopology ι] [inst_3 : FirstCountableTopology ι],
      MeasureTheory.IsStoppingTime f τ → ∀ (i : ι), MeasurableSet {ω | τ ω = i} :=
  by sorry

The theorem `MeasureTheory.IsStoppingTime.measurableSet_eq` states that for any types `Ω` and `ι`, any measurable space `m` on `Ω`, any linear order on `ι`, any filtration `f` of `m` over `ι`, any function `τ` from `Ω` to `ι`, and assuming that `ι` is a topological space with an order topology and a first countable topology, if `τ` is a stopping time with respect to the filtration `f`, then for every `i` in `ι`, the set of all `ω` in `Ω` such that `τ(ω)` equals `i` is a measurable set.

In more intuitive terms, this theorem asserts that under the given conditions, if `τ` describes a rule that determines when to stop a given process at any given time using the information we have at that time, then for every possible stopping time, the set of all outcomes that would cause us to stop at that time is a measurable set, i.e., a set to which we can meaningfully assign a probability.

If `τ: Ω -> ι` is a stopping time with respect to filtration `f` on measurable space `(Ω, m)` over linear order `ι`, with `ι` being a topological space with an order topology and first countable topology, then for every `i` in `ι`, the set `{ω | τ(ω) = i}` is measurable.


theorem Filter.blimsup_eq_iInf_biSup :
    ∀ {α : Type u_1} {β : Type u_2} [inst : CompleteLattice α] {f : Filter β} {p : β → Prop} {u : β → α},
      Filter.blimsup u f p = ⨅ s ∈ f, ⨆ b, ⨆ (_ : p b ∧ b ∈ s), u b :=
  by sorry

The theorem `Filter.blimsup_eq_iInf_biSup` states that for any complete lattice `α`, any filter `f` on `β`, any predicate `p` on `β`, and any function `u` from `β` to `α`, the bounded limit superior (`blimsup`) of the function `u` along the filter `f` and bounded by the predicate `p` is equal to the infimum over all sets `s` in the filter `f`, of the supremum over all elements `b` such that `p b` and `b` is in `s`, of `u b`. In other words, the bounded limit superior of `u` is the least upper bound of the set of all `u b` where `b` satisfies `p` and `b` is in some set `s` from the filter `f`.

The bounded limit superior of a function along a filter, with respect to a predicate, equals the infimum of sets in the filter, where each set's supremum is the function's value at an element satisfying the predicate.


ApplicativeTransformation.ext

theorem ApplicativeTransformation.ext :
    ∀ {F : Type u → Type v} [inst : Applicative F] {G : Type u → Type w} [inst_1 : Applicative G]
      ⦃η η' : ApplicativeTransformation F G⦄,
      (∀ (α : Type u) (x : F α), (fun {α} => η.app α) x = (fun {α} => η'.app α) x) → η = η' :=
  by sorry

This theorem called `ApplicativeTransformation.ext` states that for any two Applicative Transformations `η` and `η'` from an applicative functor `F` to another applicative functor `G`, if for all types `α` and for all elements `x` of type `F α`, the application of `η` to `x` is equal to the application of `η'` to `x`, then `η` must be equal to `η'`. In simpler terms, if two Applicative Transformations behave the same way for all inputs, they must be the same transformation.

If two applicative functor transformations η and η' from F to G satisfy η(x) = η'(x) for all x : F α, then η = η'.


theorem AddMonoid.Coprod.swap_injective :
    ∀ {M : Type u_1} {N : Type u_2} [inst : AddZeroClass M] [inst_1 : AddZeroClass N],
      Function.Injective ⇑(AddMonoid.Coprod.swap M N) :=
  by sorry

The theorem `AddMonoid.Coprod.swap_injective` states that for any types `M` and `N` that are instances of the `AddZeroClass`, the function `AddMonoid.Coprod.swap M N`, which swaps the components in the coproduct of `M` and `N`, is injective. In mathematical terms, this means if we have two elements from the coproduct of `M` and `N` and applying the `AddMonoid.Coprod.swap` function to them gives the same result, then the two original elements from the coproduct were the same. This injectivity property is important in many areas of abstract algebra.

If `M` and `N` are instances of `AddZeroClass`, then the function swapping components in the coproduct of `M` and `N` (`AddMonoid.Coprod.swap M N`) is an injection.


theorem ProbabilityTheory.kernel.comp_eq_snd_compProd :
    ∀ {α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {γ : Type u_4}
      {mγ : MeasurableSpace γ} (η : ↥(ProbabilityTheory.kernel β γ)) [inst : ProbabilityTheory.IsSFiniteKernel η]
      (κ : ↥(ProbabilityTheory.kernel α β)) [inst : ProbabilityTheory.IsSFiniteKernel κ],
      ProbabilityTheory.kernel.comp η κ =
        ProbabilityTheory.kernel.snd (ProbabilityTheory.kernel.compProd κ (ProbabilityTheory.kernel.prodMkLeft α η)) :=
  by sorry

This theorem in probability theory, `ProbabilityTheory.kernel.comp_eq_snd_compProd`, states that for any measurable spaces `α`, `β`, and `γ`, and any σ-finite kernels `η` in `ProbabilityTheory.kernel β γ` and `κ` in `ProbabilityTheory.kernel α β`, the composition of the two kernels `η` and `κ` is equivalent to the kernel obtained by taking the second element from the product kernel of `κ` and the kernel obtained by changing the domain of `η` from `α` to `(γ × α)` (i.e., `ProbabilityTheory.kernel.prodMkLeft α η`). This is essentially a statement about the interchangeability of certain operations in the context of measure and probability theory.

For any σ-finite measurable kernels η from β to γ and κ from α to β in probability theory, the composition of η and κ is equal to the product kernel of κ with η viewed as a kernel from α to γ.


theorem pow_eq_pow_iff_modEq :
    ∀ {G : Type u_1} [inst : LeftCancelMonoid G] {x : G} {m n : ℕ}, x ^ n = x ^ m ↔ n ≡ m [MOD orderOf x] := by sorry

This theorem named `pow_eq_pow_iff_modEq` states that for any type `G` that has an instance of `LeftCancelMonoid`, for any element `x` of `G`, and for any natural numbers `m` and `n`, the power of `x` raised to `n` equals the power of `x` raised to `m` if and only if `n` is congruent to `m` modulo the order of `x`. In other words, two exponents yield the same power of an element if and only if they are equivalent when divided by the order of the element, taking the remainder.

For any element x of a left cancelable monoid G and natural numbers m and n, x^n = x^m if and only if n is congruent to m modulo the order of x.


theorem MonoidHom.ext_mnat :
    ∀ {α : Type u_1} [inst : Monoid α] ⦃f g : Multiplicative ℕ →* α⦄,
      f (Multiplicative.ofAdd 1) = g (Multiplicative.ofAdd 1) → f = g :=
  by sorry

This theorem states that for any type `α` that forms a Monoid, two monoid homomorphisms `f` and `g` from `Multiplicative ℕ` to `α` are equal if they map the element `1` (reinterpreted multiplicatively) to the same value. In other words, the identity of the monoid homomorphisms is determined by their value at `1` in the natural numbers under the multiplicative interpretation.

If `f` and `g` are monoid homomorphisms from the multiplicative monoid of natural numbers to a monoid `α`, then `f = g` if and only if `f 1 = g 1`.


theorem Nat.card_pos_iff : ∀ {α : Type u_1}, 0 < Nat.card α ↔ Nonempty α ∧ Finite α := by sorry

The theorem `Nat.card_pos_iff` states that for any type `α`, the cardinality of `α` as a natural number is greater than 0 if and only if `α` is nonempty and finite. In other words, this theorem establishes a bi-conditional relationship between a type `α` having positive cardinality and the type `α` being nonempty and finite.

A type `α` has a positive natural number of elements if and only if it is nonempty and finite.


theorem Finset.prod_eq_multiset_prod :
    ∀ {α : Type u_3} {β : Type u_4} [inst : CommMonoid β] (s : Finset α) (f : α → β),
      (Finset.prod s fun x => f x) = Multiset.prod (Multiset.map f s.val) :=
  by sorry

The theorem `Finset.prod_eq_multiset_prod` states that for any given finite set `s` of type `α` and a function `f` from `α` to `β` where `β` forms a commutative monoid, the product of `f(x)` for each `x` in the set `s` (represented as `Finset.prod s f`) is equal to the product of the multiset obtained by mapping the function `f` over the underlying multiset of the finite set `s` (represented as `Multiset.prod (Multiset.map f s.val)`). In other words, calculating the product over a finite set using a function is equivalent to mapping the function over the set first and then taking the product.

For any commutative monoid type `β` and a finite set `s` of type `α` along with a function `f` from `α` to `β`, the product of `f(x)` for all `x` in `s` equals the product of the multiset obtained by mapping `f` over the underlying multiset of `s`.


theorem Complex.abs_le_sqrt_two_mul_max : ∀ (z : ℂ), Complex.abs z ≤ Real.sqrt 2 * max |z.re| |z.im| := by sorry

This theorem states that for every complex number `z`, the absolute value of `z` is less than or equal to the square root of 2 multiplied by the maximum of the absolute values of the real and imaginary parts of `z`. In other words, the magnitude of a complex number is always less than or equal to the square root of 2 times the maximum of the magnitudes of its real and imaginary components.

For every complex number z, |z| ≤ √2 max {|Re z|, |Im z|} where |z| denotes the absolute value of z and Re z and Im z represent the real and imaginary parts, respectively.


theorem Continuous.path_eval :
    ∀ {X : Type u_1} [inst : TopologicalSpace X] {x y : X} {Y : Type u_4} [inst_1 : TopologicalSpace Y]
      {f : Y → Path x y} {g : Y → ↑unitInterval}, Continuous f → Continuous g → Continuous fun y_1 => (f y_1) (g y_1) :=
  by sorry

The theorem `Continuous.path_eval` asserts that for any topological spaces `X` and `Y`, given two points `x` and `y` in `X`, a function `f` from `Y` to the set of paths from `x` to `y`, and a function `g` from `Y` to the unit interval `[0,1]` in ℝ, if both `f` and `g` are continuous, then the function that maps each element of `Y` to the point on the path `f(y_1)` at the parameter value `g(y_1)` is also continuous. This essentially states the continuity of path evaluation under certain conditions.

Given continuous functions `f : Y → X → Path p x y` and `g : Y → [0, 1]` from a topological space `Y` to a path `p : X → X` between points `x` and `y` in a topological space `X`, the function `h : Y → X` defined by `h(y) = f(y)(g(y))` is continuous.


theorem closure_diff_interior :
    ∀ {X : Type u} [inst : TopologicalSpace X] (s : Set X), closure s \ interior s = frontier s := by sorry

The theorem `closure_diff_interior` states that for any set `s` in a given topological space `X`, the difference between the closure of `s` and the interior of `s` is equal to the frontier of `s`. In other words, the set of all points that are either in the closure of `s` but not in its interior defines the frontier of `s`. Here, the closure of a set is the smallest closed set containing it, the interior of a set is its largest open subset, and the frontier of a set includes all points between its closure and interior.

The closure of a set in a topological space equals the union of its interior and frontier, and the difference between the two is the frontier.


theorem Absorbs.exists_pos :
    ∀ {𝕜 : Type u_1} {E : Type u_3} [inst : SeminormedRing 𝕜] [inst_1 : SMul 𝕜 E] {A B : Set E},
      Absorbs 𝕜 A B → ∃ r > 0, ∀ (c : 𝕜), r ≤ ‖c‖ → B ⊆ c • A :=
  by sorry

The theorem `Absorbs.exists_pos` states that given any two sets `A` and `B` of elements of a type `E`, under the conditions that `𝕜` is a seminormed ring and `E` has scalar multiplication by `𝕜`, if `A` absorbs `B`, then there exists a positive number `r` such that for all elements `c` of `𝕜`, if `r` is less than or equal to the seminorm of `c`, then `B` is a subset of the scalar multiple of `A` by `c`. Essentially, the theorem guarantees the existence of a positive lower bound that scales `A` to include `B` under the seminormed ring multiplication operation.
Here, "absorption" is defined in terms of a concept from topology called "bornology", where `A` absorbs `B` if `B` is contained in all scalings of `A` except those by a bounded set of elements.

Given a seminormed ring `𝕜` and sets `A` and `B` in the module `E` over `𝕜`, if `A` absorbs `B` in the bornology sense, then there exists a positive number `r` such that `B` is contained in the scalar multiples of `A` by elements of `𝕜` with seminorm less than or equal to `r`.


theorem mulRothNumber_spec :
    ∀ {α : Type u_2} [inst : DecidableEq α] [inst_1 : Monoid α] (s : Finset α),
      ∃ t, ∃ (_ : t ⊆ s), t.card = mulRothNumber s ∧ MulSalemSpencer ↑t :=
  by sorry

The theorem `mulRothNumber_spec` asserts that for all types `α` with decidable equality and monoid structure, and for any finite set `s` of type `α`, there exists a subset `t` of `s` such that the cardinality of `t` equals the multiplicative Roth number of `s` and `t` is a multiplicative Salem-Spencer set. A multiplicative Salem-Spencer set is a set where the product of any two distinct elements cannot be the square of any element in the set. The multiplicative Roth number of a set is defined as the size of its largest multiplicative Salem-Spencer subset.

For any finite set `s` with type `α` having decidable equality and monoid structure, there exists a multiplicative Salem-Spencer subset `t` of `s` with the same cardinality as the multiplicative Roth number of `s`, such that the pairwise products of distinct elements in `t` are not squares of elements in `t`.


TopologicalSpace.OpenNhdsOf.mem

theorem TopologicalSpace.OpenNhdsOf.mem :
    ∀ {α : Type u_2} [inst : TopologicalSpace α] {x : α} (U : TopologicalSpace.OpenNhdsOf x), x ∈ U := by sorry

This theorem states that for every open neighborhood `U` of a point `x` in a given topological space, `x` is always an element of `U`. Here, `α` is any type, which is equipped with the structure of a topological space. The `TopologicalSpace.OpenNhdsOf x` represents the collection of all open neighborhoods of `x`. The theorem ensures that any point is always contained within its own open neighborhoods in any topological space.

For every point `x` in any topological space `α`, and every open neighborhood `U` of `x`, we have `x ∈ U`.


theorem continuous_finset_prod :
    ∀ {ι : Type u_1} {M : Type u_3} {X : Type u_5} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace M]
      [inst_2 : CommMonoid M] [inst_3 : ContinuousMul M] {f : ι → X → M} (s : Finset ι),
      (∀ i ∈ s, Continuous (f i)) → Continuous fun a => Finset.prod s fun i => f i a :=
  by sorry

This theorem states that for any types `ι`, `M`, and `X`, when `X` and `M` have topological space structures, `M` has a commutative monoid structure, and multiplication on `M` is continuous, if we have a function `f` from type `ι` and `X` to `M` and a finite set `s` of elements of type `ι`, if for every element `i` in `s`, the function `f i` is continuous, then the function which takes an element `a` and sends it to the product over all `i` in `s` of `f i a` is also continuous. In mathematical terms, if $(f_i:X \rightarrow M)$ are continuous functions for all $i$ in a finite set, then the function $a \mapsto \prod_{i \in s} f_i(a)$ is also continuous.

If `f:` ι × X → M is a continuous function whose components are all continuous functions from X to a commutative monoid M with continuous multiplication, then the function sending x to ∏i in s (fi x) is continuous.


theorem Set.mem_of_mem_inter_left : ∀ {α : Type u} {x : α} {a b : Set α}, x ∈ a ∩ b → x ∈ a := by sorry

The theorem `Set.mem_of_mem_inter_left` states that for any type `α`, any element `x` of `α`, and any two sets `a` and `b` of type `α`, if `x` belongs to the intersection of `a` and `b`, then `x` also belongs to `a`. In other words, if an element is in both `a` and `b`, it is definitely in `a`.

If `a` and `b` are sets and `x` is an element belonging to `a ∩ b`, then `x` is also an element of `a`.


theorem MulEquiv.symm_symm :
    ∀ {M : Type u_6} {N : Type u_7} [inst : Mul M] [inst_1 : Mul N] (f : M ≃* N), MulEquiv.symm (MulEquiv.symm f) = f :=
  by sorry

The theorem `MulEquiv.symm_symm` states that for any two types `M` and `N` which have a multiplication operation defined (denoted by `Mul M` and `Mul N` respectively), if there exists a multiplicative equivalence (isomorphism) `f` from type `M` to `N`, then the inverse of the inverse of this isomorphism `f` is equivalent to the original isomorphism `f`. In mathematical terms, this means if we have an isomorphism f : M -> N, then (f^{-1})^{-1} = f.

If `f : M -> N` is a multiplicative equivalence between types `M` and `N`, then `f = (f^-\^{}-1)^-1`.


theorem Submodule.mem_iSup_of_directed :
    ∀ {R : Type u_1} {M : Type u_4} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {ι : Sort u_9}
      [inst_3 : Nonempty ι] (S : ι → Submodule R M),
      Directed (fun x x_1 => x ≤ x_1) S → ∀ {x : M}, x ∈ iSup S ↔ ∃ i, x ∈ S i :=
  by sorry

This theorem states that for any semiring `R`, an additive commutative monoid `M`, a module structure on `M` over `R`, and an indexed family `S` of submodules of `M` over `R` that is directed with respect to the inclusion relation (i.e., for any two submodules in the family, there is another submodule in the family that contains both), a module element `x` belongs to the indexed supremum of the family `S` if and only if there exists an index `i` such that `x` belongs to the submodule `S i`.

For any semiring `R`, an additive commutative monoid `M` with an `R`-module structure, and an indexed family `S` of `R`-submodules of `M` directed by inclusion, an element `x` of `M` lies in the supremum of `S` if and only if it belongs to some submodule in `S`.


theorem Real.le_sqrt_of_sq_le : ∀ {x y : ℝ}, x ^ 2 ≤ y → x ≤ Real.sqrt y := by sorry

This theorem states that for any two real numbers `x` and `y`, if the square of `x` is less than or equal to `y`, then `x` is less than or equal to the square root of `y`. In mathematical terms, it would be expressed as: for all $x, y \in \mathbb{R}$, if $x^2 \leq y$, then $x \leq \sqrt{y}$. This theorem establishes a relationship between the square of a number and the square root of another number in the context of inequality.

For all real numbers x and y, if x^2 ≤ y then x ≤ √y.


theorem Finset.subset_empty : ∀ {α : Type u_1} {s : Finset α}, s ⊆ ∅ ↔ s = ∅ := by sorry

This theorem states that for all types `α` and all finite sets `s` of type `α`, `s` is a subset of the empty set if and only if `s` is equal to the empty set. In other words, the only finite set that can be a subset of the empty set is the empty set itself.

A finite set is a subset of the empty set if and only if it is equal to the empty set.


theorem Polynomial.support_scaleRoots_le :
    ∀ {R : Type u_1} [inst : Semiring R] (p : Polynomial R) (s : R),
      Polynomial.support (Polynomial.scaleRoots p s) ≤ Polynomial.support p :=
  by sorry

This theorem states that for any polynomial `p` and scalar `s`, from a semiring `R`, the support (the set of all exponents `n` in the polynomial where the coefficient of `X^n` is non-zero) of the polynomial obtained by scaling the roots of `p` by `s` is a subset of or equal to the support of the original polynomial `p`. In other words, the support of the scaled polynomial is less than or equal to the support of the original polynomial. This result ensures that scaling the roots of a polynomial does not introduce any new non-zero coefficients at exponents that were not present in the original polynomial.

The support of a polynomial obtained by scaling its roots is a subset of the support of the original polynomial in any semiring.


theorem Monotone.iSup_nat_add :
    ∀ {α : Type u_1} [inst : CompleteLattice α] {f : ℕ → α}, Monotone f → ∀ (k : ℕ), ⨆ n, f (n + k) = ⨆ n, f n := by
  sorry

This theorem states that for any type `α` that forms a complete lattice, and any function `f` mapping natural numbers to elements of `α`, if `f` is a monotone function, then for any natural number `k`, the supremum of the set `{f(n + k) | n ∈ ℕ}` is the same as the supremum of the set `{f(n) | n ∈ ℕ}`. In other words, if you have a monotone function from the natural numbers to a complete lattice, then adding a constant to the input of the function doesn't change the supremum of the function's values.

Let `α` be a complete lattice and `f : ℕ → α` be a monotone function; then for all natural numbers `k`, the supremum of `{f(n + k) | n ∈ ℕ}` equals the supremum of `{f(n) | n ∈ ℕ}`.


theorem differentiable_circleMap : ∀ (c : ℂ) (R : ℝ), Differentiable ℝ (circleMap c R) := by sorry

The theorem `differentiable_circleMap` states that for any complex number `c` and any real number `R`, the function `circleMap` is differentiable with respect to the real numbers. The `circleMap` function represents the exponential map in the complex plane, mapping a real number `θ` to a point on a circle with center `c` and radius `|R|`. The differentiability of this function is fundamental to understanding the behavior of the function's output as the input `θ` changes infinitesimally.

The exponential map in the complex plane, represented by the `circleMap` function with center `c` and radius `R`, is differentiable as a function from the real numbers to the complex numbers.


/-- If `i` is an `F`-algebra homomorphism from `E` to `K`, then `i x` is contained in
`separableClosure F K` if and only if `x` is contained in `separableClosure F E`.  -/
theorem map_mem_separableClosure_iff :
    ∀ {F : Type u} {E : Type v} [inst : Field F] [inst_1 : Field E] [inst_2 : Algebra F E] {K : Type w}
      [inst_3 : Field K] [inst_4 : Algebra F K] (i : E →ₐ[F] K) {x : E},
      i x ∈ separableClosure F K ↔ x ∈ separableClosure F E :=
  by sorry

This theorem states that for any field `F` and any two other fields `E` and `K` where `E` and `K` are both `F`-algebras, if there exists an algebra homomorphism `i` from `E` to `K`, then an element `x` from `E` is contained in the separable closure of `F` in `K` (or, in other words, `i x` is in the separable closure of `F` in `K`) if and only if `x` is itself contained in the separable closure of `F` in `E`. In mathematical terms, this theorem asserts the compatibility of algebra homomorphisms with the operation of taking separable closures.

If `F` is a field, `E` and `K` are `F`-algebras, and there exists an algebra homomorphism from `E` to `K`, then for any element `x` in `E`, `x` is in the separable closure of `F` in `E` if and only if `i(x)` is in the separable closure of `F` in `K`.


theorem Set.ncard_coe_Finset : ∀ {α : Type u_1} (s : Finset α), Set.ncard ↑s = s.card := by sorry

This theorem states that for any finite set `s` of type `α`, the cardinality of `s` when it's considered as a general set (by means of the coercion operator `↑s`) equals to the cardinality of `s` as a finite set. In other words, the cardinality operation on a finite set `s`, as performed by `Set.ncard`, gives the same result as the cardinality operation on `s` as a `Finset`, performed by the `.card` function. This theorem bridges the two different views of a finite set, one as a general set and the other as a `Finset` in Lean 4.

For any finite set `s` of type `α` in Lean 4, the cardinality of `s` as a general set is equal to the cardinality of `s` considered as a `Finset`.


PseudoMetricSpace.ext

/-- Two pseudo metric space structures with the same distance function coincide.  -/
theorem PseudoMetricSpace.ext :
    ∀ {α : Type u_3} {m m' : PseudoMetricSpace α}, PseudoMetricSpace.toDist = PseudoMetricSpace.toDist → m = m' := by
  sorry

This theorem states that for any type `α`, if we have two pseudo metric space structures `m` and `m'` defined on it, and the distance function (`toDist`) of both these structures are the same, then the two structures `m` and `m'` are indeed the same. In other words, two pseudo metric space structures defined on the same type are completely determined by their distance functions. If the distance functions are equal, then the pseudo metric space structures are also equal.

If two pseudo metric spaces defined on the same type have equal distance functions, then they are equal as pseudo metric spaces.


theorem MeasureTheory.integrable_rnDeriv_smul_iff :
    ∀ {α : Type u_3} {m : MeasurableSpace α} {μ ν : MeasureTheory.Measure α} {E : Type u_4}
      [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E]
      [inst_2 : MeasureTheory.Measure.HaveLebesgueDecomposition μ ν],
      MeasureTheory.Measure.AbsolutelyContinuous μ ν →
        ∀ [inst_3 : MeasureTheory.SigmaFinite μ] {f : α → E},
          MeasureTheory.Integrable (fun x => (μ.rnDeriv ν x).toReal • f x) ν ↔ MeasureTheory.Integrable f μ :=
  by sorry

The theorem `MeasureTheory.integrable_rnDeriv_smul_iff` states that for any measure space `α`, a measure `μ`, another measure `ν`, a normed commutative additive group `E` which is also a normed space over the real numbers, and a function `f` from `α` to `E`, if `μ` is absolutely continuous with respect to `ν` and `μ` has a Lebesgue decomposition with respect to `ν`, then the function `f` scaled by the Radon-Nikodym derivative of `μ` with respect to `ν` is integrable with respect to `ν` if and only if `f` is integrable with respect to `μ`. Here, absolute continuity means that if a set has `ν`-measure zero, then it also has `μ`-measure zero. And integrability means that the function is both almost-everywhere strongly measurable and has a finite integral.

For a measure space with absolutely continuous and Lebesgue decomposable measures μ and ν, and a function f from the measure space to a normed real vector space, the derivative of μ with respect to ν and the function f are interchangeable in integrability, i.e., f is integrable with respect to μ if and only if the scaled function f * (dμ/dν) is integrable with respect to ν.


theorem Int.natAbs_add_le : ∀ (a b : ℤ), Int.natAbs (a + b) ≤ Int.natAbs a + Int.natAbs b := by sorry

The theorem `Int.natAbs_add_le` states that for any two integers `a` and `b`, the absolute value of their sum is less than or equal to the sum of their absolute values. In other words, given any two integers, the absolute value of their sum doesn't exceed the sum of their individual absolute values. This is represented mathematically as `|a + b| ≤ |a| + |b|`, where `|x|` denotes the absolute value of `x`.

The absolute value of the sum of two integers is less than or equal to the sum of their absolute values. | |a| + |b| ≤ |a + b|.


theorem WittVector.truncate_comp_lift :
    ∀ {p : ℕ} [hp : Fact (Nat.Prime p)] (n : ℕ) {R : Type u_1} [inst : CommRing R] {S : Type u_2} [inst_1 : Semiring S]
      {f : (k : ℕ) → S →+* TruncatedWittVector p k R}
      (f_compat : ∀ (k₁ k₂ : ℕ) (hk : k₁ ≤ k₂), RingHom.comp (TruncatedWittVector.truncate hk) (f k₂) = f k₁),
      RingHom.comp (WittVector.truncate n) (WittVector.lift (fun k₂ => f k₂) f_compat) = f n :=
  by sorry

The theorem `WittVector.truncate_comp_lift` states that for a given prime number `p`, a natural number `n`, a commutative ring `R`, a semiring `S`, and a family of ring homomorphisms `f` from `S` to the set of truncated Witt vectors of `R` with varying lengths, if the homomorphisms `f` are compatible (i.e., composing `f` at length `k₂` with the truncation function from length `k₂` to `k₁` yields `f` at length `k₁`), then composing the function that lifts the family `f` to a ring homomorphism on the Witt vectors of `R` with the truncation function to length `n` is equivalent to the ring homomorphism `f` at length `n`. This theorem essentially states the compatibility of the lift operation with the truncation operation in the context of Witt vectors.

Given a prime number `p`, a natural number `n`, a commutative ring `R`, a semiring `S`, and a family of ring homomorphisms `f` from `S` to the truncated Witt vectors of `R` with compatible lengths, the lift of `f` to a ring homomorphism on the Witt vectors of `R` and the truncation function to length `n` are equal.


theorem abs_sup_sub_sup_le_abs :
    ∀ {α : Type u_1} [inst : Lattice α] [inst_1 : AddCommGroup α]
      [inst_2 : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] (a b c : α),
      |a ⊔ c - b ⊔ c| ≤ |a - b| :=
  by sorry

This theorem states that for any type `α` that is a lattice and an additive commutative group, and also has the covariance property with respect to addition and ordering, the absolute difference between the supremum (or join) of `a` and `c` and the supremum of `b` and `c` is less than or equal to the absolute difference between `a` and `b`. This means the impact of the supremum operation combined with subtraction on `a`, `b`, and `c` does not increase the absolute difference between `a` and `b`.

For any lattice, additive commutative group `α` with covariance property for addition and ordering, |sup(a, c) - sup(b, c)| ≤ |a - b|.


theorem AddLECancellable.add_le_add_iff_left :
    ∀ {α : Type u_1} [inst : LE α] [inst_1 : Add α]
      [inst_2 : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] {a b c : α},
      AddLECancellable a → (a + b ≤ a + c ↔ b ≤ c) :=
  by sorry

The theorem `AddLECancellable.add_le_add_iff_left` states that for any type `α` equipped with an addition operation and a less than or equal to order relation, and for any elements `a`, `b`, `c` of that type, if `a` is `AddLECancellable` (meaning the function `x ↦ a + x` is order-reflecting or, in other words, for all `b` and `c`, if `a + b` is less than or equal to `a + c`, then `b` is less than or equal to `c`), then `a + b` is less than or equal to `a + c` if and only if `b` is less than or equal to `c`.

For any AddLECancellable element `a` in a type with addition and order relation, `a + b` is less than or equal to `a + c` if and only if `b` is less than or equal to `c`.


theorem Set.setOf_mem_eq : ∀ {α : Type u} {s : Set α}, {x | x ∈ s} = s := by sorry

This theorem states that for all types `α` and for all sets `s` of type `α`, the set of all elements `x` such that `x` is a member of `s` is equal to `s` itself. In other words, if we construct a set by collecting all the elements from a given set, we end up with the original set. This is a fundamental property of sets that is being formally stated and proven in the Lean 4 theorem prover.

For all types `α` and sets `s` of type `α`, `s` is equal to the set of its elements.


Continuous.vsub

theorem Continuous.vsub :
    ∀ {α : Type u_1} {V : Type u_2} {P : Type u_3} [inst : SeminormedAddCommGroup V] [inst_1 : PseudoMetricSpace P]
      [inst_2 : NormedAddTorsor V P] [inst_3 : TopologicalSpace α] {f g : α → P},
      Continuous f → Continuous g → Continuous (f -ᵥ g) :=
  by sorry

This theorem states that for any types `α`, `V`, and `P`, if `V` is a semi-normed additive commutative group, `P` is a pseudo metric space, and `V` is a normed add-torsor over `P`, and if `α` is a topological space, then for any two functions `f` and `g` from `α` to `P`, if both `f` and `g` are continuous, then their group difference (defined as `f -ᵥ g`) is also continuous. This theorem is a statement about the continuity of the difference of two continuous functions in the context of normed add-torsors.

If `V` is a normed add-torsor over a pseudo metric space `P`, and `α` is a topological space, then for any two continuous functions `f` and `g` from `α` to `P`, their group difference `f -ᵥ g` is also continuous.


theorem MeasureTheory.upperCrossingTime_succ :
    ∀ {Ω : Type u_1} {ι : Type u_2} [inst : Preorder ι] [inst_1 : OrderBot ι] [inst_2 : InfSet ι] {a b : ℝ}
      {f : ι → Ω → ℝ} {N : ι} {n : ℕ} {ω : Ω},
      MeasureTheory.upperCrossingTime a b f N (n + 1) ω =
        MeasureTheory.hitting f (Set.Ici b)
          (MeasureTheory.lowerCrossingTimeAux a f (MeasureTheory.upperCrossingTime a b f N n ω) N ω) N ω :=
  by sorry

The theorem `MeasureTheory.upperCrossingTime_succ` states that for any set of real numbers Ω, an ordered type ι with a least element (OrderBot) and an InfSet structure, a pair of real numbers `a` and `b`, a function `f` from ι and Ω to ℝ, a value `N` of type ι, a natural number `n` and an element `ω` of Ω, the upper crossing time of `f` at level `b` after time `N` and `n + 1` times at the point `ω` is equal to the first time `f` reaches or exceeds `b` after the first time `f` drops below `a` after the `n`-th upper crossing time of `f` at level `b` after time `N` at the point `ω` but before time `N`.

For any function `f` from an ordered type `ι` and a set of real numbers `Ω` to ℝ, the `(n+1)`-th upper crossing time of `f` at level `b` after time `N` at point `ω` is the first time after the last upper crossing before `N` that `f(x) ≥ b` for some `x > N` such that `f(x) < a`, where `a ≤ b` and `N, ω ∈ Ω`.


theorem Asymptotics.isBigOWith_self_const_mul' :
    ∀ {α : Type u_1} {R : Type u_13} [inst : SeminormedRing R] (u : Rˣ) (f : α → R) (l : Filter α),
      Asymptotics.IsBigOWith ‖↑u⁻¹‖ l f fun x => ↑u * f x :=
  by sorry

This theorem states that for any non-zero scalar `u` in a seminormed ring `R`, any function `f` from type `α` to `R`, and any filter `l` on `α`, the function `f` is Big-O of the function `g(x) = u * f(x)` with respect to `l`, where the constant of the Big-O notation is the norm of the inverse of `u`. In other words, the norm of `f` is eventually bounded by the norm of the inverse of `u` times the norm of `g(x) = u * f(x)` for values in the filter `l`.

For any non-zero scalar `u` in a seminormed ring `R`, and for any function `f : α → R` and filter `l` on `α`, the norm of `f` is eventually dominated by the constant `(|u|⁻¹ * |u| * |f|)` as `x` approaches elements in the filter `l`.


theorem LieModule.antitone_lowerCentralSeries :
    ∀ (R : Type u) (L : Type v) (M : Type w) [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L]
      [inst_3 : AddCommGroup M] [inst_4 : Module R M] [inst_5 : LieRingModule L M],
      Antitone (LieModule.lowerCentralSeries R L M) :=
  by sorry

This theorem states that the lower central series of Lie submodules of a Lie module, defined over a commutative ring, a Lie ring, and an abelian additive group, is an antitone function. In simpler terms, if `k ≤ l` for natural numbers `k` and `l`, then `LieModule.lowerCentralSeries R L M l ≤ LieModule.lowerCentralSeries R L M k`. This means that as we move up in the sequence (increasing the natural number), the corresponding Lie submodules in the lower central series become smaller or stay the same.

The lower central series of a Lie module over a commutative ring is an antitone function with respect to the natural number indices.


theorem Valuation.extendToLocalization.proof_2 :
    ∀ {A : Type u_1} [inst : CommRing A] {Γ : Type u_2} [inst_1 : LinearOrderedCommGroupWithZero Γ] (v : Valuation A Γ)
      {S : Submonoid A}, S ≤ Ideal.primeCompl (Valuation.supp v) → ∀ (s : ↥S), IsUnit (↑v.toMonoidWithZeroHom ↑s) :=
  by sorry

This theorem states that for any commutative ring `A`, any linearly ordered commutative group with zero `Γ`, any valuation `v` from `A` to `Γ`, and any submonoid `S` of `A`, if `S` is a subset of the complement of the prime ideal which is the support of `v`, then for any element `s` in `S`, the valuation of `s` is a unit. In other words, when a submonoid of a commutative ring is contained within the complement of the prime ideal formed by the vanishing points of a valuation, then the valuation of each element of the submonoid is invertible.

If `S` is a submonoid of a commutative ring `A` that lies in the complement of the prime ideal generated by the support of a valuation `v` from `A` to a linearly ordered commutative group with zero `Γ`, then every element `s` in `S` is a unit with respect to `v`.


/-- In a Hilbert space, the orthogonal complement of the orthogonal complement of a subspace `K`
is the topological closure of `K`.

Note that the completeness assumption is necessary. Let `E` be the space `ℕ →₀ ℝ` with inner space
structure inherited from `PiLp 2 (fun _ : ℕ ↦ ℝ)`. Let `K` be the subspace of sequences with the sum
of all elements equal to zero. Then `Kᗮ = ⊥`, `Kᗮᗮ = ⊤`.   -/
theorem Submodule.orthogonal_orthogonal_eq_closure :
    ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
      (K : Submodule 𝕜 E) [inst_3 : CompleteSpace E], Kᗮᗮ = Submodule.topologicalClosure K :=
  by sorry

This theorem states that in a Hilbert space, the orthogonal complement of the orthogonal complement of a given subspace `K` is equal to the topological closure of `K`. However, this is valid only under the assumption that the space is complete. For example, consider the space of sequences of real numbers that converge to zero (`ℕ →₀ ℝ`), with an inner product space structure inherited from `PiLp 2 (fun _ : ℕ ↦ ℝ)`. In this case, if we take `K` as the subspace of sequences whose elements sum to zero, the orthogonal complement of `K` is the zero subspace, and the orthogonal complement of this zero subspace is the whole space, not the topological closure of `K`.

In a complete Hilbert space, the orthogonal complement of the orthogonal complement of a subspace equals the topological closure of that subspace.


theorem CategoryTheory.StructuredArrow.hom_ext :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂}
      [inst_1 : CategoryTheory.Category.{v₂, u₂} D] {S : D} {T : CategoryTheory.Functor C D}
      {X Y : CategoryTheory.StructuredArrow S T} (f g : X ⟶ Y), f.right = g.right → f = g :=
  by sorry

This theorem states that for any two categories 'C' and 'D', a functor 'T' from 'C' to 'D', an object 'S' from 'D', and two objects 'X' and 'Y' from the structured arrows from 'S' to 'T', if there exist two morphisms 'f' and 'g' from 'X' to 'Y' such that their right components are equal, then the two morphisms themselves are equal. This is an equality condition for morphisms in the context of structured arrows in category theory.

For any categories 'C' and 'D', functor 'T' from 'C' to 'D', object 'S' in 'D', and structured arrows 'X' and 'Y' from 'S' to 'T', if there exist morphisms 'f' and 'g' with equal right components from 'X' to 'Y', then 'f' = 'g'.


theorem Ordinal.zero_nmul : ∀ (a : Ordinal.{u_1}), Ordinal.nmul 0 a = 0 := by sorry

The theorem `Ordinal.zero_nmul` states that for any ordinal number `a`, the natural number multiplication of zero and `a` is zero. In other words, multiplying any ordinal number by zero results in the ordinal zero.

For any ordinal number `a`, `0 * a = 0` holds as an equality of ordinal numbers.


theorem mul_lt_mul'' :
    ∀ {α : Type u} [inst : StrictOrderedSemiring α] {a b c d : α}, a < c → b < d → 0 ≤ a → 0 ≤ b → a * b < c * d := by
  sorry

This theorem states that for any strictly ordered semiring `α`, given four elements `a`, `b`, `c`, and `d` from `α` where `a` is less than `c` and `b` is less than `d`, and both `a` and `b` are non-negative, then the product of `a` and `b` is less than the product of `c` and `d`.

For any strictly ordered semiring `α`, if `a`, `b`, `c`, and `d` are elements of `α` with `a < c`, `b < d`, and `a`, `b` non-negative, then `a * b < c * d`.


theorem Set.eq_of_mem_uIcc_of_mem_uIcc :
    ∀ {α : Type u_1} [inst : DistribLattice α] {a b c : α}, a ∈ Set.uIcc b c → b ∈ Set.uIcc a c → a = b := by sorry

This theorem states that for any type `α` that forms a distributive lattice, given three elements `a`, `b`, and `c` of `α`, if `a` lies in the set of elements between `b` and `c` (inclusive), and `b` lies in the set of elements between `a` and `c` (inclusive), then `a` and `b` must be equal. This is a property of the `Set.uIcc` function, which defines the set of elements between two given elements in a lattice.

In a distributive lattice, if `a` is between `b` and `c`, and `b` is between `a` and `c`, then `a = b`.


theorem Multiset.replicate_le_coe :
    ∀ {α : Type u_1} {a : α} {n : ℕ} {l : List α}, Multiset.replicate n a ≤ ↑l ↔ List.Sublist (List.replicate n a) l :=
  by sorry

This theorem states that for any type `α`, any element `a` of type `α`, any natural number `n`, and any list `l` of elements of type `α`, the multiset created by replicating `a` `n` times is a subset of the multiset derived from `l` if and only if the list created by replicating `a` `n` times is a sublist of `l`. This is a way of linking the concept of sublist on lists with the concept of subset on multisets.

For any type `α`, any natural number `n`, any element `a` of type `α`, and any list `l` of elements of type `α`, the multiset formed by `n` replicas of `a` is a subset of the multiset formed from list `l` if and only if `l` contains `n` copies of `a` as sublist.


theorem Complex.UnitDisc.abs_lt_one : ∀ (z : Complex.UnitDisc), Complex.abs ↑z < 1 := by sorry

This theorem states that for every complex number `z` in the unit disc, the absolute value of `z` is less than one. In other words, the absolute value (or modulus) of any complex number that belongs to the unit disc in the complex plane is strictly less than one. This is consistent with the definition of a unit disc in the complex plane, which includes all complex numbers within a distance less than one from the origin (0,0).

For all complex numbers `z`, if `z` is in the unit disc, then the absolute value of `z` is less than 1.


MeasureTheory.Memℒp.sup

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

The theorem `MeasureTheory.Memℒp.sup` states that for any nonnegative extended real number `p`, any measurable space `α`, any `E` that forms a normed lattice addition commutative group, any measure `μ` on the measurable space `α`, and any two functions `f` and `g` from `α` to `E`, if both `f` and `g` satisfy the property `Memℒp`, then the function which at each point takes the supremum (or maximum) of `f` and `g` also satisfies the property `Memℒp`.

In mathematical terms, `f` and `g` being in `L^p` space (denoted by `Memℒp`) means that they are almost everywhere strongly measurable and their p-th power integrals are finite (if `p < ∞`), or their essential supremum is finite (if `p = ∞`). The theorem then states that the pointwise supremum of two functions in `L^p` space is also in `L^p` space.

If `f` and `g` are measurable functions from a measurable space to a normed lattice addition commutative group with finite p-th power integrals (or essential supremum for p = ∞), then the pointwise supremum of `f` and `g` also has finite p-th power integrals (or essential supremum for p = ∞).


/-- The diameter of a set is always nonnegative  -/
theorem Metric.diam_nonneg : ∀ {α : Type u} [inst : PseudoMetricSpace α] {s : Set α}, 0 ≤ Metric.diam s := by sorry

This theorem states that the diameter of a set is always nonnegative. Specifically, it asserts that for any type `α` that is a PseudoMetricSpace (a generalized metric space), and for any set `s` of elements of type `α`, the diameter of `s` (as computed by the `Metric.diam` function) is greater than or equal to 0. This means that in any metric space, the diameter, which is the greatest distance between any two points in the set, can never be a negative number.

For any PseudoMetricSpace `α` and set `s` of elements in `α`, the diameter of `s` (as computed by `Metric.diam`) is a non-negative real number.


theorem Polynomial.mirror_mirror :
    ∀ {R : Type u_1} [inst : Semiring R] (p : Polynomial R), Polynomial.mirror (Polynomial.mirror p) = p := by sorry

The theorem `Polynomial.mirror_mirror` states that for any type `R` that is a semiring, and a polynomial `p` from that semiring, if we apply the "mirror" operation twice, we get back the original polynomial. In other words, mirroring a polynomial is an involution in the semiring of polynomials over `R`. The "mirror" of a polynomial is defined as the product of the reversed polynomial and `X` raised to the power of the natural trailing degree of the polynomial.

For any semiring `R` and polynomial `p` over `R`, applying the mirror operation twice equals the identity on `p`, where the mirror operation is defined as the reversed polynomial multiplied by `X` raised to the power of the degree of `p`.


theorem extremePoints_subset :
    ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : OrderedSemiring 𝕜] [inst_1 : AddCommMonoid E] [inst_2 : SMul 𝕜 E]
      {A : Set E}, Set.extremePoints 𝕜 A ⊆ A :=
  by sorry

This theorem states that for any ordered semiring `𝕜` and any set `A` of elements of an additive commutative monoid `E` that has a scalar multiplication with `𝕜`, the set of extreme points of `A` is a subset of `A`. In other words, every extreme point of `A` is also an element of `A`. An extreme point `x` of a set `A` is defined as a point that belongs to no open segment with ends in `A`, except for the open segment with both ends at `x`.

The set of extreme points of an additive commutative monoid equipped with scalar multiplication by an ordered semiring is a subset of the monoid itself.


theorem MeasureTheory.OuterMeasure.isCaratheodory_iff_le :
    ∀ {α : Type u} (m : MeasureTheory.OuterMeasure α) {s : Set α},
      MeasurableSet s ↔ ∀ (t : Set α), ↑m (t ∩ s) + ↑m (t \ s) ≤ ↑m t :=
  by sorry

This theorem, `MeasureTheory.OuterMeasure.isCaratheodory_iff_le`, states that for any type `α`, any outer measure `m` on `α`, and any set `s` of type `α`, the set `s` is measurable if and only if for all sets `t` of type `α`, the sum of the measures of the intersection of `t` and `s` and the set difference of `t` and `s` is less than or equal to the measure of `t`. Here, the measure of a set is obtained using the outer measure `m`. This theorem relates the concept of measurability of a set to the property of being Caratheodory measurable, which involves the measures of intersections and differences of sets.

For any outer measure `m` on a type `α`, a set `s` is measurable if and only if for all sets `t`, the measure of `s ∩ t` plus the measure of `s \ t` is less than or equal to the measure of `t`.


theorem Finset.insert_erase_invOn :
    ∀ {α : Type u_1} [inst : DecidableEq α] {a : α},
      Set.InvOn (insert a) (fun s => Finset.erase s a) {s | a ∈ s} {s | a ∉ s} :=
  by sorry

The theorem `Finset.insert_erase_invOn` states that for any type `α` with decidable equality and any element `a` of type `α`, the function `insert a` and the function `erase s a` are inverses of each other for the relevant domains. More specifically, `insert a` acts as inverse in the set where `a` does not belong to `s` and `erase s a` acts as inverse in the set where `a` belongs to `s`. Here, `s` is a set of `α`. This means that if you insert an element `a` into a set from which it has been erased, you will get back your original set; and similarly, if you erase an element `a` from a set where it has been inserted, you will also retrieve your initial set.

For any type `α` with decidable equality and any set `s` of `α`, the functions `insert a` and `erase s a` are inverse bijections when `a` is not in `s` and `a` is in `s`, respectively.


theorem MeasureTheory.ae_le_of_forall_set_lintegral_le_of_sigmaFinite :
    ∀ {α : Type u_1} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} [inst : MeasureTheory.SigmaFinite μ]
      {f g : α → ENNReal},
      Measurable f →
        Measurable g →
          (∀ (s : Set α), MeasurableSet s → ↑↑μ s < ⊤ → ∫⁻ (x : α) in s, f x ∂μ ≤ ∫⁻ (x : α) in s, g x ∂μ) →
            f ≤ᶠ[MeasureTheory.Measure.ae μ] g :=
  by sorry

The theorem `MeasureTheory.ae_le_of_forall_set_lintegral_le_of_sigmaFinite` states that for any type `α` with a measurable space `m0` and a sigma-finite measure `μ`, given two functions `f` and `g` from `α` to the extended non-negative reals (`ENNReal`), if both `f` and `g` are measurable, and for every measurable set `s` with a measure that's less than infinity, the integral of `f` over `s` with respect to `μ` is less than or equal to the integral of `g` over `s` with respect to `μ`, then `f` is less than or equal to `g` almost everywhere with respect to measure `μ`. This essentially says that if one function's integral is less than or equal to another's over all measurable sets, then the first function is less than or equal to the second almost everywhere.

If `α` is a type with a sigma-finite measure `μ`, `f` and `g` are measurable functions from `α` to the extended non-negative reals, and for every measurable set `s` with finite measure, `∫(s, μ, f) ≤ ∫(s, μ, g)`, then `f ≤ g` almost everywhere with respect to `μ`.


theorem List.erase_comm :
    ∀ {α : Type u_1} [inst : BEq α] [inst_1 : LawfulBEq α] (a b : α) (l : List α),
      List.erase (List.erase l a) b = List.erase (List.erase l b) a :=
  by sorry

The theorem `List.erase_comm` states that for any type `α` that has an equality comparison (`BEq α`) and respects the laws of equality (`LawfulBEq α`), given any two elements `a` and `b` of type `α` and a list `l` of elements of type `α`, the order of erasing `a` and `b` from the list `l` doesn't matter. In other words, erasing `a` first and then `b` from the list `l` is the same as erasing `b` first and then `a`.

For any type `α` with `BEq α` and `LawfulBEq α`, and any `a`, `b` in `α` and list `l` of `α`, erasing `a` then `b` from `l` is equal to erasing `b` then `a` from `l`.


theorem Int.lt_add_of_sub_left_lt : ∀ {a b c : ℤ}, a - b < c → a < b + c := by sorry

This theorem states that for any three integers `a`, `b`, and `c`, if the difference of `a` and `b` is less than `c`, then `a` is less than the sum of `b` and `c`. In mathematical terms, if `a - b < c` then `a < b + c`. This theorem is a basic property of integers and their operations.

If `a`, `b`, and `c` are integers with `a - b < c`, then `a < b + c`.


theorem map_pos_of_ne_zero :
    ∀ {F : Type u_2} {α : Type u_3} {β : Type u_4} [inst : FunLike F α β] [inst_1 : AddGroup α]
      [inst_2 : LinearOrderedAddCommMonoid β] [inst_3 : AddGroupNormClass F α β] (f : F) {x : α}, x ≠ 0 → 0 < f x :=
  by sorry

The theorem `map_pos_of_ne_zero` states that for all types `F`, `α`, and `β`, given an instance of `FunLike F α β` (a function-like relationship between `F`, `α`, and `β`), an `AddGroup` instance for `α` (which is a group under addition), a `LinearOrderedAddCommMonoid` instance for `β` (a commutative monoid under addition which is linearly ordered), and an `AddGroupNormClass` instance for `F α β` (a class that relates norms and addition), if we have a function `f` of type `F` and a non-zero element `x` of type `α`, then the mapped value `f x` is greater than 0. In other words, this theorem says when we map a non-zero element from an additive group to a linearly ordered additive commutative monoid using a function that respects norms and addition, the resulting element is positive.

Given a function `f : F α → β` between additive groups with respect to `FunLike`, and a non-zero element `x ∈ α`, if `F` is an `AddGroupNormClass` over `α` and `β` is a linearly ordered `AddGroup` and `LinearOrderedAddCommMonoid`, then `f x` is positive.


theorem Polynomial.newtonMap_apply :
    ∀ {R : Type u_1} {S : Type u_2} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] (P : Polynomial R)
      {x : S},
      Polynomial.newtonMap P x =
        x - Ring.inverse ((Polynomial.aeval x) (Polynomial.derivative P)) * (Polynomial.aeval x) P :=
  by sorry

This theorem states that for any commutative ring `R`, any other commutative ring `S`, any `R`-algebra structure on `S`, and any polynomial `P` over `R`, the value of the Newton map of `P` at any point `x` in `S` is equal to `x` minus the product of the inverse of the evaluation of the derivative of `P` at `x` and the evaluation of `P` at `x`. If the derivative of `P` evaluated at `x` is not a unit (i.e., it cannot be inverted), then the Ring.inverse function returns zero for this term.

For any commutative rings `R` and `S`, `R-algebra` `S`, polynomial `P` over `R`, and `x` in `S`, the Newton map of `P` at `x` equals `x - P'(x)⁻¹ * P(x)`, where `P'(x)` is the derivative of `P` at `x` and `⁻¹` denotes the multiplicative inverse. If `P'(x)` is not a unit, then `P'(x)⁻¹` is zero.