theorem Matrix.updateRow_apply :
    ∀ {m : Type u_2} {n : Type u_3} {α : Type v} {M : Matrix m n α} {i : m} {j : n} {b : n → α} [inst : DecidableEq m]
      {i' : m}, Matrix.updateRow M i b i' j = if i' = i then b j else M i' j :=
  by sorry

This theorem states that for any type `m` indexing rows, type `n` indexing columns, and type `α` for entry values of a matrix `M`, along with a specific row `i` in `m`, a specific column `j` in `n`, and a function `b` mapping `n` to `α`, and given that equality in `m` is decidable, then updating the `i`-th row of the matrix `M` using function `b` and checking the value at the position `(i', j)` in the updated matrix results in the value `b j` if `i'` equals `i`, otherwise it remains the original value `M i' j`. This theorem precisely describes how a row in a matrix is updated with a new function in Lean 4.

Given a decidably equated matrix M with types m for rows, n for columns, and α for entries, and a function b from n to α, updating row i of M with b results in the value b j for position (i, j), and the original value otherwise.


theorem mem_nhds_uniformity_iff_right :
    ∀ {α : Type ua} [inst : UniformSpace α] {x : α} {s : Set α}, s ∈ nhds x ↔ {p | p.1 = x → p.2 ∈ s} ∈ uniformity α :=
  by sorry

This theorem states that for any type `α` equipped with a `UniformSpace` structure, any point `x` of type `α`, and any set `s` of type `α`, `s` is a neighborhood of `x` (i.e., `s` belongs to the neighborhood filter at `x`) if and only if the set of pairs `p` such that if the first component of `p` is `x`, then the second component of `p` belongs to `s`, belongs to the uniformity filter of `α`. In simpler terms, it connects the concepts of neighborhood filters and the uniformity filter in a uniform space, specifying how a set qualifies as a neighborhood of a particular point under the conditions of uniform space.

In a uniform space, a set is a neighborhood of a point if and only if the point-set pair lies in the uniformity relation.


LinearEquiv.finiteDimensional

/-- Finite dimensionality is preserved under linear equivalence.  -/
theorem LinearEquiv.finiteDimensional :
    ∀ {K : Type u} {V : Type v} [inst : DivisionRing K] [inst_1 : AddCommGroup V] [inst_2 : Module K V] {V₂ : Type v'}
      [inst_3 : AddCommGroup V₂] [inst_4 : Module K V₂],
      (V ≃ₗ[K] V₂) → ∀ [inst_5 : FiniteDimensional K V], FiniteDimensional K V₂ :=
  by sorry

The theorem `LinearEquiv.finiteDimensional` states that the property of being a finite-dimensional vector space is preserved under a linear equivalence. Specifically, given a division ring `K` and two vector spaces `V` and `V₂` over `K`, if `V` is a finite-dimensional vector space and there exists a linear equivalence (i.e., a bijective linear transformation) between `V` and `V₂`, then `V₂` is also a finite-dimensional vector space.

If two finite-dimensional vector spaces over a division ring are linearly equivalent, then they have equal finite dimensions.


WellFounded.isIrrefl

theorem WellFounded.isIrrefl : ∀ {α : Type u_1} {r : α → α → Prop}, WellFounded r → IsIrrefl α r := by sorry

This theorem states that for any type `α` and any relation `r` over `α`, if `r` is well-founded, then it is also irreflexive. In other words, there are no elements `a` in `α` for which `r a a` holds true. In the context of set theory, a relation is well-founded if there are no infinite descending chains, and is irreflexive if no element is related to itself.

If `α` is a type and `r` is a well-founded relation over `α`, then `r` is irreflexive.


theorem AddMonoidHom.id_apply : ∀ (M : Type u_10) [inst : AddZeroClass M] (x : M), (AddMonoidHom.id M) x = x := by sorry

This theorem states that for any type `M` that is an instance of the `AddZeroClass` (in other words, `M` is an additive monoid), the identity map on this additive monoid, when applied to any element `x` of `M`, returns `x` itself. This is analogous to the mathematical property where the identity map (function) on any mathematical structure (like a set or a group) leaves each element unchanged.

For any additive monoid M, the identity function maps each element x of M to x itself.


theorem isClosed_of_spaced_out :
    ∀ {α : Type u} [inst : UniformSpace α] [inst_1 : T0Space α] {V₀ : Set (α × α)},
      V₀ ∈ uniformity α → ∀ {s : Set α}, (Set.Pairwise s fun x y => (x, y) ∉ V₀) → IsClosed s :=
  by sorry

This theorem states that for any type `α` equipped with a uniform space structure and an additional T0Space structure, given a set `V₀` of pairs from `α` that belongs to the uniformity of `α`, if for any set `s` of `α`, all distinct pairs `(x, y)` from `s` do not belong to `V₀` (property defined by the `Set.Pairwise` definition), then the set `s` is a closed set. In other words, it says that if all distinct pairs of elements from a set are 'spaced out' (i.e., not in a certain set related to the uniformity structure), then the original set is closed in the topology induced by the uniform space.

Given a T0 space `α` with uniformity structure, a set `V₀` in its uniformity, if for every set `s`, all distinct pairs `(x, y)` from `s` are not in `V₀`, then `s` is closed.


theorem Set.Ico_subset_Ici_self : ∀ {α : Type u_1} [inst : Preorder α] {a b : α}, Set.Ico a b ⊆ Set.Ici a := by sorry

The theorem `Set.Ico_subset_Ici_self` states that for any type `α` with a preorder, and for all `a` and `b` of type `α`, the left-closed right-open interval from `a` to `b` is a subset of the left-closed right-infinite interval starting at `a`. In mathematical terms, this means that for all `x` such that `a ≤ x < b`, it is also true that `a ≤ x`.

For any type `α` with a preorder and all `a < b` in `α`, the left-closed right-open interval `[a, b) is a subset of the left-closed right-infinite interval `[a, ∞)`.


theorem Filter.map₂_map_right :
    ∀ {α : Type u_1} {β : Type u_3} {γ : Type u_5} {δ : Type u_7} {f : Filter α} {g : Filter β} (m : α → γ → δ)
      (n : β → γ), Filter.map₂ m f (Filter.map n g) = Filter.map₂ (fun a b => m a (n b)) f g :=
  by sorry

The theorem `Filter.map₂_map_right` states that for all types `α`, `β`, `γ`, `δ`, for any filters `f` of type `α` and `g` of type `β`, and for any functions `m : α → γ → δ` and `n : β → γ`, the image of the binary function `m` under the filter `f` and the mapped filter `n(g)` (denoted as `Filter.map₂ m f (Filter.map n g)`) is equal to the image of the binary function `(a, b) ↦ m a (n b)` under the filters `f` and `g` (denoted as `Filter.map₂ (fun a b => m a (n b)) f g`). In essence, it's saying that the mapping of the second filter can be "absorbed" into the binary function without changing the result.

For any filters `f` and `g`, and functions `m` and `n`, `Filter.map₂ m (Filter.map n g) f = Filter.map₂ (λa b, m a (n b)) f g`.


theorem Filter.HasBasis.forall_iff :
    ∀ {α : Type u_1} {ι : Sort u_4} {l : Filter α} {p : ι → Prop} {s : ι → Set α},
      Filter.HasBasis l p s →
        ∀ {P : Set α → Prop}, (∀ ⦃s t : Set α⦄, s ⊆ t → P s → P t) → ((∀ s ∈ l, P s) ↔ ∀ (i : ι), p i → P (s i)) :=
  by sorry

This theorem states that for a given type `α` and a filter `l` on `α`, if the filter has a basis characterized by a predicate `p` on an index type `ι` and a map `s` from `ι` to the set of `α`, then for any property `P` which holds for subsets of a set if it holds for that set, it holds for all sets in the filter if and only if it holds for all sets in the basis where the predicate `p` is true. In other words, the filter satisfies a property for all its sets if and only if its basis sets satisfying the predicate also satisfy this property.

Given a filter `l` on type `α` with basis characterized by predicate `p` on index type `ι` and map `s`, if property `P` holds for sets if and only if it holds for sets in the basis where `p` is true, then `P` holds for all sets in the filter if and only if it holds for all sets in the basis.


theorem Polynomial.derivation_ext :
    ∀ {R : Type u_1} {A : Type u_2} [inst : CommSemiring R] [inst_1 : AddCommMonoid A] [inst_2 : Module R A]
      [inst_3 : Module (Polynomial R) A] {D₁ D₂ : Derivation R (Polynomial R) A},
      D₁ Polynomial.X = D₂ Polynomial.X → D₁ = D₂ :=
  by sorry

The theorem `Polynomial.derivation_ext` states that for any two derivations `D₁` and `D₂` from the polynomial ring over a commutative semiring `R` to an `R`-module `A`, if these derivations coincide on the polynomial variable `X`, then `D₁` and `D₂` are identical. In other words, given the same commutative semiring, the same module, and the same polynomial variable, the derivation is uniquely determined by its action on the polynomial variable `X`.

Given two derivations from a polynomial ring over a commutative semiring to an R-module, if they agree on the derivative of the polynomial variable X, then they are equal.


theorem measurable_sum :
    ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {m : MeasurableSpace α} {mβ : MeasurableSpace β}
      {x : MeasurableSpace γ} {f : α ⊕ β → γ}, Measurable (f ∘ Sum.inl) → Measurable (f ∘ Sum.inr) → Measurable f :=
  by sorry

The theorem `measurable_sum` states that for all types `α`, `β`, and `γ` with measurable spaces `m`, `mβ`, and `x`, respectively, if a function `f` from the sum type `α ⊕ β` to `γ` is such that both the composition of `f` with `Sum.inl` and the composition of `f` with `Sum.inr` are measurable, then `f` itself is measurable. Here `Sum.inl` and `Sum.inr` cover the left and right inclusion maps from `α` and `β` into the sum type `α ⊕ β`. In other words, if `f` is measurable when restricted to both parts of the sum type, then it is measurable on the entire sum type.

If the restriction of a function between sum types to each summand is measurable, then the function is measurable.


theorem Mathlib.Order.WellFoundedSet._auxLemma.20 : ∀ (p : Prop), (True ∧ p) = p := by sorry

This theorem, termed as `Mathlib.Order.WellFoundedSet._auxLemma.20`, states that for any proposition `p`, the logical conjunction of `True` and `p` is equivalent to `p` itself. In other words, if `p` is a proposition, then `True and p` is just `p`, because the truth-value of the conjunction is solely determined by `p` when the other conjunct is `True`.

For any proposition `p`, `True` and `p` are logically equivalent.


theorem Polynomial.roots_pow :
    ∀ {R : Type u} [inst : CommRing R] [inst_1 : IsDomain R] (p : Polynomial R) (n : ℕ),
      Polynomial.roots (p ^ n) = n • Polynomial.roots p :=
  by sorry

The theorem `Polynomial.roots_pow` states that for any polynomial `p` over a domain `R` which forms a commutative ring, and any natural number `n`, the roots of `p` raised to the power `n` are the same as `n` times the roots of `p`. This means that taking a polynomial to a power `n` doesn't change its set of roots, but instead each root's multiplicity is multiplied by `n`.

For any polynomial `p` over a commutative ring `R` and natural number `n`, the roots of `p` are the same as the roots of `p^n`, each with multiplicity multiplied by `n`.


theorem Set.finite_of_ncard_ne_zero : ∀ {α : Type u_1} {s : Set α}, Set.ncard s ≠ 0 → Set.Finite s := by sorry

This theorem states that for any type `α` and any set `s` of type `Set α`, if the cardinality of `s` (returned by `Set.ncard s`) is not equal to zero, then the set `s` is finite. In other words, if a set has a nonzero cardinality, it must be a finite set. This is essentially an assertion about the finiteness of sets based on their cardinality in the mathematical logic context.

If a set has nonzero cardinality, then it is finite.


theorem MeasureTheory.OuterMeasure.boundedBy_le :
    ∀ {α : Type u_1} {m : Set α → ENNReal} (s : Set α), ↑(MeasureTheory.OuterMeasure.boundedBy m) s ≤ m s := by sorry

This theorem states that for all types `α` and for all functions `m` which assign measures in the extended nonnegative real numbers to sets of type `α`, the measure of any set `s` of type `α` under the unique maximal outer measure `μ` (which is derived from `m` by `MeasureTheory.OuterMeasure.boundedBy`) is less than or equal to the measure of `s` under `m`. In other words, the measure of a set under the maximal outer measure never exceeds its measure under the original measure function.

For all types `α` and measures `m`, the outer measure `μ` derived from `m` satisfies `μ(s) ≤ m(s)` for all sets `s` of type `α`.


theorem Polynomial.isEquivalent_atTop_lead :
    ∀ {𝕜 : Type u_1} [inst : NormedLinearOrderedField 𝕜] (P : Polynomial 𝕜) [inst_1 : OrderTopology 𝕜],
      Asymptotics.IsEquivalent Filter.atTop (fun x => Polynomial.eval x P) fun x =>
        Polynomial.leadingCoeff P * x ^ Polynomial.natDegree P :=
  by sorry

This theorem states that for any polynomial `P` over a normed linearly ordered field `𝕜` with an order topology, the evaluation of the polynomial at a value `x` is asymptotically equivalent to the product of the polynomial's leading coefficient and `x` raised to the power of the polynomial's degree, as `x` goes to infinity. In simpler terms, as `x` grows without bound, the behavior of the polynomial `P` is dominated by its term with the highest degree.

For any polynomial `P` over a normed linearly ordered field `𝕜`, as `x` approaches infinity, `P x` is asymptotically equivalent to the product of `P`'s leading coefficient and `x` raised to the power of `P`'s degree.


theorem Nat.add_sub_cancel' : ∀ {n m : ℕ}, m ≤ n → m + (n - m) = n := by sorry

This theorem, `Nat.add_sub_cancel'`, states that for all natural numbers `n` and `m`, if `m` is less than or equal to `n`, then adding `m` to the difference of `n` and `m` will yield `n`. Essentially, this is saying that we can "cancel out" the subtraction by adding the subtracted element back, assuming the natural number we are subtracting is less than or equal to the original number. This theorem is a specific instance of the general algebraic property that `n = m + (n - m)` when `m ≤ n`.

For all natural numbers `n` and `m` with `m <= n`, `n = (n - m) + m`.


Set.Nonempty.neg

theorem Set.Nonempty.neg : ∀ {α : Type u_2} [inst : InvolutiveNeg α] {s : Set α}, Set.Nonempty s → Set.Nonempty (-s) :=
  by sorry

The theorem `Set.Nonempty.neg` states that for any type `α` with an `InvolutiveNeg` instance (meaning that it's a type with a negation operation such that negating twice gives the original element), if a set `s` of this type is nonempty (i.e., `Set.Nonempty s`), then the set obtained by applying the negation operation to each element of `s` (denoted by `-s`) is also nonempty. In other words, if we have at least one element in a set, the set of their negations will also have at least one element.

If `α` is a type with an `InvolutiveNeg` instance and `s : Set α` is nonempty, then `-s` is also nonempty.


theorem NormedSpace.exp_zero :
    ∀ {𝕂 : Type u_1} {𝔸 : Type u_2} [inst : Field 𝕂] [inst_1 : Ring 𝔸] [inst_2 : Algebra 𝕂 𝔸]
      [inst_3 : TopologicalSpace 𝔸] [inst_4 : TopologicalRing 𝔸], NormedSpace.exp 𝕂 0 = 1 :=
  by sorry

The theorem `NormedSpace.exp_zero` states that for any given types `𝕂` and `𝔸`, where `𝕂` is a field, `𝔸` is a ring and `𝔸` is an algebra over `𝕂`, if `𝔸` is also a topological space and a topological ring, then the exponential of zero in this normed space is equal to one. In mathematical terms, for such structures, we have `exp(0) = 1`.

For a normed space `𝔸` over a field `𝕂`, where `𝔸` is a ring, an algebra over `𝕂`, a topological space, and a topological ring, the exponential function in `𝔸` evaluates to one at zero, i.e., `exp(0) = 1`.


theorem MeasureTheory.DominatedFinMeasAdditive.eq_zero_of_measure_zero :
    ∀ {α : Type u_1} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} {β : Type u_8} [inst : NormedAddCommGroup β]
      {T : Set α → β} {C : ℝ},
      MeasureTheory.DominatedFinMeasAdditive μ T C → ∀ {s : Set α}, MeasurableSet s → ↑↑μ s = 0 → T s = 0 :=
  by sorry

This theorem states that for a given type `α`, a measure space `m` over `α`, a measure `μ` on `α`, a type `β` which forms a normed additive commutative group, a set function `T` from `α` to `β`, and a real number `C`, if `T` is a `DominatedFinMeasAdditive` function with respect to `μ` and `C`, then for any measurable set `s` such that the measure of `s` under `μ` is zero, the application of `T` to `s` will yield the zero element of `β`. In essence, this theorem says that a `DominatedFinMeasAdditive` function maps zero-measure sets to the zero element in the target normed additive commutative group.

If `T` is a `DominatedFinMeasAdditive` function from a measure space `(α, m)` to a normed additive commutative group `(β, +, ∥⋅∥)` with dominating measure `μ` and constant `C`, then `T(s) = ∥0∥` for any measurable set `s` with `μ(s) = 0`.


theorem Real.volume_Ioc : ∀ {a b : ℝ}, ↑↑MeasureTheory.volume (Set.Ioc a b) = ENNReal.ofReal (b - a) := by sorry

This theorem, named `Real.volume_Ioc`, states that for any two real numbers `a` and `b`, the measure (in terms of Lebesgue measure, sometimes referred to as "volume") of the interval that is open on the left and closed on the right, denoted as `(a, b]` (or `Set.Ioc a b` in Lean), is equivalent to the non-negative part of the difference `b - a`. This non-negative part is computed by the function `ENNReal.ofReal`, which returns `b - a` if it is a non-negative number, and `0` otherwise. In mathematical terms, it is saying that the measure of the interval (a, b] is max{b - a, 0}.

The Lebesgue measure of the interval (a, b] equals the non-negative value of b - a.


theorem IsMaxFilter.comp_antitone :
    ∀ {α : Type u} {β : Type v} {γ : Type w} [inst : Preorder β] [inst_1 : Preorder γ] {f : α → β} {l : Filter α}
      {a : α}, IsMaxFilter f l a → ∀ {g : β → γ}, Antitone g → IsMinFilter (g ∘ f) l a :=
  by sorry

The theorem `IsMaxFilter.comp_antitone` states that for all types `α`, `β`, and `γ` with `β` and `γ` equipped with a preorder, and for any filter `l` over `α`, any function `f : α → β`, and any element `a` of `α`, if `f` achieves its maximum at `a` with respect to the filter `l`, then for any antitone function `g : β → γ`, the composed function `g ∘ f` achieves its minimum at `a` with respect to the filter `l`. In other words, if `f` is maximized at `a` and `g` decreases when its input increases, then `g(f(x))` is minimized at `a`.

For all types `α`, `β`, and `γ` with `β` and `γ` preordered, if a filter `l` over `α`, function `f : α → β`, and element `a` of `α` satisfy `f(a) = max filter l a`, then `g ∘ f(a) = min filter l (g ∘ f) a` for any antitone function `g : β → γ`.


theorem AddSubgroup.le_comap_map :
    ∀ {G : Type u_1} [inst : AddGroup G] {N : Type u_5} [inst_1 : AddGroup N] (f : G →+ N) (H : AddSubgroup G),
      H ≤ AddSubgroup.comap f (AddSubgroup.map f H) :=
  by sorry

The theorem `AddSubgroup.le_comap_map` states that for any additive group homomorphism `f` from an additive group `G` to another additive group `N`, and any additive subgroup `H` of `G`, `H` is a subset of the preimage under `f` of the image under `f` of `H`. In other words, every element of the subgroup `H` is mapped to an element in `N` and then mapped back to an element in `G` that is in `H`. This theorem is a form of the fundamental property of the image and preimage (or inverse image) under a function.

For any additive group homomorphism f from an additive group G to another additive group N and any additive subgroup H of G, the image of H under f is a subset of the preimage of the image of H under f.


theorem Computation.map_think :
    ∀ {α : Type u} {β : Type v} (f : α → β) (s : Computation α),
      Computation.map f (Computation.think s) = Computation.think (Computation.map f s) :=
  by sorry

The theorem `Computation.map_think` states that for any type `α` and `β`, and a function `f` from `α` to `β`, and a computation `s` of type `α`, the computation that first delays the execution of `s` for one tick and then applies the function `f` on the result (represented by `Computation.map f (Computation.think s)`) is the same as the computation that first applies the function `f` on the computation `s` and then delays the execution of the result for one tick (represented by `Computation.think (Computation.map f s)`). This theorem establishes the distributivity of the `map` and `think` operations on computations.

For any type `α` and function `f` from `α` to `β`, and computation `s` of type `α`, `Computation.map f (Computation.think s)` is equal to `Computation.think (Computation.map f s)`.


theorem AEMeasurable.comp_aemeasurable :
    ∀ {α : Type u_2} {β : Type u_3} {δ : Type u_5} {m0 : MeasurableSpace α} [inst : MeasurableSpace β]
      [inst_1 : MeasurableSpace δ] {μ : MeasureTheory.Measure α} {f : α → δ} {g : δ → β},
      AEMeasurable g (MeasureTheory.Measure.map f μ) → AEMeasurable f μ → AEMeasurable (g ∘ f) μ :=
  by sorry

The theorem `AEMeasurable.comp_aemeasurable` states that for any three types `α`, `β`, and `δ` and any two functions `f : α → δ` and `g : δ → β`, if `g` is almost everywhere measurable with respect to the measure induced on `δ` by `f` and the measure `μ` on `α`, and if `f` is also almost everywhere measurable with respect to `μ`, then the composition of `g` and `f` (i.e., `g ∘ f`) is also almost everywhere measurable with respect to `μ`. This theorem formalizes in Lean 4 one of the properties of almost everywhere measurable functions in measure theory.

If `f : α → δ` and `g : δ → β` are almost everywhere measurable functions with respect to the same measure `μ`, then their composition `g ∘ f` is also almost everywhere measurable.


theorem Set.exists_finite_iff_finset : ∀ {α : Type u} {p : Set α → Prop}, (∃ s, Set.Finite s ∧ p s) ↔ ∃ s, p ↑s := by
  sorry

The theorem `Set.exists_finite_iff_finset` states that for any type `α` and any property `p` applied to a set of type `α`, there exists a finite set `s` such that `s` is finite and `p s` holds if and only if there exists a finite set `s` such that `p ↑s` holds. Here, `↑s` refers to the coercion of `s` from a finite set to a set, and `Set.Finite s` means that the set `s` is finite, i.e., it can be put into a one-to-one correspondence with a set of natural numbers less than some natural number `n`.

For any type `α` and property `p`, a set of type `α` is finite if and only if there exists a finite set of elements of type `α` satisfying property `p`.


theorem Multiset.attach_map_val : ∀ {α : Type u_1} (s : Multiset α), Multiset.map Subtype.val (Multiset.attach s) = s :=
  by sorry

The theorem `Multiset.attach_map_val` states that for all types `α` and for every multiset `s` of that type, when we "attach" a proof that each element `a` belongs to `s` (via `Multiset.attach`) and then map the `Subtype.val` function (which retrieves the underlying element from the subtype) over this attached multiset, we recover the original multiset `s`. In other words, attaching proofs of membership to elements of the multiset and then stripping them away effectively acts as an identity operation on the original multiset.

For all types `α` and multisets `s` of `α`, `Multiset.attach s (λ a h := h) = s`.


theorem Asymptotics.IsLittleO.trans_isBigOWith :
    ∀ {α : Type u_1} {E : Type u_3} {F : Type u_4} {G : Type u_5} [inst : Norm E] [inst_1 : Norm F] [inst_2 : Norm G]
      {c : ℝ} {f : α → E} {g : α → F} {k : α → G} {l : Filter α},
      f =o[l] g → Asymptotics.IsBigOWith c l g k → 0 < c → f =o[l] k :=
  by sorry

The theorem `Asymptotics.IsLittleO.trans_isBigOWith` states that for any types `α`, `E`, `F`, and `G` with instances of norms on `E`, `F`, and `G`, a real number `c`, functions `f : α → E`, `g : α → F`, and `k : α → G`, and a filter `l` on `α`, if `f` is little-o of `g` at `l` (meaning that `f` grows slower than `g` at `l`), and if `g` is Big-O of `k` at `l` with a constant factor `c` (meaning that `g` grows no faster than `c * k` at `l`), and if `c` is greater than zero, then `f` is little-o of `k` at `l`. In other words, it states that the little-o relation is transitive through the Big-O relation, under certain conditions. This conclusion allows us to compare the growth rates of functions at a specific point or sequence.

If `f` is little-o of `g` at filter `l` and `g` is Big-O of `k` at `l` with constant factor `c > 0`, then `f` is little-o of `k` at `l`.


NormedAddGroupHom.lipschitz

/-- continuous linear maps are Lipschitz continuous.  -/
theorem NormedAddGroupHom.lipschitz :
    ∀ {V₁ : Type u_2} {V₂ : Type u_3} [inst : SeminormedAddCommGroup V₁] [inst_1 : SeminormedAddCommGroup V₂]
      (f : NormedAddGroupHom V₁ V₂), LipschitzWith { val := ‖f‖, property := ⋯ } ⇑f :=
  by sorry

The theorem `NormedAddGroupHom.lipschitz` states that for any continuous linear map `f` from one seminormed additive commutative group `V₁` to another `V₂`, `f` is Lipschitz continuous with a Lipschitz constant of `‖f‖`. In other words, for any pair of elements `x, y` in `V₁`, the distance in `V₂` between `f(x)` and `f(y)` is less than or equal to `‖f‖` times the distance between `x` and `y` in `V₁`. The value `‖f‖` represents the operator norm of the linear map `f`.

For any continuous linear map between two seminormed additive commutative groups, the operator norm bounds the Lipschitz constant, ensuring that the image difference is less than or equal to the norm times the difference of the arguments.


theorem AddMonoidHom.eq_of_eqOn_denseM :
    ∀ {M : Type u_1} {N : Type u_2} [inst : AddZeroClass M] [inst_1 : AddZeroClass N] {s : Set M},
      AddSubmonoid.closure s = ⊤ → ∀ {f g : M →+ N}, Set.EqOn (⇑f) (⇑g) s → f = g :=
  by sorry

The theorem `AddMonoidHom.eq_of_eqOn_denseM` states that for any types `M` and `N` which are instances of the `AddZeroClass`, and for any set `s` of type `M`, if the additive submonoid generated by `s` is the entire set (i.e., `AddSubmonoid.closure s = ⊤` where `⊤` denotes the total set), then for any two additive monoid homomorphisms `f` and `g` from `M` to `N`, if `f` and `g` are equal on the set `s` (i.e., `Set.EqOn (⇑f) (⇑g) s` where `⇑f` and `⇑g` are the application of the functions `f` and `g` respectively), then `f` and `g` are equal everywhere. In other words, in the context of additive monoid homomorphisms, knowing that two functions are equal on a densely populated set implies that they are equal everywhere.

If `M` and `N` are AddZeroClasses, `s` is the dense additive submonoid of `M`, and `f` and `g` are additive monoid homomorphisms from `M` to `N` that agree on `s`, then `f = g`.


/-- If the angle between three points is nonzero, the first and third points are not equal.  -/
theorem EuclideanGeometry.left_ne_right_of_oangle_ne_zero :
    ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V]
      [inst_2 : MetricSpace P] [inst_3 : NormedAddTorsor V P] [hd2 : Fact (FiniteDimensional.finrank ℝ V = 2)]
      [inst_4 : Module.Oriented ℝ V (Fin 2)] {p₁ p₂ p₃ : P}, EuclideanGeometry.oangle p₁ p₂ p₃ ≠ 0 → p₁ ≠ p₃ :=
  by sorry

This theorem states that in a two-dimensional oriented module over real numbers, if the angle formed by three points is non-zero, then the first and third points cannot be identical. The points belong to a space that is a normed additively torsor over a normed additively commutative group, and the underlying vector space is an inner product space.

In a two-dimensional oriented real inner product space, distinct points form a non-zero angle.


CategoryTheory.EffectiveEpi.uniq

theorem CategoryTheory.EffectiveEpi.uniq :
    ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] {X Y W : C} (f : Y ⟶ X)
      [inst_1 : CategoryTheory.EffectiveEpi f] (e : Y ⟶ W)
      (h :
        ∀ {Z : C} (g₁ g₂ : Z ⟶ Y),
          CategoryTheory.CategoryStruct.comp g₁ f = CategoryTheory.CategoryStruct.comp g₂ f →
            CategoryTheory.CategoryStruct.comp g₁ e = CategoryTheory.CategoryStruct.comp g₂ e)
      (m : X ⟶ W), CategoryTheory.CategoryStruct.comp f m = e → m = CategoryTheory.EffectiveEpi.desc f e ⋯ :=
  by sorry

The theorem `CategoryTheory.EffectiveEpi.uniq` in Lean 4 states that for any category $C$, given objects $X$, $Y$, and $W$ in $C$, a morphism $f: Y \to X$ that is an effective epimorphism, and a morphism $e: Y \to W$. If for all objects $Z$ in $C$, and for any two morphisms $g_1, g_2: Z \to Y$, the situation where the composition of $g_1$ and $f$ is equal to the composition of $g_2$ and $f$ implies that the composition of $g_1$ and $e$ is equal to the composition of $g_2$ and $e$, then for any morphism $m: X \to W$ such that its composition with $f$ equals to $e$, $m$ is equal to the desc morphism of $f$ and $e$. In simple terms, under the given conditions, the morphism $m$ is uniquely determined by the effective epimorphism and the morphism $e$.

Given any category $C$, if $f: Y \to X$ is an effective epimorphism and for all $Z$ and morphisms $g\_1, g\_2: Z \to Y$, $g\_1 \circ f = g\_2 \circ f$ implies $g\_1 \circ e = g\_2 \circ e$, then the description morphism of $f$ and $e$ is unique.


theorem ENNReal.inv_le_inv : ∀ {a b : ENNReal}, a⁻¹ ≤ b⁻¹ ↔ b ≤ a := by sorry

This theorem states that for any two extended nonnegative real numbers `a` and `b`, the inverse of `a` is less than or equal to the inverse of `b` if and only if `b` is less than or equal to `a`. Here, the extended nonnegative real numbers are denoted as ENNReal, which includes all nonnegative real numbers along with positive infinity. The notion of inverses and inequalities for this set is extended from the standard definitions for nonnegative real numbers.

For any extended nonnegative real numbers `a` and `b`, `1/a <= 1/b` if and only if `a >= b`.


theorem Matrix.diag_diagonal :
    ∀ {n : Type u_3} {α : Type v} [inst : DecidableEq n] [inst_1 : Zero α] (a : n → α),
      Matrix.diag (Matrix.diagonal a) = a :=
  by sorry

The theorem `Matrix.diag_diagonal` states that for any type `n` with decidable equality and any type `α` with a zero element, if you have a function `a` from `n` to `α`, then the diagonal of the square matrix obtained by calling the function `Matrix.diagonal` with `a` as argument is equal to `a`. In other words, this is saying that if you create a square matrix where the diagonal elements are defined by some function `a` and the off-diagonal elements are zero, then retrieving the diagonal of this matrix gives you back the original function `a`.

For any type `n` with decidable equality and any type `α` with a zero element, the diagonal of the square matrix obtained by applying the function `Matrix.diagonal` to a function `a` from `n` to `α` is equal to `a` itself.


theorem hasDerivAtFilter_id :
    ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] (x : 𝕜) (L : Filter 𝕜), HasDerivAtFilter id 1 x L := by sorry

The theorem `hasDerivAtFilter_id` states that for any type `𝕜` which forms a non-trivially normed field, any element `x` of type `𝕜`, and any filter `L` on `𝕜`, the identity function `id` has derivative 1 at the point `x` as `x` converges along the filter `L`. In mathematical terms, it means that $ \lim_{x' \to x} \frac{id(x') - id(x)}{x' - x} = 1 $ for all x' in the neighbourhood of x defined by the filter `L`.

For any non-trivially normed field `𝕜`, element `x` in `𝕜`, and filter `L` on `𝕜`, the identity function `id` has derivative 1 at `x` as `x` converges along `L`. Equivalently, $ \lim\_{x' \to x} \frac{id(x') - id(x)}{x' - x} = 1 $ for all `x'` in the neighborhood of `x` defined by `L`.


theorem t1Space_iff_specializes_imp_eq :
    ∀ {X : Type u_1} [inst : TopologicalSpace X], T1Space X ↔ ∀ ⦃x y : X⦄, x ⤳ y → x = y := by sorry

This theorem states that for any type `X` equipped with a topological space structure, `X` is a T1 space if and only if for any two elements `x` and `y` in `X`, the specialization relation `x ⤳ y` implies that `x` equals `y`. The specialization relation is a fundamental concept in topology which intuitively says that a point `x` is "closer" than or "specializes" to a point `y` if every open set containing `y` also contains `x`. In a T1 space, distinct points are topologically distinguishable.

A topological space `X` is T1 if and only if the specialization relation `x ⤳ y` implies `x = y` for all `x, y ∈ X`.


/-- Open balls are bounded  -/
theorem Metric.isBounded_ball :
    ∀ {α : Type u} [inst : PseudoMetricSpace α] {x : α} {r : ℝ}, Bornology.IsBounded (Metric.ball x r) := by sorry

This theorem states that in any pseudometric space, the open balls are always bounded. Here, an open ball is defined as the set of all points that are at a distance less than a chosen radius from a given point. Boundedness is defined relative to the ambient bornology on the underlying set of the pseudometric space. Specifically, a set is said to be bounded if its complement is cobounded. In the context of this theorem, it means that no matter what point and radius we choose, the open ball with that center and radius is always a bounded set.

In every pseudometric space, open balls are bounded.


theorem geom_sum_eq :
    ∀ {α : Type u} [inst : DivisionRing α] {x : α},
      x ≠ 1 → ∀ (n : ℕ), (Finset.sum (Finset.range n) fun i => x ^ i) = (x ^ n - 1) / (x - 1) :=
  by sorry

The theorem `geom_sum_eq` states that for any type `α` which forms a Division Ring and any element `x` of this type `α` that is not equal to `1`, for any natural number `n`, the sum of the `i`-th power of `x` for all `i` in the range less than `n` (also known as the geometric sum) equals `(x ^ n - 1) / (x - 1)`. In mathematical terms, for `x ≠ 1` and `n ∈ ℕ`, it asserts the equality `∑_{i=0}^{n-1} x^i = (x^n - 1) / (x - 1)`.

For any division ring `α` and `x ∈ α \neq 1`, the geometric sum of the first `n` powers of `x`, `∑_{i=0}^{n-1} x^i`, equals `(x^n - 1) / (x - 1)` for any natural number `n`.


theorem MeasureTheory.toMeasurable_def :
    ∀ {α : Type u_6} [inst : MeasurableSpace α] (μ : MeasureTheory.Measure α) (s : Set α),
      MeasureTheory.toMeasurable μ s =
        if h : ∃ t ⊇ s, MeasurableSet t ∧ t =ᶠ[MeasureTheory.Measure.ae μ] s then Exists.choose h
        else
          if h' : ∃ t ⊇ s, MeasurableSet t ∧ ∀ (u : Set α), MeasurableSet u → ↑↑μ (t ∩ u) = ↑↑μ (s ∩ u) then
            Exists.choose h'
          else Exists.choose ⋯ :=
  by sorry

The theorem `MeasureTheory.toMeasurable_def` states that for any type `α` with a `MeasurableSpace` instance and for any measure `μ` and a set `s` of type `α`, the measurable representative `MeasureTheory.toMeasurable` of the set `s` according to the measure `μ` is defined as follows: If there exists a set `t` that contains `s`, is measurable, and is equal to `s` almost everywhere with respect to the measure `μ`, then the measurable representative is the set extracted from this existential statement. If such a `t` does not exist but there exists a `t` that contains `s` and is measurable, and for all measurable sets `u`, the measure of the intersection of `t` and `u` is equal to the measure of the intersection of `s` and `u`, then the measurable representative is the set extracted from this second existential statement. If neither of these conditions is met, then the measurable representative is obtained from another (unspecified here) existential statement.

If a set in a measurable space can be represented as the measurable subset equal almost everywhere or having equal measures with some other measurable set, then that set is the measurable representative according to the given measure. Otherwise, the measurable representative is obtained from some other existential statement.


theorem AdjoinRoot.mk_eq_mk :
    ∀ {R : Type u} [inst : CommRing R] {f g h : Polynomial R}, (AdjoinRoot.mk f) g = (AdjoinRoot.mk f) h ↔ f ∣ g - h :=
  by sorry

This theorem states that for any commutative ring `R` and any polynomials `f`, `g`, and `h` over `R`, the equality of the images of `g` and `h` under the ring homomorphism from `R[x]` to `AdjoinRoot f` (which sends `X` to the `root` of `f`) is equivalent to `f` dividing the difference of `g` and `h`. That is, the ring homomorphism maps `g` and `h` to the same element in the `AdjoinRoot f` ring if and only if `f` is a divisor of the polynomial obtained by subtracting `h` from `g`.

For any commutative ring `R`, polynomials `f`, `g`, and `h` over `R`, `g` and `h` map to the same element in `AdjoinRoot f` if and only if `f` divides `g - h` in `R[x]`.


theorem IsMinFilter.comp_antitone :
    ∀ {α : Type u} {β : Type v} {γ : Type w} [inst : Preorder β] [inst_1 : Preorder γ] {f : α → β} {l : Filter α}
      {a : α}, IsMinFilter f l a → ∀ {g : β → γ}, Antitone g → IsMaxFilter (g ∘ f) l a :=
  by sorry

The theorem `IsMinFilter.comp_antitone` states that for all types `α`, `β`, and `γ`, if `β` and `γ` are preordered, and given a function `f` from `α` to `β`, a filter `l` on `α`, and an element `a` of `α` such that `f` has a local minimum at `a` with respect to `l` (i.e., `f a` is less than or equal to `f x` for all `x` near `a`), then for any function `g` from `β` to `γ` that is antitone (i.e., if `b` is greater than or equal to `a` then `g(b)` is less than or equal to `g(a)`), the composed function `g ∘ f` has a local maximum at `a` with respect to `l`. In other words, if `f` is minimized at some point under some conditions, the composition of `f` with an antitone function will be maximized at that point under the same conditions.

If `f: α → β` has a local minimum at `a` with respect to filter `l` on `α`, and `g: β → γ` is antitone, then `g ∘ f` has a local maximum at `a` with respect to `l`.


theorem Primrec.vector_tail : ∀ {α : Type u_1} [inst : Primcodable α] {n : ℕ}, Primrec Vector.tail := by sorry

This theorem states that for any type `α` which can be primarily encoded and for any natural number `n`, the function `Vector.tail`, which returns the tail of a vector (with an empty vector resulting in an empty tail), is a primitive recursive function. In other words, `Vector.tail` is a function that, after encoding its input and output as natural numbers, can be computed using only basic operations and recursion on natural numbers.

The function `Vector.tail` on type `α` is a primitive recursive function on natural numbers.


theorem Cardinal.power_self_eq : ∀ {c : Cardinal.{u_1}}, Cardinal.aleph0 ≤ c → c ^ c = 2 ^ c := by sorry

This theorem states that for any cardinal number `c` in a certain type universe `u_1`, if `c` is greater than or equal to aleph-zero (ℵ₀, the smallest infinite cardinal), then the cardinality of the power set of `c` is equal to the cardinality of the set of all functions from `c` to a two-element set. This is expressed in the theorem as `c ^ c = 2 ^ c`. In other words, the cardinality of all subsets of `c` is the same as the cardinality of all binary-valued functions on `c`, as long as `c` is at least as large as the cardinality of the natural numbers.

The cardinality of the power set of a cardinal number `c` equal to or greater than aleph-zero is equivalent to the cardinality of the set of functions from `c` to a two-element set. (Or equivalently, `c ^ c = 2 ^ c`)


theorem List.maximum_ne_bot_of_length_pos :
    ∀ {α : Type u_1} [inst : LinearOrder α] {l : List α}, 0 < List.length l → List.maximum l ≠ ⊥ := by sorry

The theorem `List.maximum_ne_bot_of_length_pos` states that for any list `l` of elements of any type `α` that has a linear order structure, if the length of this list is greater than zero, then the maximum value of the list is not `⊥` (bottom). In other words, if a list is not empty, it will always have a maximum value.

For any non-empty list `l` of elements with a linear order structure, the maximum element exists in `l`.


theorem Embedding.t0Space :
    ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] [inst_2 : T0Space Y]
      {f : X → Y}, Embedding f → T0Space X :=
  by sorry

This theorem states that for any two types `X` and `Y`, given that `Y` is a T0 space and `f` is an embedding from `X` to `Y`, then `X` is also a T0 space. Here, a T0 space is a topological space that satisfies the T0 separation axiom, meaning that for any two distinct points in the space, there is at least one open set containing one of them but not the other. An embedding is a function `f` that is both injective (or one-to-one) and continuous, and its inverse function is also continuous when restricted to `f`'s range.

If `f` is an embedding of a T0 space `X` into a T0 space `Y`, then `X` is also a T0 space.


/-- **Alias** of the reverse direction of `Filter.eventuallyEq_set`. -/
theorem Filter.Eventually.set_eq :
    ∀ {α : Type u} {s t : Set α} {l : Filter α}, (∀ᶠ (x : α) in l, x ∈ s ↔ x ∈ t) → s =ᶠ[l] t := by sorry

This theorem, named `Filter.Eventually.set_eq`, expresses that for any set `s` and `t` of a certain type `α`, and a filter `l` on that type, if it is always the case that an element `x` of `α` is in `s` if and only if `x` is in `t` (under the filter `l`), then the sets `s` and `t` are eventually equal under that filter. In other words, it states that two sets are considered equal under a filter if all elements from the filter satisfy the condition of being in one set if and only if they are in the other.

If for all `x` in the filter `l` on type `α`, `x` is in set `s` if and only if `x` is in set `t`, then sets `s` and `t` are eventually equal under filter `l`.


theorem Polynomial.coeff_X_pow_self :
    ∀ {R : Type u} [inst : Semiring R] (n : ℕ), Polynomial.coeff (Polynomial.X ^ n) n = 1 := by sorry

This theorem, `Polynomial.coeff_X_pow_self`, states that for any semiring `R` and for any natural number `n`, the coefficient of `X^n` in the polynomial `X^n` is 1, where `X` is the polynomial variable. In other words, if you raise the polynomial variable `X` to some power `n`, and then look at the coefficient of the `X^n` term in the resulting polynomial, that coefficient will always be 1.

For any semiring R and natural number n, the coefficient of X^n in the polynomial X^n is 1.


theorem Equiv.image.proof_2 : ∀ {α : Type u_1} {β : Type u_2} (e : α ≃ β) (s : Set α) (y : ↑(⇑e '' s)), e.symm ↑y ∈ s :=
  by sorry

This theorem states that for every two types `α` and `β`, if there exists a bijective function `e` from `α` to `β`, and `s` is a set of elements of type `α`, then for every element `y` that is in the image of `s` under the function `e`, the preimage of `y` under the inverse of `e` is an element of `s`. In simpler terms, if you take an element from the set `s`, apply the function `e`, and then apply the inverse of `e`, you will end up back in the original set `s`.

If `e: α ↔ β` is a bijective function and `s ⊆ α` such that `y ∈ s'` where `y = e(x)` for some `x ∈ s`, then `e⁻¹(y) ∈ s`.


theorem Nat.lcm_ne_zero : ∀ {m n : ℕ}, m ≠ 0 → n ≠ 0 → Nat.lcm m n ≠ 0 := by sorry

This theorem states that for any two natural numbers `m` and `n`, if neither `m` nor `n` are zero, then their least common multiple (lcm) is also not zero. The least common multiple is defined as the product of `m` and `n` divided by their greatest common divisor (gcd).

For any non-zero natural numbers m and n, their least common multiple is a non-zero number. (lcm(m, n) = (m * n) / gcd(m, n) where m and n are non-zero)


theorem Mathlib.Data.Multiset.Bind._auxLemma.5 :
    ∀ {α : Type u_1} {β : Type v} {b : β} {s : Multiset α} {f : α → Multiset β},
      (b ∈ Multiset.bind s f) = ∃ a ∈ s, b ∈ f a :=
  by sorry

This theorem states that for any types `α` and `β`, any element `b` of type `β`, any multiset `s` of type `α`, and any function `f` from `α` to a multiset of `β`, the condition of `b` being in the multiset obtained by binding `s` with `f` is equivalent to there existing an element `a` in `s` such that `b` is in the multiset generated by applying `f` on `a`. In other words, `b` is in the bound multiset if and only if `b` is in the image of some element of `s` under `f`.

For any types `α` and `β`, any multiset `s` of `α`, any function `f` from `α` to multisets of `β`, and any `b` in `β`, `b` is in the multiset obtained by binding `s` with `f` if and only if there exists an `a` in `s` such that `b` is in the multiset generated by applying `f` on `a`.


Functor.Comp.ext

theorem Functor.Comp.ext :
    ∀ {F : Type u → Type w} {G : Type v → Type u} {α : Type v} {x y : Functor.Comp F G α},
      Functor.Comp.run x = Functor.Comp.run y → x = y :=
  by sorry

The theorem `Functor.Comp.ext` states that for all type functions `F` mapping from type `u` to type `w`, `G` mapping from type `v` to type `u` and any type `α` of type `v`, given two elements `x` and `y` of the composite functor `Functor.Comp F G α`, if the application of the `Functor.Comp.run` function on `x` results in the same value as the application on `y`, then `x` and `y` must be equal. This theorem essentially asserts the injectiveness of the `Functor.Comp.run` function, saying that no two distinct values in the composite functor can map to the same value in the composed functor `F (G α)`.

If `F : Type u -> Type w` and `G : Type v -> Type u` are functors, and `x` and `y` are elements of `Functor.Comp F G α`, then `Functor.Comp.run F G x = Functor.Comp.run F G y` implies `x = y`.


theorem Int.eq_of_mul_eq_mul_left : ∀ {a b c : ℤ}, a ≠ 0 → a * b = a * c → b = c := by sorry

This theorem states that for any three integers `a`, `b`, and `c`, if `a` is not zero and the product of `a` and `b` is equal to the product of `a` and `c`, then `b` must be equal to `c`. In mathematical terms, this corresponds to the property of cancellation in the integers: if $ab = ac$ and $a \neq 0$, then $b = c$.

If $a \neq 0$ and $ab = ac$, then $b = c$.


/-- **Alias** of the forward direction of `directedOn_range`. -/
theorem Directed.directedOn_range :
    ∀ {α : Type u} {ι : Sort w} {r : α → α → Prop} {f : ι → α}, Directed r f → DirectedOn r (Set.range f) := by sorry

This theorem states that for any type `α`, any sort `ι`, any binary relation `r` on `α`, and any function `f` from `ι` to `α`, if `f` is directed with respect to `r`, then the range of `f` is a directed set with respect to `r`. In other words, if for any two elements `x` and `y` in the domain of `f`, there exists an element `z` such that `f(x) ≼ f(z)` and `f(y) ≼ f(z)`, then for all pairs of elements `x` and `y` in the range of `f`, there exists an element `z` in the range of `f` such that `x ≼ z` and `y ≼ z` for the relation `r`.

If `f` is a function from a directed set `(ι, ≤)` to a type `α` such that the image of every pair of related elements in `ι` is related in `α` (i.e., `f(x) ≤ f(y)` whenever `x ≤ y`), then the image `f"[ι]` is a directed set under the relation `≤`.


theorem continuousWithinAt_iff_continuousAt_restrict :
    ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] (f : α → β) {x : α}
      {s : Set α} (h : x ∈ s), ContinuousWithinAt f s x ↔ ContinuousAt (Set.restrict s f) { val := x, property := h } :=
  by sorry

The theorem `continuousWithinAt_iff_continuousAt_restrict` states that for all types `α` and `β`, topological spaces `inst` and `inst_1` defined on these types, a function `f` from `α` to `β`, a point `x` of type `α`, and a set `s` of type `α`, if `x` is an element of `s`, then the function `f` is continuous at the point `x` within the set `s` if and only if when the domain of the function `f` is restricted to the set `s`, the function is continuous at the point `x`. In other words, restricting the domain of a function to a subset does not affect the continuity of the function at a point within that subset.

For all types `α` and `β`, topological spaces `inst` and `inst_1` on `α`, function `f : α → β`, point `x : α`, and set `s ⊆ α` containing `x`, the function `f` is continuous at `x` within `s` if and only if the restriction of `f` to `s` is continuous at `x`.


HasDerivAt.continuousOn

theorem HasDerivAt.continuousOn :
    ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {F : Type v} [inst_1 : NormedAddCommGroup F]
      [inst_2 : NormedSpace 𝕜 F] {s : Set 𝕜} {f f' : 𝕜 → F}, (∀ x ∈ s, HasDerivAt f (f' x) x) → ContinuousOn f s :=
  by sorry

This theorem states that for any type 𝕜 which is a nontrivially normed field, and any type F which is a normed additive commutative group and a normed space over 𝕜, if a function f from 𝕜 to F has a derivative at every point x in a set s, then the function f is continuous on the set s. In mathematical terms, if ∀ x ∈ s, f has derivative f'(x) at x, then f is continuous on s.

If a function between a nontrivially normed field and a normed additive commutative group, which is also a normed space over the field, has a derivative at every point in a set, then the function is continuous on that set.


theorem Positive.coe_add :
    ∀ {M : Type u_1} [inst : AddMonoid M] [inst_1 : Preorder M]
      [inst_2 : CovariantClass M M (fun x x_1 => x + x_1) fun x x_1 => x < x_1] (x y : { x // 0 < x }),
      ↑(x + y) = ↑x + ↑y :=
  by sorry

The theorem `Positive.coe_add` states that for any type `M` that forms an additive monoid and a preorder, and where addition (`fun x x_1 => x + x_1`) is a covariant function (meaning if `x < x_1` then `x + something < x_1 + something`), the sum of two strictly positive elements `x` and `y` (represented as `{ x // 0 < x }`), when coerced (or converted) back to `M`, is equivalent to the sum of the coerced elements `x` and `y`. Essentially, this theorem is establishing the property that the coercion respects addition in this context.

For any additive monoid and preorder type `M` with covariant addition, and for `x` and `y` being strictly positive elements of `M`, the coercion of `x + y` is equal to the coercion of `x` plus the coercion of `y`.


theorem IntermediateField.adjoin_univ :
    ∀ (F : Type u_3) (E : Type u_4) [inst : Field F] [inst_1 : Field E] [inst_2 : Algebra F E],
      IntermediateField.adjoin F Set.univ = ⊤ :=
  by sorry

This theorem states that for any field `F` and any field `E`, if `E` is an algebra over `F`, then the intermediate field obtained by adjoining the universal set (which includes all elements of `E`) to `F` is the top element of the lattice of intermediate fields (i.e., it is the field `E` itself). In other words, if you extend `F` by all elements of `E`, you get `E` itself.

For any field extension `E` of a field `F`, the field obtained by adjoining all elements of `E` to `F` is equal to `E`.


theorem hasDerivWithinAt_id :
    ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] (x : 𝕜) (s : Set 𝕜), HasDerivWithinAt id 1 s x := by sorry

The theorem `hasDerivWithinAt_id` states that for any nontrivially normed field `𝕜`, any element `x` of `𝕜`, and any set `s` of elements of `𝕜`, the identity function `id` has a derivative of `1` at the point `x` within the subset `s`. In mathematical terms, this means that the limit of the difference quotient as `x'` approaches `x` within `s` is `1` for the identity function, which is consistent with the standard calculus result that the derivative of the identity function is `1`.

For any nontrivially normed field `𝕜`, the identity function `id` has a derivative equal to `1` at every point `x` in `𝕜`.


theorem CategoryTheory.Preadditive.mono_of_cancel_zero :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C] {Q R : C}
      (f : Q ⟶ R),
      (∀ {P : C} (g : P ⟶ Q), CategoryTheory.CategoryStruct.comp g f = 0 → g = 0) → CategoryTheory.Mono f :=
  by sorry

The theorem `CategoryTheory.Preadditive.mono_of_cancel_zero` states that for any category `C` with preadditive structure (i.e., such that the hom-sets have an abelian group structure compatible with composition), given any two objects `Q` and `R` in `C` and a morphism `f` from `Q` to `R`, if for every object `P` in `C` and morphism `g` from `P` to `Q`, the composition `g ≫ f` being zero implies that `g` is zero, then `f` is a monomorphism. This theorem is about the cancellation property of morphisms in preadditive categories.

In a preadditive category, if every morphism with zero composition with a given morphism is the zero morphism, then the given morphism is a monomorphism.


theorem Matrix.toLin'_mul :
    ∀ {R : Type u_1} [inst : CommSemiring R] {l : Type u_3} {m : Type u_4} {n : Type u_5} [inst_1 : DecidableEq n]
      [inst_2 : Fintype n] [inst_3 : Fintype m] [inst_4 : DecidableEq m] (M : Matrix l m R) (N : Matrix m n R),
      Matrix.toLin' (M * N) = Matrix.toLin' M ∘ₗ Matrix.toLin' N :=
  by sorry

The theorem `Matrix.toLin'_mul` states that for every commutative semiring `R`, types `l`, `m`, and `n`, where `m` and `n` are finite types with decidable equality, and for every two matrices `M` and `N` with entries in `R` (where `M` has rows indexed by `l` and columns indexed by `m`, and `N` has rows indexed by `m` and columns indexed by `n`), the linear map equivalent to the matrix multiplication of `M` and `N` is equal to the composition of the linear map equivalents of `M` and `N`.

In mathematical terms, if we consider matrices as linear maps, then the multiplication of two matrices corresponds to the composition of the two corresponding linear maps.

For every commutative semiring R and finite types l, m, n with decidable equality, the matrix multiplication of two matrices M and N with entries in R, where M has dimensions l x m and N has dimensions m x n, is equal to the composition of the linear maps represented by M and N.


theorem TypeVec.appendFun_comp :
    ∀ {n : ℕ} {α₀ : TypeVec.{u_1} n} {α₁ : TypeVec.{u_2} n} {α₂ : TypeVec.{u_3} n} {β₀ : Type u_1} {β₁ : Type u_2}
      {β₂ : Type u_3} (f₀ : TypeVec.Arrow α₀ α₁) (f₁ : TypeVec.Arrow α₁ α₂) (g₀ : β₀ → β₁) (g₁ : β₁ → β₂),
      (TypeVec.comp f₁ f₀ ::: g₁ ∘ g₀) = TypeVec.comp (f₁ ::: g₁) (f₀ ::: g₀) :=
  by sorry

The theorem `TypeVec.appendFun_comp` states that for any natural number `n` and any six categories `α₀`, `α₁`, `α₂`, `β₀`, `β₁`, `β₂` in `TypeVec n` and `Type`, and any two `TypeVec.Arrow`s `f₀` and `f₁` from `α₀` to `α₁` and `α₁` to `α₂` respectively, and two functions `g₀` and `g₁` from `β₀` to `β₁` and `β₁` to `β₂` respectively, the composition of `f₁` and `f₀` appended with the composition of `g₁` and `g₀` is equal to the composition of `f₁` appended with `g₁` and `f₀` appended with `g₀`.

In other words, the theorem is expressing a property of the composition operation in the category of `TypeVec n` and `Type`: the composition operation is associative and respects the concatenation (appending) of arrows. This is a basic property one would expect from a category, and is similar to function composition in set theory.

For any natural number `n` and categories `α₀, α₁, α₂, β₀, β₁, β₂` in `TypeVec n` and `Type`, and functions `f₀ : α₀ → α₁`, `f₁ : α₁ → α₂`, `g₀ : β₀ → β₁`, and `g₁ : β₁ → β₂`, the diagram `(f₁ ∘ f₀) ∘ (g₁ ∘ g₀) ↔ (f₁ ∘ g₁) ∘ (f₀ ∘ g₀)` holds in the category of `TypeVec n` and `Type`.


theorem PNat.gcd_eq : ∀ (a b : ℕ+), PNat.gcdD a b = PNat.gcd a b := by sorry

The theorem `PNat.gcd_eq` states that for any two positive natural numbers `a` and `b`, the value of the greatest common divisor computed using the `gcdD` function, which is defined as the `a` value of the extended greatest common divisor, is equal to the greatest common divisor computed using the standard `gcd` function.

For all natural numbers `a` and `b` greater than 0, `gcd a b` equals the `a`-th component of the extended greatest common divisor of `a` and `b`.


theorem Complex.exp_log : ∀ {x : ℂ}, x ≠ 0 → Complex.exp (Complex.log x) = x := by sorry

This theorem states that, for any non-zero complex number `x`, the exponential of the logarithm of `x` equals `x` itself. In other words, the functions `Complex.exp` and `Complex.log` are inverses of each other when the domain is the set of non-zero complex numbers. This mirrors the standard property of exponential and logarithm functions in real number mathematics.

For any non-zero complex number `x`, `Complex.exp (Complex.log x) = x` holds. (The functions `Complex.exp` and `Complex.log` are inverses on the non-zero complex numbers.)


theorem MeasureTheory.condexp_sub :
    ∀ {α : Type u_1} {F' : Type u_3} [inst : NormedAddCommGroup F'] [inst_1 : NormedSpace ℝ F']
      [inst_2 : CompleteSpace F'] {m m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} {f g : α → F'},
      MeasureTheory.Integrable f μ →
        MeasureTheory.Integrable g μ →
          MeasureTheory.condexp m μ (f - g) =ᶠ[MeasureTheory.Measure.ae μ]
            MeasureTheory.condexp m μ f - MeasureTheory.condexp m μ g :=
  by sorry

The theorem `MeasureTheory.condexp_sub` states that for any two functions `f` and `g` from a type `α` to a normed additively commutative group `F'`, equipped with a normed space structure and complete space structure, and given two measurable spaces `m` and `m0` and a measure `μ`, if `f` and `g` are both integrable with respect to `μ`, then the conditional expectation of the difference of `f` and `g` is almost everywhere equal to the difference of the conditional expectations of `f` and `g` with respect to the measure `μ`. This means, intuitively, that the operation of taking conditional expectations is linear: the expectation of a difference is the difference of the expectations.

For measurable functions `f` and `g` from a measure space to a normed additively commutative group, if both are integrable, then their conditional expectations with respect to a measure `μ` differ almost everywhere by the difference of their unconditional expectations.


theorem Ideal.mem_map_iff_of_surjective :
    ∀ {R : Type u} {S : Type v} {F : Type u_1} [inst : Semiring R] [inst_1 : Semiring S] [inst_2 : FunLike F R S]
      [rc : RingHomClass F R S] (f : F),
      Function.Surjective ⇑f → ∀ {I : Ideal R} {y : S}, y ∈ Ideal.map f I ↔ ∃ x ∈ I, f x = y :=
  by sorry

This theorem states that for any two types `R` and `S`, which have semiring structures, and a type `F` that is function-like from `R` to `S` with a ring homomorphism class, given a function `f` of type `F`, if the function `f` is surjective, then for any ideal `I` of `R` and any element `y` of `S`, `y` belongs to the ideal generated by the image of `I` under `f` if and only if there exists an element `x` in `I` such that `f(x)=y`. In other words, it provides a criterion for an element of `S` to belong to the ideal mapped from `R` under a surjective ring homomorphism.

For any surjective ring homomorphism `f` from semiring `R` to semiring `S`, and ideal `I` of `R`, an element `y` in `S` belongs to the image ideal of `I` under `f` if and only if there exists an element `x` in `I` such that `f(x) = y`.


theorem Nat.dvd_of_mem_primeFactors : ∀ {n p : ℕ}, p ∈ n.primeFactors → p ∣ n := by sorry

This theorem states that for any natural numbers `n` and `p`, if `p` is a member of the prime factors of `n`, then `p` divides `n`. In mathematical terms, for any pair of integers $(n, p)$, if $p$ is a prime factor of $n$, then there exists an integer $k$ such that $n = p \cdot k$.

If a prime number `p` is a factor of natural number `n`, then `p` divides `n`. (Equivalently, every prime factor of `n` is a divisor of `n`.)


theorem ProbabilityTheory.kernel.indep_limsup_self :
    ∀ {α : Type u_1} {Ω : Type u_2} {ι : Type u_3} {_mα : MeasurableSpace α} {m0 : MeasurableSpace Ω}
      {κ : ↥(ProbabilityTheory.kernel α Ω)} {μα : MeasureTheory.Measure α} [inst : ProbabilityTheory.IsMarkovKernel κ]
      {s : ι → MeasurableSpace Ω} {α_1 : Type u_4} {p : Set ι → Prop} {f : Filter ι} {ns : α_1 → Set ι},
      (∀ (n : ι), s n ≤ m0) →
        ProbabilityTheory.kernel.iIndep s κ μα →
          (∀ (t : Set ι), p t → tᶜ ∈ f) →
            Directed (fun x x_1 => x ≤ x_1) ns →
              (∀ (a : α_1), p (ns a)) →
                (∀ (n : ι), ∃ a, n ∈ ns a) →
                  ProbabilityTheory.kernel.Indep (Filter.limsup s f) (Filter.limsup s f) κ μα :=
  by sorry

This theorem, `ProbabilityTheory.kernel.indep_limsup_self`, says that for all types `α`, `Ω`, and `ι`, and given a measurable space `α`, a measurable space `Ω`, a kernel `κ` belonging to the set of probability theory kernels between `α` and `Ω`, a measure `μα` on `α`, and a function `s` that maps `ι` to measurable spaces `Ω`, if every measurable space `s(n)` is a subset of `m0`, and the kernel is independent with respect to this family of measurable spaces `s`, and for another type `α_1`, a property `p` on sets of `ι`, a filter `f` on `ι`, and a function `ns` mapping `α_1` to sets of `ι`, if every complement of a set on which `p` holds belongs to the filter `f`, and the function `ns` is directed by the less than or equal to relation, and the property `p` holds for all sets `ns(a)`, and for every `n` in `ι` there exists an `a` such that `n` is an element of `ns(a)`, then the limit superior of the function `s` along the filter `f` is independent with respect to the kernel and the measure.

In other words, this theorem deals with the independence properties of limit superior of measurable spaces along a filter in the context of probability theory. Limit superior is a limit-like quantity that measures the "eventual" upper bound of a sequence of real numbers. The set of assumptions lays the groundwork for understanding how these measurable spaces, kernels, and measures interact under the conditions specified.

Given a probability theory kernel, a measure, a family of measurable spaces, a filter on indices, and a function mapping indices to sets such that the property `p` holds for the sets and the limit superior exists, if the kernel is independent with respect to the family of measurable spaces and the filter satisfies certain conditions, then the limit superior is independent with respect to the kernel and the measure.


theorem Finset.sum_pair :
    ∀ {α : Type u_3} {β : Type u_4} {f : α → β} [inst : AddCommMonoid β] [inst_1 : DecidableEq α] {a b : α},
      a ≠ b → (Finset.sum {a, b} fun x => f x) = f a + f b :=
  by sorry

The theorem `Finset.sum_pair` states that, for any types `α` and `β`, a function `f` which maps from `α` to `β`, an instance of an additive commutative monoid `β`, an instance of decidable equality on `α`, and distinct elements `a` and `b` of type `α`, the sum of the values of the function `f` over the finite set `{a, b}` is equal to the sum of the values of `f` at `a` and `f` at `b`. In other words, if we have a set containing just two distinct elements, the sum of the function applied to those elements is equal to the sum of the function applied to each element individually.

For any additive commutative monoid β, decidably equal types α, function f from α to β, and distinct elements a and b in α, the sum of f over the finite set {a, b} equals the sum of f(a) and f(b).


theorem tsum_prod' :
    ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : AddCommMonoid α] [inst_1 : TopologicalSpace α]
      [inst_2 : ContinuousAdd α] [inst_3 : T3Space α] {f : β × γ → α},
      Summable f → (∀ (b : β), Summable fun c => f (b, c)) → ∑' (p : β × γ), f p = ∑' (b : β) (c : γ), f (b, c) :=
  by sorry

This theorem is about the summation of a function that takes pairs of values as input. Specifically, it states that for any types `α`, `β`, and `γ`, given `α` is an additive commutative monoid and a topological space, and addition operation on `α` is continuous, if a function `f` from pairs of `β` and `γ` to `α` is summable, and for all `b` in `β`, the function obtained by fixing the first argument of `f` to `b` is also summable, then the infinite sum over all pairs `(b, c)` of `f` equals to the double infinite sum over `b` and `c` of `f`. This is a property of rearranging terms in infinite sums, and it relies on the assumption that the original sum and the terms obtained by fixing the first argument of function are all summable.

Let `α` be an additive commutative monoid and topological space with continuous addition, and let `f : β × γ → α` be a summable function such that for all `b ∈ β`, the function `x => f (b, x)` is also summable. Then the infinite sum of `f` equals the double infinite sum over `b` and `c` of `f (b, c)`.


theorem Nat.size_le : ∀ {m n : ℕ}, Nat.size m ≤ n ↔ m < 2 ^ n := by sorry

This theorem, `Nat.size_le`, asserts that for any two natural numbers `m` and `n`, the size of `m` (i.e., the length of its binary representation) is less than or equal to `n` if and only if `m` is less than 2 to the power `n`. This theorem establishes a relationship between the size of a natural number in binary and the powers of 2, providing a way to compare natural numbers and their binary sizes.

The size of a natural number in binary is less than or equal to the given natural number if and only if the number is less than 2 raised to the power of that number.


theorem MeasureTheory.hasFiniteIntegral_of_bounded :
    ∀ {α : Type u_1} {β : Type u_2} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} [inst : NormedAddCommGroup β]
      [inst_1 : MeasureTheory.IsFiniteMeasure μ] {f : α → β} {C : ℝ},
      (∀ᵐ (a : α) ∂μ, ‖f a‖ ≤ C) → MeasureTheory.HasFiniteIntegral f μ :=
  by sorry

The theorem `MeasureTheory.hasFiniteIntegral_of_bounded` states that for any types `α` and `β`, with `α` having a measurable space structure and `β` a normed add commutative group structure, and for any measure `μ` on `α` which is a finite measure, and for any function `f` from `α` to `β`, and for any real number `C`, if almost every `a` in `α` under measure `μ` has the property that the norm of `f(a)` is less than or equal to `C`, then `f` has a finite integral with respect to measure `μ`. In other words, if a function is almost everywhere bounded by a constant in a finite measure space, then it has a finite integral in that space.

If a function from a measurable space with a finite measure to a normed add commutative group is almost everywhere bounded, then it has a finite integral with respect to the measure.


theorem linearIndependent_fin_cons :
    ∀ {K : Type u_3} {V : Type u} [inst : DivisionRing K] [inst_1 : AddCommGroup V] [inst_2 : Module K V] {x : V}
      {n : ℕ} {v : Fin n → V},
      LinearIndependent K (Fin.cons x v) ↔ LinearIndependent K v ∧ x ∉ Submodule.span K (Set.range v) :=
  by sorry

The theorem `linearIndependent_fin_cons` states that for any division ring `K`, any additively commutative group `V`, any `K`-module `V`, any vector `x` from `V`, any natural number `n`, and any function `v` from a `n`-element finite type to `V`, the vectors defined by the function `Fin.cons x v` are linearly independent over `K` if and only if the vectors defined by `v` are linearly independent over `K` and the vector `x` is not in the span of the set of vectors given by the range of `v`. In simpler terms, it states that adding a new vector at the beginning of a linearly independent set of vectors will result in a linearly independent set if and only if the newly added vector is not a linear combination of the other vectors.

Given a division ring K, an additively commutative group V, a K-module V, a vector x in V, a natural number n, and a function v from a n-element finite type to V, the vectors Fin.cons x v are linearly independent over K if and only if the vectors v are linearly independent over K and x is not in the span of v.


theorem contDiff_pi :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type uE} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {n : ℕ∞} {ι : Type u_3} [inst_3 : Fintype ι] {F' : ι → Type u_5}
      [inst_4 : (i : ι) → NormedAddCommGroup (F' i)] [inst_5 : (i : ι) → NormedSpace 𝕜 (F' i)] {Φ : E → (i : ι) → F' i},
      ContDiff 𝕜 n Φ ↔ ∀ (i : ι), ContDiff 𝕜 n fun x => Φ x i :=
  by sorry

The theorem `contDiff_pi` states that for any non-trivially normed field `𝕜`, normed additive commutative group `E`, normed space `𝕜 E`, a function `Φ : E → (i : ι) → F' i` where `F' : ι → Type u_5` is a normed additive commutative group and normed space `𝕜 (F' i)` for each `i : ι`, the function `Φ` is continuously differentiable of any order `n` if and only if for each `i : ι`, the function `fun x => Φ x i` is continuously differentiable of order `n`. In other words, a function between normed spaces is continuously differentiable of a certain order if and only if each of its component functions is.

A function `Φ : E → (i : ι) → F' i` between normed spaces is continuously differentiable of order `n` if and only if each component function `fun x => Φ x i` is.


Sym.ext

theorem Sym.ext : ∀ {α : Type u_1} {n : ℕ} {s₁ s₂ : Sym α n}, ↑s₁ = ↑s₂ → s₁ = s₂ := by sorry

The theorem `Sym.ext` asserts that for any type `α`, any natural number `n`, and any two symmetric powers `s₁` and `s₂` of `α` of order `n`, if the underlying multisets of `s₁` and `s₂` are equal (denoted by `↑s₁ = ↑s₂`), then `s₁` and `s₂` themselves must be equal. In other words, two n-tuples are considered identical in the nth symmetric power if they consist of the same elements, regardless of their order.

In the n-th symmetric power of a type α, two multisets represent equal elements if and only if their corresponding symmetric powers are equal.


theorem Int.add_le_add : ∀ {a b c d : ℤ}, a ≤ b → c ≤ d → a + c ≤ b + d := by sorry

This theorem states that for any four integers `a`, `b`, `c`, `d`, if `a` is less than or equal to `b` and `c` is less than or equal to `d`, then the sum of `a` and `c` is also less than or equal to the sum of `b` and `d`. In other words, in the integer domain, the sum of two quantities will not exceed the sum of their upper bounds.

For all integers a, b, c, and d, if a <= b and c <= d then a + c <= b + d.


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

This theorem states that for any type `α` equipped with an addition operation and a less than or equal to relation, if the addition operation and the less than or equal to relation are related by the contravariant class relation with the swap of addition operation, then for any three elements `a`, `b`, and `c` of the type `α` or the special element `⊤` (coming from the `WithTop` construction), if `a` is not `⊤` and `b` plus `a` is less than or equal to `c` plus `a`, then `b` is less than or equal to `c`. In other words, it's saying if we add the same non-top element to two elements, and it doesn't change the order of the elements, then the two elements must have been in that same order to begin with.

If `α` is a type with an addition operation and a less than or equal to relation such that addition is opposite-preserving with respect to the less than or equal to relation, then for all `a, b, c` in `α` or the top element `⊤`, if `a ≠ ⊤` and `a + b ≤ a + c`, then `b ≤ c`.


theorem Polynomial.eq_C_of_degree_eq_zero :
    ∀ {R : Type u} [inst : Semiring R] {p : Polynomial R},
      Polynomial.degree p = 0 → p = Polynomial.C (Polynomial.coeff p 0) :=
  by sorry

The theorem `Polynomial.eq_C_of_degree_eq_zero` states that for any semiring `R` and any polynomial `p` over `R`, if the degree of `p` is zero, then `p` is equal to the constant polynomial `C` with coefficient equal to the coefficient of `X^0` in `p`. In other words, if the degree of a polynomial is zero, this polynomial is just a constant term, which is the coefficient of `X^0`.

For any semiring `R` and polynomial `p` over `R` of degree zero, `p` equals the constant polynomial with coefficient equal to `p.coeff 0`.


theorem MeasureTheory.integral_map :
    ∀ {α : Type u_1} {G : Type u_5} [inst : NormedAddCommGroup G] [inst_1 : NormedSpace ℝ G] {m : MeasurableSpace α}
      {μ : MeasureTheory.Measure α} {β : Type u_7} [inst_2 : MeasurableSpace β] {φ : α → β},
      AEMeasurable φ μ →
        ∀ {f : β → G},
          MeasureTheory.AEStronglyMeasurable f (MeasureTheory.Measure.map φ μ) →
            ∫ (y : β), f y ∂MeasureTheory.Measure.map φ μ = ∫ (x : α), f (φ x) ∂μ :=
  by sorry

This theorem, `MeasureTheory.integral_map`, states that for any types `α`, `G`, and `β`, with `G` being a normed addition commutative group and also a normed space over the real numbers, and given a measurable space `m` on `α`, a measure `μ` on that space, and a function `φ` from `α` to `β` that is almost everywhere measurable, then for any function `f` from `β` to `G` that is almost everywhere strongly measurable with respect to the pushforward measure of `φ` applied to `μ`, the integral of `f` with respect to the pushforward measure equals the integral of the composition of `f` and `φ` with respect to the original measure `μ`. In other words, the theorem states that the integral of a function over the image of a measure under a transformation is equal to the integral of the composed function over the original measure, provided the conditions of almost everywhere measurability are met.

For any measurable space `(α, μ)`, normed additive commutative group and normed space `(G, ||||)` over the real numbers, almost everywhere measurable function `φ: α → β`, almost everywhere strongly measurable function `f: β → (G, ||||)`, and almost everywhere measurable measure `ν = φ_\*μ`, the integral of `f` with respect to `ν` equals the integral of `f ∘ φ` with respect to `μ`.


theorem Polynomial.eval_comp :
    ∀ {R : Type u} [inst : CommSemiring R] {p q : Polynomial R} {x : R},
      Polynomial.eval x (Polynomial.comp p q) = Polynomial.eval (Polynomial.eval x q) p :=
  by sorry

The theorem `Polynomial.eval_comp` states that for any type `R` with a commutative semiring structure, and any two polynomials `p` and `q` over `R`, and for any element `x` of `R`, the evaluation of the composite of `p` and `q` at `x` is equal to the evaluation of `p` at the result of evaluating `q` at `x`. In other words, if you compose two polynomials and then evaluate the result at a point, you get the same answer as if you first evaluated the inner polynomial at that point, and then evaluated the outer polynomial at that result. This is written mathematically as $(p\circ q)(x) = p(q(x))$.

For any commutative semiring `R`, polynomials `p` and `q` over `R`, and element `x` of `R`, $(p\circ q)(x) = p(q(x))$.


theorem exists_seq_strictAnti_tendsto :
    ∀ {α : Type u} [inst : TopologicalSpace α] [inst_1 : LinearOrder α] [inst_2 : OrderTopology α]
      [inst_3 : DenselyOrdered α] [inst_4 : NoMaxOrder α] [inst_5 : FirstCountableTopology α] (x : α),
      ∃ u, StrictAnti u ∧ (∀ (n : ℕ), x < u n) ∧ Filter.Tendsto u Filter.atTop (nhds x) :=
  by sorry

This theorem states that for any type `α` that has a topology, a linear order, an order topology, is densely ordered, has no maximum order, and a first countable topology, and for any element `x` of type `α`, there exists a sequence `u` that meets the following conditions:

- `u` is strictly antitone, i.e., if `a < b` then `u b < u a`.
- For all natural numbers `n`, `x` is less than `u n`.
- The sequence `u` tends to `x` as it goes to infinity, i.e., for every open set around `x`, all but finitely many elements of the sequence `u` are in that open set.

For any densely ordered, first countable, no-maximum, topological space `(α, ≤, top)` with order topology, there exists a strictly antitone sequence `{u_n}` in `α` such that `x ≤ u_n` for all `n` and `x` is the limit of `{u_n}` as `n` approaches infinity.


theorem AlgebraicGeometry.StructureSheaf.isUnit_to_basicOpen_self :
    ∀ (R : Type u) [inst : CommRing R] (f : R),
      IsUnit ((AlgebraicGeometry.StructureSheaf.toOpen R (PrimeSpectrum.basicOpen f)) f) :=
  by sorry

The theorem `AlgebraicGeometry.StructureSheaf.isUnit_to_basicOpen_self` asserts that for any commutative ring `R` and any element `f` from `R`, the element `f` is a unit in the structure sheaf of the basic open subset of the prime spectrum of `R` not containing `f`. In other words, for each `f` in a commutative ring `R`, `f` has a multiplicative inverse in the algebraic geometry structure sheaf over the open subset of prime ideals not containing `f`.

For every commutative ring R and element f, the function field of the basic open subset of the prime spectrum of R not containing f contains the multiplicative inverse of f.


theorem PosNum.bit0_of_bit0 : ∀ (n : PosNum), bit0 n = PosNum.bit0 n := by sorry

This theorem states that for every positive number `n`, the operation `bit0` applied to `n` is equal to the operation `PosNum.bit0` applied to the same `n`. In other words, the `bit0` operation, which doubles an input value, performs the same operation as `PosNum.bit0` when the input is a positive number.

For all positive numbers `n`, `bit0 n` equals `PosNum.bit0 n`.


theorem inter_minimals_preimage_inter_eq_of_rel_iff_rel_on :
    ∀ {β : Type u_2} {α : Type u_1} {f : α → β} {r : α → α → Prop} {s : β → β → Prop} {x : Set α},
      (∀ ⦃a a' : α⦄, a ∈ x → a' ∈ x → (r a a' ↔ s (f a) (f a'))) →
        ∀ (y : Set β), x ∩ f ⁻¹' minimals s (f '' x ∩ y) = minimals r (x ∩ f ⁻¹' y) :=
  by sorry

The theorem `inter_minimals_preimage_inter_eq_of_rel_iff_rel_on` states the following:

Given two types, `α` and `β`, a function `f` from `α` to `β`, a relation `r` on `α`, a relation `s` on `β`, and a set `x` of `α`, if for all pairs `a` and `a'` in `x`, the relation `r` holds between `a` and `a'` if and only if the relation `s` holds between `f(a)` and `f(a')`, then for any set `y` of `β`, the intersection of `x` and the preimage under `f` of the minimal elements of the intersection of the image of `x` under `f` and `y` with respect to `s`, is equal to the set of minimal elements of the intersection of `x` and the preimage of `y` under `f` with respect to `r`.

In other words, this theorem relates the minimal elements of a preimage under a function with the minimal elements of the original set, given a particular relationship between the function and the relational structure on the domain and codomain.

If for all pairs of elements in a set x, the relation r holds between them if and only if s holds between their images under f, then the minimal elements of the intersection of x and the preimage of a set y under f with respect to r are equal to the minimal elements of the intersection of x and the image of y under f with respect to s.


theorem SemiconjBy.neg_left :
    ∀ {R : Type x} [inst : Mul R] [inst_1 : HasDistribNeg R] {a x y : R}, SemiconjBy a x y → SemiconjBy (-a) x y := by
  sorry

The theorem `SemiconjBy.neg_left` states that for any type `R` that has a multiplication operation (`Mul R`) and a distributable negation operation (`HasDistribNeg R`), and for any three elements `a`, `x`, and `y` of this type `R`, if `a` is semiconjugate to `y` by `x` (i.e., `a * x = y * a`), then `-a` (the negation of `a`) is also semiconjugate to `y` by `x` (i.e., `-a * x = y * -a`). This theorem captures a property of semiconjugacy under negation in the context of multiplication in a ring (or similar mathematical structure).

If `a`, `x`, and `y` are elements of a type `R` with multiplication and distributive negation, and `a` is semiconjugate to `y` by `x`, then `-a` is semiconjugate to `y` by `x`.


theorem Dioph.const_dioph : ∀ {α : Type} (n : ℕ), Dioph.DiophFn (Function.const (α → ℕ) n) := by sorry

The theorem `Dioph.const_dioph` states that for any type `α` and natural number `n`, the constant function `Function.const (α → ℕ) n`, which takes any value from `α` and returns the constant `n`, is Diophantine. A function is considered Diophantine if its graph is Diophantine, meaning the set of its inputs and outputs can be expressed as the solutions to a Diophantine equation.

The constant function from type `α` to natural numbers `Function.const (α → ℕ) n` is Diophantine for any type `α` and natural number `n`.


/-- `choose n r` is maximised when `r` is `n/2`.  -/
theorem Nat.choose_le_middle : ∀ (r n : ℕ), Nat.choose n r ≤ Nat.choose n (n / 2) := by sorry

The theorem `Nat.choose_le_middle` states that for any two natural numbers `r` and `n`, the binomial coefficient ("n choose r") is always less than or equal to the binomial coefficient when choosing half of `n` (i.e., "n choose n/2"). This theorem essentially suggests that the binomial coefficient is maximized when the number of elements chosen is half the total number of elements.

For all natural numbers r and n, the binomial coefficient n choose r is less than or equal to n choose n/2.


ContDiffAt.hasStrictFDerivAt

/-- If a function is `C^n` with `1 ≤ n` around a point, then the derivative of `f` at this point
is also a strict derivative.  -/
theorem ContDiffAt.hasStrictFDerivAt :
    ∀ {n : ℕ∞} {𝕂 : Type u_1} [inst : RCLike 𝕂] {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'}, ContDiffAt 𝕂 n f x → 1 ≤ n → HasStrictFDerivAt f (fderiv 𝕂 f x) x :=
  by sorry

The theorem `ContDiffAt.hasStrictFDerivAt` states that if a function `f` is `n` times continuously differentiable at a point `x` in a normed space over a real-like field `𝕂`, with `n` being any countably infinite natural number and `1 ≤ n`, then the derivative of `f` at this point `x` is also a strict derivative. Here, a strict derivative refers to the fact that the derivative of `f` at `x`, given by `fderiv 𝕂 f x`, is a linear approximation of `f` near `x` that is not just accurate but also has optimal error bounds. This theorem is a key result in differential calculus in the context of real or complex normed vector spaces.

If a function `f` is `n` times continuously differentiable at a point `x` in a normed space over a real- or complex-number field, then its derivative at `x` is a strict derivative.


theorem Function.Surjective.of_comp_iff' :
    ∀ {α : Sort u_1} {β : Sort u_2} {γ : Sort u_3} {f : α → β},
      Function.Bijective f → ∀ (g : γ → α), Function.Surjective (f ∘ g) ↔ Function.Surjective g :=
  by sorry

This theorem states that for any types `α`, `β`, and `γ`, and for any function `f` from `α` to `β` that is bijective (both injective and surjective), for any function `g` from `γ` to `α`, the composition of `f` and `g` (denoted by `f ∘ g`) is surjective if and only if `g` itself is surjective. In other words, if every element of `β` can be obtained by applying `f ∘ g` to some element of `γ`, then every element of `α` can also be obtained by applying `g` to some element of `γ`.

For any types `α`, `β`, and `γ`, if `f: α → β` is bijective and `g: γ → α`, then `f ∘ g` is surjective if and only if `g` is surjective.


IsIntegral.algebraMap

theorem IsIntegral.algebraMap :
    ∀ {R : Type u_1} {A : Type u_2} {B : Type u_3} [inst : CommRing R] [inst_1 : CommRing A] [inst_2 : Ring B]
      [inst_3 : Algebra R A] [inst_4 : Algebra R B] [inst_5 : Algebra A B] [inst_6 : IsScalarTower R A B] {x : A},
      IsIntegral R x → IsIntegral R ((algebraMap A B) x) :=
  by sorry

The theorem `IsIntegral.algebraMap` states that for any commutative rings `R` and `A`, a ring `B`, and algebras over `R` of `A` and `B`, as well as an algebra over `A` of `B`, if the algebra structures form a scalar tower, then any element `x` of `A` that is integral over `R` (i.e., it is a root of some monic polynomial with coefficients in `R`) remains integral when mapped from `A` to `B` using the algebra embedding (denoted by `algebraMap`). Here, the scalar tower property ensures the compatibility of the algebra structures.

If `R` is a commutative ring, `A` and `B` are algebras over `R`, `A` is an algebra over `B`, and `x` is an element of `A` integral over `R` with compatible algebra structures forming a scalar tower, then `x` is also integral over `R` in `B`.


theorem Mathlib.Data.Multiset.Basic._auxLemma.72 :
    ∀ {α : Type u_1} {p : α → Prop} [inst : DecidablePred p] {a : α} {s : Multiset α},
      (a ∈ Multiset.filter p s) = (a ∈ s ∧ p a) :=
  by sorry

The theorem `Mathlib.Data.Multiset.Basic._auxLemma.72` states that for any type `α`, any decidable predicate `p` on `α`, any item `a` of type `α`, and any `Multiset` `s` of type `α`, the item `a` is in the filtered multiset (where the filter is given by the predicate `p`) if and only if `a` is in the original multiset `s` and `a` satisfies the predicate `p`. In other words, filtering a multiset by a predicate does not introduce new elements, and it only retains those elements from the original multiset that satisfy the predicate.

For any type `α`, decidable predicate `p` on `α`, item `a` of type `α`, and `Multiset` `s` of type `α`, the item `a` is in the filtered multiset (defined as the multiset of elements in `s` that satisfy `p`) if and only if `a` is in `s` and `p(a)` holds.


theorem Mathlib.Data.Multiset.Basic._auxLemma.34 :
    ∀ {α : Type u_1} {l₁ l₂ : List α}, (↑l₁ ≤ ↑l₂) = List.Subperm l₁ l₂ := by sorry

This theorem states that for any type `α` and any two lists `l₁` and `l₂` of type `α`, the statement that the multiset generated from `l₁` is a subset of the multiset generated from `l₂` (denoted as `↑l₁ ≤ ↑l₂`) is equivalent to the statement that `l₁` is a sublist of a permutation of `l₂` (denoted as `List.Subperm l₁ l₂`). In other words, it establishes an equivalence between subset relationships in multisets and the `Subperm` relation for lists, which is a sublist relationship that respects multiplicities of elements.

The multiset generated by a list is a subset of another multiset if and only if the first list is a sublist of a permutation of the second list.


theorem Mathlib.Data.Multiset.Basic._auxLemma.23 : ∀ {a b c : Prop}, (a ∨ b → c) = ((a → c) ∧ (b → c)) := by sorry

This theorem states that for any three propositions `a`, `b` and `c`, the proposition that "`a` OR `b` implies `c`" is equivalent to the conjunction "`a` implies `c` AND `b` implies `c`". In other words, if `c` follows from either `a` or `b`, then `c` should follow from `a` and also from `b`.

(`a ∨ b ↔ a → c ∧ b → c`) states that `a` OR `b` implies `c` if and only if `a` implies `c` and `b` implies `c`.


theorem Mathlib.Data.Multiset.Basic._auxLemma.24 :
    ∀ {α : Sort u_1} {p q : α → Prop}, (∀ (x : α), p x ∧ q x) = ((∀ (x : α), p x) ∧ ∀ (x : α), q x) := by sorry

This theorem, `Mathlib.Data.Multiset.Basic._auxLemma.24`, states that for any type `α` and for any two predicates `p` and `q` on that type, the proposition that every `x` of type `α` satisfies both `p` and `q` is equivalent to the conjunction of the propositions that every `x` of type `α` satisfies `p` and every `x` of type `α` satisfies `q`. In other words, saying "every element has properties P and Q" is the same as saying "every element has property P and every element has property Q".

For any type `α` and predicates `p` and `q` on `α`, `(∀ x : α, p x) ↔ (p : Prop) ∧ (q : Prop) ∧ (∀ x : α, q x)` (The proposition that every element of a type `α` satisfies both predicates `p` and `q` is equivalent to the conjunction of the propositions that every element satisfies `p` and every element satisfies `q`.)


/-- A morphism in `SimplexCategory` is an epimorphism if and only if it is a surjective function
 -/
theorem SimplexCategory.epi_iff_surjective :
    ∀ {n m : SimplexCategory} {f : n ⟶ m},
      CategoryTheory.Epi f ↔ Function.Surjective ⇑(SimplexCategory.Hom.toOrderHom f) :=
  by sorry

This theorem is stating that a morphism in the `SimplexCategory` is an epimorphism (a morphism which is right-cancellable) if and only if it is a surjective function (a function where every element in the codomain has a pre-image in the domain). Here, `SimplexCategory` is a category where objects are natural numbers, and morphisms from `n` to `m` are monotone functions from the finite set of size `n+1` to the finite set of size `m+1`. The theorem applies to any given natural numbers `n` and `m` in `SimplexCategory` and any morphism `f` from `n` to `m`. The surjectivity of the function is determined by the `Function.Surjective` predicate, which checks that every element in the codomain is the image of at least one element in the domain.

A morphism in the SimplexCategory is an epimorphism if and only if it is a surjective function.


theorem Equiv.Perm.disjoint_prod_right :
    ∀ {α : Type u_1} {f : Equiv.Perm α} (l : List (Equiv.Perm α)),
      (∀ g ∈ l, Equiv.Perm.Disjoint f g) → Equiv.Perm.Disjoint f (List.prod l) :=
  by sorry

The theorem `Equiv.Perm.disjoint_prod_right` states that for any type `α`, and any permutation `f` of this type, given a list `l` of such permutations, if `f` is disjoint with every permutation in the list `l` (meaning for every element, it is either fixed by `f` or by the permutation in `l`), then `f` is also disjoint with the product of all permutations in the list `l`. This product of permutations is computed as if applying each permutation in order, from right to left.

If a permutation is disjoint with every permutation in a list, then it is disjoint with their right-to-left product.


theorem mem_leftCoset_iff : ∀ {α : Type u_1} [inst : Group α] {s : Set α} {x : α} (a : α), x ∈ a • s ↔ a⁻¹ * x ∈ s := by
  sorry

This theorem, `mem_leftCoset_iff`, states that for any type `α` that forms a group and for any set `s` of elements from that group, a given element `x` is in the left coset of `s` under an element `a` if and only if the product of the inverse of `a` and `x` is in `s`. Here, the left coset of `s` under `a` is represented by `a • s` and the inverse of `a` is represented by `a⁻¹`. The product of the inverse of `a` and `x` is denoted by `a⁻¹ * x`. This provides a condition for membership in left cosets in group theory.

For any group type `α` and set `s` of elements, an element `x` lies in the left coset `a • s` if and only if `a⁻¹ * x ∈ s`.


theorem Mathlib.NumberTheory.Padics.PadicVal._auxLemma.7 :
    ∀ {p n : ℕ}, (padicValNat p n = 0) = (p = 1 ∨ n = 0 ∨ ¬p ∣ n) := by sorry

This theorem states that for any two natural numbers `p` and `n`, the `p`-adic valuation of `n` is zero if and only if either `p` equals 1, `n` equals 0, or `p` does not divide `n`. In mathematical terminology, for `p, n ∈ ℕ`, we have `padicValNat(p, n) = 0` if and only if `p = 1`, `n = 0`, or `p ∤ n`.

The `p`-adic valuation of a natural number `n` is zero if and only if `p` is equal to 1, `n` is zero, or `p` does not divide `n`.


/-- The function `fun (x, y) => x ^ y` is infinitely smooth at `(x, y)` unless `x = 0`.  -/
theorem Real.contDiffAt_rpow_of_ne : ∀ (p : ℝ × ℝ), p.1 ≠ 0 → ∀ {n : ℕ∞}, ContDiffAt ℝ n (fun p => p.1 ^ p.2) p := by
  sorry

The theorem `Real.contDiffAt_rpow_of_ne` states that for any pair of real numbers `(x, y)`, the function `f(x, y) = x ^ y` is infinitely continuously differentiable at the point `(x, y)`, provided that `x` is not equal to zero. This holds for any value of `n`, where `n` is a countably infinite integer (ℕ∞).

For any `x ≠ 0` in ℝ and any `y` in ℝ, the function `x ^ y` is infinitely differentiable as a function of `x` at the point `(x, y)`.


theorem Mathlib.Data.Finset.Prod._auxLemma.25 :
    ∀ {α : Type u_1} [inst : DecidableEq α] {a : α} {s₁ s₂ : Finset α}, (a ∈ s₁ ∩ s₂) = (a ∈ s₁ ∧ a ∈ s₂) := by sorry

This theorem, named `Mathlib.Data.Finset.Prod._auxLemma.25`, states that for any type `α` with a decidable equality (`DecidableEq α`), and for any elements `a` of type `α` and `s₁`, `s₂` of type `Finset α` (which are finite sets of elements of type `α`), the statement "`a` is in the intersection of `s₁` and `s₂`" is equivalent to the statement "`a` is in `s₁` and `a` is in `s₂`". This theorem essentially formalizes the definition of intersection for finite sets in the context of Lean 4.

For any type `α` with decidable equality and any finite sets `s₁` and `s₂` of elements from `α`, the element `a` belongs to the intersection of `s₁` and `s₂` if and only if it belongs to both `s₁` and `s₂`.


theorem Mathlib.Data.Finset.Prod._auxLemma.29 :
    ∀ {α : Type u_1} [inst : DecidableEq α] {s : Finset α} {x : α × α}, (x ∈ Finset.diag s) = (x.1 ∈ s ∧ x.1 = x.2) :=
  by sorry

This theorem states that for any type `α` with decidable equality and for any finite set `s` of type `α`, a pair of elements `(x.1, x.2)` belongs to the diagonal of `s` (i.e., `Finset.diag s`) if and only if the first element of the pair `x.1` belongs to the set `s` and `x.1` is equal to `x.2`. In other words, a pair is in the diagonal of `s` only when both its elements are the same and belong to the set `s`.

For any finite set `s` of type `α` with decidable equality, the diagonal of `s` is equal to the set of pairs `(x.1, x.2)` where `x.1` is in `s` and `x.1` equals `x.2`.


TendstoUniformlyOnFilter.prod

theorem TendstoUniformlyOnFilter.prod :
    ∀ {α : Type u} {β : Type v} {ι : Type x} [inst : UniformSpace β] {F : ι → α → β} {f : α → β} {p : Filter ι}
      {p' : Filter α} {ι' : Type u_1} {β' : Type u_2} [inst_1 : UniformSpace β'] {F' : ι' → α → β'} {f' : α → β'}
      {q : Filter ι'},
      TendstoUniformlyOnFilter F f p p' →
        TendstoUniformlyOnFilter F' f' q p' →
          TendstoUniformlyOnFilter (fun i a => (F i.1 a, F' i.2 a)) (fun a => (f a, f' a)) (p ×ˢ q) p' :=
  by sorry

The theorem `TendstoUniformlyOnFilter.prod` states that given two sequences of functions `F` and `F'` that converge uniformly on a filter `p'` to limiting functions `f` and `f'` respectively, with respect to filters `p` and `q`, then the function that maps each element of the pair `(i, a)` to `(F i.1 a, F' i.2 a)` converges uniformly on the filter `p'` to the limiting function that maps `a` to `(f a, f' a)`, with respect to the product filter `p ×ˢ q`. This is under the condition that the codomain of the functions `F`, `f`, `F'`, and `f'` are uniform spaces.

Given uniformly convergent sequences of functions `F : X → Y` and `F' : X' → Y'` on filters `p` and `p'` respectively, with codomain uniform spaces `Y` and `Y'`, their product sequence `(F i.1, F' i.2) : X × X' → Y × Y'` converges uniformly on `p'` to `(f : X → Y, f' : X' → Y')` with `f` and `f'` being the respective limits of `F` and `F'` on filters `p` and `q`.


theorem Nat.squarefree_iff_nodup_factors : ∀ {n : ℕ}, n ≠ 0 → (Squarefree n ↔ List.Nodup (Nat.factors n)) := by sorry

The theorem `Nat.squarefree_iff_nodup_factors` states that for any non-zero natural number `n`, `n` is squarefree if and only if the list of its prime factorization, `Nat.factors n`, has no duplicates. Here, a number is considered squarefree if the only squares that divide it are the squares of units. This theorem provides a characterization of squarefree numbers in terms of the uniqueness of their prime factors.

A natural number `n` is squarefree if and only if its prime factorization `Nat.factors n` has no repeating elements.


/-- Uses `left` co(ntra)variant. -/
theorem Left.neg_nonpos_iff :
    ∀ {α : Type u} [inst : AddGroup α] [inst_1 : LE α]
      [inst_2 : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] {a : α}, -a ≤ 0 ↔ 0 ≤ a :=
  by sorry

This theorem, `Left.neg_nonpos_iff`, declares a fundamental property of ordered additive groups. For any type `α` that has an additive group structure and an order `≤` that is compatible with the group operation (i.e., it is left-covariant), the theorem states that for any element `a` of this type, `-a` is less than or equal to `0` if and only if `0` is less than or equal to `a`. In other words, `a` is nonnegative if and only if its negation `-a` is nonpositive.

For any additive group `α` with a compatible ordering `≤`, the elements `a` and `-a` are related by `a ≤ 0 iff -a ≥ 0`.


theorem isCoprime_zero_right : ∀ {R : Type u} [inst : CommSemiring R] {x : R}, IsCoprime x 0 ↔ IsUnit x := by sorry

The theorem `isCoprime_zero_right` states that for any commutative semiring `R` and any element `x` of `R`, `x` and `0` are coprime if and only if `x` is a unit. In mathematical terms, this means there exist elements `a` and `b` in `R` such that `a * x + b * 0 = 1` if and only if there exists a two-sided inverse of `x`. Essentially, an element is coprime with zero in a commutative semiring if and only if it is invertible.

In a commutative semiring, an element is coprime to zero if and only if it is a unit.


theorem iSup_inf_of_monotone :
    ∀ {α : Type u} [inst : Order.Frame α] {ι : Type u_1} [inst_1 : Preorder ι]
      [inst_2 : IsDirected ι fun x x_1 => x ≤ x_1] {f g : ι → α},
      Monotone f → Monotone g → ⨆ i, f i ⊓ g i = (⨆ i, f i) ⊓ ⨆ i, g i :=
  by sorry

The theorem `iSup_inf_of_monotone` states that for any types `α` and `ι`, where `α` forms a frame order and `ι` a preorder. If `ι` is directed with respect to the partial order `≤`, and `f` and `g` are both monotone functions from `ι` to `α`, then the supremum of the infimum of `f(i)` and `g(i)` for all `i` in `ι` is equal to the infimum of the supremum of `f(i)` and the supremum of `g(i)`. In mathematical terms, this can be written as $\bigvee_i (f(i) \land g(i)) = (\bigvee_i f(i)) \land (\bigvee_i g(i))$, where $\bigvee$ denotes the supremum (or join), $\land$ denotes the infimum (or meet), and the index `i` ranges over all elements in `ι`.

For any frame order types `α` and preorder `ι`, if `ι` is directed and `f` and `g` are monotone functions from `ι` to `α`, then $\bigvee\_i (f(i) \land g(i)) = (\bigvee\_i f(i)) \land (\bigvee\_i g(i))$.


theorem Nat.digits_add_two_add_one :
    ∀ (b n : ℕ), Nat.digits (b + 2) (n + 1) = (n + 1) % (b + 2) :: Nat.digits (b + 2) ((n + 1) / (b + 2)) := by sorry

This theorem states that for any two natural numbers `b` and `n`, the digits of `n + 1` in base `b + 2` are obtained by adding `(n + 1) % (b + 2)` to the front of the digits of `(n + 1) / (b + 2)` in the same base. Essentially, it describes how the digits of a number in a given base can be computed by repeatedly dividing the number by the base and taking the remainder.

For any natural number `n` and base `b`, the digits of `n + 1` in base `b + 2` are obtained by appending the remainder of `(n + 1) / (b + 2)` to the base `b+2` representation of `(n + 1) / (b + 2)`.


theorem Submodule.span_eq_iSup_of_singleton_spans :
    ∀ {R : Type u_1} {M : Type u_4} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] (s : Set M),
      Submodule.span R s = ⨆ x ∈ s, Submodule.span R {x} :=
  by sorry

This theorem states that for any given set `s` of a type `M` that is a module over a semiring `R`, the span of `s` (i.e., the smallest submodule of `M` that contains `s`) is equivalent to the supremum of the spans of all singleton sets that contain elements of `s`. In other words, the smallest submodule that contains all elements of `s` is the same as the "largest" submodule that can be generated by taking the span of each individual element of `s` separately.

The span of a set `s` in a module `M` over a semiring `R` is equal to the sum of the spans of all singleton sets contained in `s`.


theorem Polynomial.separable_map :
    ∀ {F : Type u} [inst : Field F] {S : Type u_1} [inst_1 : CommRing S] [inst_2 : Nontrivial S] (f : F →+* S)
      {p : Polynomial F}, Polynomial.Separable (Polynomial.map f p) ↔ Polynomial.Separable p :=
  by sorry

This theorem states that for any field `F`, commutative ring `S`, and a ring homomorphism `f` from `F` to `S`, if a polynomial `p` over `F` is separable (meaning that it is coprime with its derivative), then the polynomial obtained by mapping `p` across the ring homomorphism `f` is also separable, and vice versa. In other words, the separability of a polynomial is preserved under the mapping operation.

If `f` is a ring homomorphism from field `F` to commutative ring `S`, and polynomial `p` over `F` is separable, then the image of `p` under `f` is also separable. Conversely, if `p` is the image of a separable polynomial under `f`, then `p` itself is separable.