Filter.Tendsto.vadd

theorem Filter.Tendsto.vadd :
    ∀ {M : Type u_1} {X : Type u_2} {α : Type u_4} [inst : TopologicalSpace M] [inst_1 : TopologicalSpace X]
      [inst_2 : VAdd M X] [inst_3 : ContinuousVAdd M X] {f : α → M} {g : α → X} {l : Filter α} {c : M} {a : X},
      Filter.Tendsto f l (nhds c) →
        Filter.Tendsto g l (nhds a) → Filter.Tendsto (fun x => f x +ᵥ g x) l (nhds (c +ᵥ a)) :=
  by sorry

This theorem, named `Filter.Tendsto.vadd`, states that for any types `M`, `X` and `α`, with `M` and `X` equipped with a topology and a vector addition operation, and `α` serving as the domain of two functions `f` and `g` with values in `M` and `X` respectively. If `f` tends to a point `c` in `M` and `g` tends to a point `a` in `X` with respect to a filter `l`, and if the vector addition operation is continuous, then the function that at any point `x` gives `f x +ᵥ g x` tends to `c +ᵥ a` with respect to the same filter `l`. In terms of limits, this means that the limit of the vector sum of two functions is the vector sum of their limits, under the given conditions.

If functions `f : X → M` and `g : X → X` are each pointwise convergence to their respective limits `c : M` and `a : X` with respect to filter `l`, and vector addition in `M` is continuous, then `f +ᵥ g` pointwise converges to `c +ᵥ a` with respect to `l`.


theorem Mathlib.Order.BoundedOrder._auxLemma.30 :
    ∀ {α : Type u} [inst : PartialOrder α] [inst_1 : BoundedOrder α] [inst_2 : Nontrivial α], (⊥ = ⊤) = False := by
  sorry

This theorem, from the `Mathlib.Order.BoundedOrder` namespace, states that for any type `α` which is a partial order, a bounded order, and is nontrivial, the bottom element (denoted by `⊥`) and the top element (denoted by `⊤`) of this order are not equal. In other words, it asserts that in any nontrivial partially ordered set that is also a bounded order, the least element is not the same as the greatest element.

In any nontrivial partially ordered set that is also a bounded order, the bottom and top elements are distinct.


theorem Flow.map_add :
    ∀ {τ : Type u_1} [inst : AddMonoid τ] [inst_1 : TopologicalSpace τ] [inst_2 : ContinuousAdd τ] {α : Type u_2}
      [inst_3 : TopologicalSpace α] (ϕ : Flow τ α) (t₁ t₂ : τ) (x : α),
      ϕ.toFun (t₁ + t₂) x = ϕ.toFun t₁ (ϕ.toFun t₂ x) :=
  by sorry

This theorem, `Flow.map_add`, describes a property of a flow in topological spaces. In particular, given a type `τ` with `AddMonoid`, `TopologicalSpace`, and `ContinuousAdd` structures, and another type `α` with a `TopologicalSpace` structure, for any `Flow` `ϕ` from `τ` to `α`, and any elements `t₁`, `t₂` of `τ` and `x` of `α`, the function application of `ϕ` to the sum `t₁ + t₂` and `x` is equal to the function application of `ϕ` to `t₁` and the result of the function application of `ϕ` to `t₂` and `x`. This is essentially a statement about the continuity of the addition operation in the flow.

For any continuous flow `ϕ` from an additive and topological space `(τ, +)` to a topological space `(α, ∅)`, the diagram commutes: `ϕ(t₁ + t₂) = ϕ(t₁) + ϕ(t₂)` for all `t₁, t₂ ∈ τ` and `ϕ(x) ∈ α`.


theorem Set.inter_diff_self : ∀ {α : Type u} (a b : Set α), a ∩ (b \ a) = ∅ := by sorry

This theorem states that for any type `α` and for any two sets `a` and `b` of type `α`, the intersection of set `a` and the difference of sets `b` and `a` is an empty set. In other words, the intersection of a set and the difference of another set and the former set always results in an empty set. In mathematical terms, if `a` and `b` are sets, then `a ∩ (b \ a) = ∅`.

The theorem asserts that for any type `α` and sets `a` and `b` of type `α`, the intersection of `a` and the set difference `(b \ a)` is the empty set. In symbols, `a ∩ (b \ a) = ∅`.


/-- Alias for `Equiv.image_eq_preimage`  -/
theorem Set.preimage_equiv_eq_image_symm :
    ∀ {α : Type u_1} {β : Type u_2} (S : Set α) (f : β ≃ α), ⇑f ⁻¹' S = ⇑f.symm '' S := by sorry

The theorem `Set.preimage_equiv_eq_image_symm` states that for any set `S` of type `α` and for any bijective mapping `f` between types `β` and `α`, the preimage of `S` under `f` is equal to the image of `S` under the inverse of `f`. In other words, if you perform the inverse operation of `f` on the set `S`, it is the same as applying `f` and then mapping `S` back to its original state. This is a property of bijective functions, where each element in both the domain and codomain pair up uniquely.

For any bijective function $f : \beta \rightarrow \alpha$ and set $S \subseteq \alpha$, the preimage $f^{-1}(S)$ is equal to the image $f(S^{-1})$ under set inverse operations.


/-- `∑' i, f i` is the sum of `f` it exists, or 0 otherwise. -/
theorem tsum_def :
    ∀ {α : Type u_4} [inst : AddCommMonoid α] [inst_1 : TopologicalSpace α] {β : Type u_5} (f : β → α),
      tsum f = if h : Summable f then if Set.Finite (Function.support f) then finsum f else Exists.choose h else 0 :=
  by sorry

The theorem `tsum_def` states that for any type `α` that forms an additive commutative monoid and has a topological space structure, and any function `f` from type `β` to `α`, the sum `∑' i, f i` is defined as follows: If `f` is summable (i.e., it has an infinite sum), then if the support of `f` (the set of points `x` for which `f x ≠ 0`) is finite, it equals the finite sum of `f`; otherwise, it equals some value obtained from the summability of `f`. If `f` is not summable, then the sum is 0.

For any additive commutative monoid type `α` with topological space structure and summable function `f` from type `β` to `α` with finite support, the sum `∑' i, f i` equals the finite sum of `f`; otherwise, it equals the value obtained from `f`'s summability. If `f` is not summable, the sum is 0.


/-- When a ring is not a field, the maximal ideals are nontrivial.  -/
theorem Ring.ne_bot_of_isMaximal_of_not_isField :
    ∀ {R : Type u_1} [inst : CommSemiring R] [inst_1 : Nontrivial R] {M : Ideal R},
      Ideal.IsMaximal M → ¬IsField R → M ≠ ⊥ :=
  by sorry

This theorem states that for any commutative semiring `R` that is not trivial, and for any `M` which is an ideal in `R`, if `M` is a maximal ideal and `R` is not a field, then `M` must not be the zero ideal. In other words, when a commutative semiring is not a field, all its maximal ideals are nontrivial; they contain more than just the zero element.

In a commutative semiring that is not a field, every maximal ideal is non-zero.


theorem IsUnit.val_inv_mul : ∀ {M : Type u_1} [inst : Monoid M] {a : M} (h : IsUnit a), ↑(IsUnit.unit h)⁻¹ * a = 1 := by
  sorry

The theorem `IsUnit.val_inv_mul` states that for any type `M` that has a Monoid structure and any element `a` of `M` which is a unit (meaning it has a two-sided inverse), the inverse of the unit corresponding to `a` (given by `IsUnit.unit h`) times `a` equals the multiplicative identity `1`. In essence, it establishes that for a unit element in a monoid, multiplying it by its inverse results in the multiplicative identity.

For any monoid `M` and unit `a` in `M`, `IsUnit.unit h * a = 1` where `IsUnit.unit h` is the inverse of `a`.


theorem Mathlib.MeasureTheory.Function.L1Space._auxLemma.18 :
    ∀ {α : Type u_1} {β : Type u_2} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} [inst : NormedAddCommGroup β]
      (f : α → β), (∫⁻ (a : α), edist (f a) 0 ∂μ < ⊤) = MeasureTheory.HasFiniteIntegral f μ :=
  by sorry

This theorem states that for any types `α` and `β`, any measurable space `m` on `α`, any measure `μ` on `α`, and any function `f` from `α` to `β` where `β` forms a normed add commutative group, the condition that the extended distance from `f a` to `0` integrated with respect to measure `μ` over all `a` in `α` is finite is equivalent to the function `f` having a finite integral with respect to the measure `μ`. In mathematical terms, it asserts that `∫⁻ (a : α), edist (f a) 0 ∂μ < ∞` is equivalent to `∫⁻ (a : α), ‖f a‖ ∂μ < ∞`.

The theorem asserts that for any measurable space, measure, and integrable function between normed add commutative groups, the finite integrability of the extended distance from the function to the origin equals the finite integrability of the function's norm.


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

This theorem states that, given a nontrivially normed field `𝕜`, a normed additive commutative group `E` as the domain and `F` as the codomain, a function `f : E → F`, its Fréchet derivative `f' : E →L[𝕜] F` at a point `x : E`, and a filter `L` on `E`, if the function `f` has a Fréchet derivative `f'` at the point `x` with respect to the filter `L`, then the function `x' ↦ f(x') - f(x)` is a big O of the function `x' ↦ x' - x` with respect to the filter `L`. In simpler terms, the difference between the function values of `f` at points `x'` and `x` grows at most as fast as the difference between `x'` and `x` itself, in the limit as `x'` approaches `x` according to the filter `L`.

Given a nontrivially normed field `𝕜`, a normed additive commutative group `E`, a function `f : E → F` with Fréchet derivative `f'` at a point `x ∈ E`, and a filter `L` on `E`, if `f` is Fréchet differentiable at `x` with respect to `L`, then the difference `f(x') - f(x)` is O(||x' - x||) as `x'` approaches `x` according to filter `L`.


/-- **Alias** of `Dvd.intro_left`. -/
theorem dvd_of_mul_left_eq : ∀ {α : Type u_1} [inst : CommSemigroup α] {a b : α} (c : α), c * a = b → a ∣ b := by sorry

This theorem, `dvd_of_mul_left_eq`, states that for any type `α` that forms a commutative semigroup, and for any elements `a`, `b`, and `c` of type `α`, if `c * a` equals `b`, then `a` divides `b`. In mathematical terms, it means if `b` can be written as the product of `c` and `a`, then `a` is a factor, or divisor, of `b`.

If `c * a = b` in a commutative semigroup, then `a` divides `b`.


/-- If `I` divides `J`, then `I` contains `J`.

In a Dedekind domain, to divide and contain are equivalent, see `Ideal.dvd_iff_le`.
 -/
theorem Ideal.le_of_dvd : ∀ {R : Type u} [inst : CommSemiring R] {I J : Ideal R}, I ∣ J → J ≤ I := by sorry

This theorem states that in a commutative semiring `R`, if ideal `I` divides ideal `J`, then `I` contains `J`. In other words, if `I` is a factor of `J`, then every element of `J` is also an element of `I`. This is a general property of ideals in commutative semirings. However, it's worth noting that in a Dedekind domain (a specific type of integral domain), the concepts of division and containment for ideals are equivalent, which is elaborated in `Ideal.dvd_iff_le`.

In a commutative semiring, if one ideal is a divisor of another, then it contains that ideal.


theorem LieSubmodule.mem_coeSubmodule :
    ∀ {R : Type u} {L : Type v} {M : Type w} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : AddCommGroup M]
      [inst_3 : Module R M] [inst_4 : LieRingModule L M] (N : LieSubmodule R L M) {x : M}, x ∈ ↑N ↔ x ∈ N :=
  by sorry

This theorem, `LieSubmodule.mem_coeSubmodule`, states that for any given commutative ring `R`, Lie ring `L`, and additive commutative group `M` with `M` being a module over `R` and a Lie ring module over `L`, a certain element `x` of `M` is in the set underlying a Lie submodule `N` if and only if `x` is an element of the Lie submodule `N`. In other words, it asserts the equivalence of the membership of `x` in the underlying set of `N` and in the submodule `N` itself.

For any commutative ring R, Lie ring L, additive commutative group M being an L-Lie module over L, the element x of M is in the underlying set of a Lie submodule N if and only if x is in N as a submodule.


theorem OneOneReducible.to_many_one :
    ∀ {α : Type u_1} {β : Type u_2} [inst : Primcodable α] [inst_1 : Primcodable β] {p : α → Prop} {q : β → Prop},
      p ≤₁ q → p ≤₀ q :=
  by sorry

This theorem states that for any types `α` and `β` and predicates `p` and `q` on `α` and `β` respectively, if `p` is one-one reducible to `q` (denoted by `p ≤₁ q`), then `p` is many-one reducible to `q` (denoted by `p ≤₀ q`). Here, both `α` and `β` are required to be primcodable, which means there exists an effective procedure to encode and decode values of these types. One-one reducibility and many-one reducibility are concepts from the theory of computability, which deal with the transformations between different decision problems or sets.

If `α` and `β` are primcodable types and `p` is one-one reducible to `q` (`p ≤₁ q`), then `p` is many-one reducible to `q` (`p ≤₀ q`).


/-- If a word reduces to another word, then they have a common maximal reduction.  -/
theorem FreeGroup.reduce.eq_of_red :
    ∀ {α : Type u} {L₁ L₂ : List (α × Bool)} [inst : DecidableEq α],
      FreeGroup.Red L₁ L₂ → FreeGroup.reduce L₁ = FreeGroup.reduce L₂ :=
  by sorry

The theorem `FreeGroup.reduce.eq_of_red` asserts that for any type `α` with decidable equality and any two lists `L₁` and `L₂` of pairs of elements of `α` and Boolean values, if there exists a reflexive-transitive reduction from `L₁` to `L₂`, then these two lists have the same maximal reduction. In other words, if one word can be reduced to another, then their maximal reductions, which are computable when `α` has decidable equality, are identical.

If `α` has decidable equality and there exists a reflexive-transitive reduction from list `L₁` to list `L₂` of pairs of elements and Boolean values from `α`, then `L₁` and `L₂` have the same maximal reduction.


theorem sSup_image2_eq_sSup_sSup :
    ∀ {α : Type u} {β : Type v} {γ : Type w} [inst : CompleteLattice α] [inst_1 : CompleteLattice β]
      [inst_2 : CompleteLattice γ] {s : Set α} {t : Set β} {l : α → β → γ} {u₁ : β → γ → α} {u₂ : α → γ → β},
      (∀ (b : β), GaloisConnection (Function.swap l b) (u₁ b)) →
        (∀ (a : α), GaloisConnection (l a) (u₂ a)) → sSup (Set.image2 l s t) = l (sSup s) (sSup t) :=
  by sorry

The theorem states that for all types `α`, `β`, `γ` that have complete lattice structures, given two sets `s : Set α` and `t : Set β`, a binary function `l : α → β → γ`, and two functions `u₁ : β → γ → α` and `u₂ : α → γ → β` that form Galois connections when combined with `l` (where `l` is swapped with `b` for `u₁`), the supremum (or the least upper bound) of the image of the binary function applied to `s` and `t` is equal to the result of applying `l` to the supremum of `s` and the supremum of `t`.

In mathematical terms, if we have a Galois connection between functions `l` and `u₁` (for each `b : β`) and between `l` and `u₂` (for each `a : α`), then we have $\sup(l(s,t)) = l(\sup s, \sup t)$ where $l$ is a binary function and $s$ and $t$ are sets in the respective complete lattices.

For sets $s$ and $t$ in complete lattices $\alpha$ and $\beta$, respectively, and with Galois connections between the binary function $l$ and functions $u\_1$ and $u\_2$, we have $\sup(l(s,t)) = l(\sup s, \sup t)$.


theorem differentiableAt_fst :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {p : E × F},
      DifferentiableAt 𝕜 Prod.fst p :=
  by sorry

The theorem `differentiableAt_fst` states that for any point `p` in the product space of two normed spaces `E` and `F` over a nontrivially normed field `𝕜`, the projection function `Prod.fst` that maps a pair to its first element is differentiable at `p`. In other words, it claims the existence of a derivative for the first projection function at any point of the product space.

The projection function `Prod.fst` from the product of two normed spaces is differentiable at any point in the product space.


theorem Fintype.card_le_one_iff_subsingleton :
    ∀ {α : Type u_1} [inst : Fintype α], Fintype.card α ≤ 1 ↔ Subsingleton α := by sorry

The theorem `Fintype.card_le_one_iff_subsingleton` states that for any type `α` which is a `Fintype` (i.e., a finite type), the cardinality of `α` (i.e., the number of elements in `α`) is less than or equal to one if and only if `α` is a `Subsingleton`. In the language of set theory, a type is a `Subsingleton` if it has at most one element. By this theorem, we see the direct correlation between a type's cardinality and whether or not it is a `Subsingleton` in Lean 4. The "if and only if" indicates a bi-directional implication: not only does having at most one element imply that a type is a `Subsingleton`, but also being a `Subsingleton` implies that a type has at most one element.

For a type `α` in Lean 4, `α` is a `Fintype` with cardinality less than or equal to one if and only if `α` is a `Subsingleton`.


theorem List.take_left : ∀ {α : Type u_1} (l₁ l₂ : List α), List.take (List.length l₁) (l₁ ++ l₂) = l₁ := by sorry

The theorem `List.take_left` states that for any two lists `l₁` and `l₂` of elements of an arbitrary type `α`, if we append `l₁` and `l₂` and then take the first `n` elements of the resulting list, where `n` is the length of `l₁`, we get back the list `l₁`. In other words, taking the first `n` elements of the appended list is equivalent to simply retrieving the original list `l₁`.

For any lists `l₁` and `l₂` of length `n` over an arbitrary type `α`, `List.take_left l₁ (l₁ ++ l₂) = l₁`.


theorem CategoryTheory.ShortComplex.rightHomologyMap'_id :
    ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
      {S : CategoryTheory.ShortComplex C} (h : CategoryTheory.ShortComplex.RightHomologyData S),
      CategoryTheory.ShortComplex.rightHomologyMap' (CategoryTheory.CategoryStruct.id S) h h =
        CategoryTheory.CategoryStruct.id h.H :=
  by sorry

The theorem `CategoryTheory.ShortComplex.rightHomologyMap'_id` states that for any category 'C' that has zero morphisms and a short complex 'S', the right homology map, when applied to the identity morphism of 'S' and any right homology data 'h' of 'S', returns the identity morphism of 'h'. In other words, the right homology map preserves the identity morphism in the context of short complexes in the category theory.

For any short complex S in a category C with zero morphisms, the right homology map of the identity morphism of S with respect to any right homology data is the identity morphism of the right homology data.


theorem MeasureTheory.Measure.rnDeriv_def :
    ∀ {α : Type u_3} {m : MeasurableSpace α} (μ ν : MeasureTheory.Measure α),
      μ.rnDeriv ν = if h : MeasureTheory.Measure.HaveLebesgueDecomposition μ ν then (Classical.choose ⋯).2 else 0 :=
  by sorry

The theorem `MeasureTheory.Measure.rnDeriv_def` states that for any given measurable space `α` and two measures `μ` and `ν` on that space, the Radon-Nikodym derivative of `μ` with respect to `ν`, denoted as `μ.rnDeriv ν`, is defined as follows: If the measures `μ` and `ν` satisfy the Lebesgue Decomposition theorem (indicated by the existence proof `h : MeasureTheory.Measure.HaveLebesgueDecomposition μ ν`), then the Radon-Nikodym derivative is given by the second component of the pair returned by the function `Classical.choose`. This function selects an arbitrary element from a non-empty set that satisfies a certain property. If the measures `μ` and `ν` do not satisfy the Lebesgue Decomposition theorem, then the Radon-Nikodym derivative is defined as `0`.

If measures `μ` and `ν` on measurable space `α` satisfy the Lebesgue Decomposition theorem, then `μ.rnDeriv ν` is the second component of the pair returned by `Classical.choose` on the set of Radon-Nikodym derivatives. Otherwise, `μ.rnDeriv ν` is `0`.


/-- The vector space of functions on a `Fintype ι` has finrank equal to the cardinality of `ι`.  -/
theorem FiniteDimensional.finrank_fintype_fun_eq_card :
    ∀ (R : Type u) {η : Type u₁'} [inst : Ring R] [inst_1 : StrongRankCondition R] [inst_2 : Fintype η],
      FiniteDimensional.finrank R (η → R) = Fintype.card η :=
  by sorry

This theorem states that for any type `R` which forms a ring and satisfies the strong rank condition, and for any finite type `η`, the rank of the vector space of functions from `η` to `R` is equal to the number of elements in `η`. In other words, if you have a set `η` of elements and the set of all functions mapping these elements to a ring `R` form a vector space, the dimension (or rank) of this vector space is the same as the number of elements in the original set `η`.

For any finite type `η` and ring `R` satisfying the strong rank condition, the dimension of the vector space of functions from `η` to `R` equals the cardinality of `η`.


theorem Real.contDiff_sinh : ∀ {n : ℕ∞}, ContDiff ℝ n Real.sinh := by sorry

This theorem states that the real hyperbolic sine function, defined as the real part of the complex hyperbolic sine, is continuously differentiable for all natural numbers `n`, including infinity. In mathematical terms, it verifies that the function `Real.sinh : ℝ → ℝ` is `n`-times continuously differentiable for every `n` in `ℕ∞`, where `ℕ∞` is the set of natural numbers extended by infinity.

The real hyperbolic sine function, defined as the real part of the complex hyperbolic sine, is continuously differentiable for all natural numbers and infinity. Equivalently, `Real.sinh : ℝ → ℝ` is `n`-times differentiable for every `n` in `ℕ ∪ {∞}`.


/-- If `s` is a compact set and `μ` is a locally finite measure, then `s` admits an open superset of
finite measure.  -/
theorem IsCompact.exists_open_superset_measure_lt_top :
    ∀ {α : Type u_1} [inst : TopologicalSpace α] [inst_1 : MeasurableSpace α] {s : Set α},
      IsCompact s →
        ∀ (μ : MeasureTheory.Measure α) [inst_2 : MeasureTheory.IsLocallyFiniteMeasure μ],
          ∃ U ⊇ s, IsOpen U ∧ ↑↑μ U < ⊤ :=
  by sorry

The theorem `IsCompact.exists_open_superset_measure_lt_top` states that for any type `α` that is a topological space and a measurable space, and for any set `s` of type `α` that is compact, given a measure `μ` on `α` that is locally finite, there exists an open superset `U` of `s` such that the measure `μ` of `U` is finite. In other words, in a given topological and measurable space, any compact set admits an open superset of finite measure under a locally finite measure.

In a locally finite measure on a compact subset of a topological and measurable space, there exists an open superset with finite measure.


theorem Localization.liftOn_mk :
    ∀ {M : Type u_1} [inst : CommMonoid M] {S : Submonoid M} {p : Sort u} (f : M → ↥S → p)
      (H : ∀ {a c : M} {b d : ↥S}, (Localization.r S) (a, b) (c, d) → f a b = f c d) (a : M) (b : ↥S),
      Localization.liftOn (Localization.mk a b) f H = f a b :=
  by sorry

The theorem `Localization.liftOn_mk` states that, for a given commutative monoid `M` and a submonoid `S`, for any type `p` and function `f : M → ↥S → p` satisfying the property that if the congruence relation `Localization.r S` holds between `(a, b)` and `(c, d)`, then `f a b` equals `f c d`, then the `Localization.liftOn` operation on the equivalence class of `(a, b)` (created by `Localization.mk a b`) with function `f` and property `H` is equal to `f a b`. In other words, when we lift a function `f` to the entire localization under these conditions, applying this lifted function to the localization of `a` and `b` retrieves the original function `f` applied to `a` and `b`.

If `M` is a commutative monoid, `S` a submonoid, `f : M → ↥S → p`, and for any `(a, b)` and `(c, d)` such that `Localization.r S` holds between them implies `f a b = f c d`, then `Localization.liftOn (Localization.mk a b) f = f a b`.


theorem List.map_congr :
    ∀ {α : Type u} {β : Type v} {f g : α → β} {l : List α}, (∀ x ∈ l, f x = g x) → List.map f l = List.map g l := by
  sorry

The theorem `List.map_congr` states that for any two functions `f` and `g` from type `α` to type `β`, and for any list `l` of type `α`, if `f` and `g` give the same result for all elements in `l`, then the result of mapping `f` over `l` is the same as the result of mapping `g` over `l`. In other words, if two functions agree on the elements of a list, then their map over the list also agrees.

If two functions agree on every element of a list, then applying them with `List.map` yields the same output.


theorem Ordnode.Valid'.dual_iff :
    ∀ {α : Type u_1} [inst : Preorder α] {t : Ordnode α} {o₁ : WithBot α} {o₂ : WithTop α},
      Ordnode.Valid' o₁ t o₂ ↔ Ordnode.Valid' o₂ (Ordnode.dual t) o₁ :=
  by sorry

The theorem `Ordnode.Valid'.dual_iff` states that for any given type `α` which is a Preorder, any Ordnode `t` of `α`, any element `o₁` of `WithBot α`, and any element `o₂` of `WithTop α`, the Ordnode `t` is valid with respect to `o₁` and `o₂` if and only if the dual of `Ordnode t` is valid with respect to `o₂` and `o₁`. Here, `WithBot α` and `WithTop α` essentially extend `α` by attaching a bottom element `⊥` and a top element `⊤` respectively, `Ordnode` is a type of self-balancing binary search trees, and `Ordnode.Valid'` is a predicate that checks if the tree is valid with respect to two optional bounds. The 'dual' of a tree is obtained by flipping it around the root, which turns a tree valid for `o₁` and `o₂` into one valid for `o₂` and `o₁`.

For any Preorder type `α`, Ordnode `t` of `α`, and elements `o₁` of `WithBot α` and `o₂` of `WithTop α`, the Ordnode `t` is valid with respect to `o₁` and `o₂` if and only if the dual of Ordnode `t` is valid with respect to `o₂` and `o₁`.


theorem ENNReal.eq_top_of_forall_nnreal_le : ∀ {x : ENNReal}, (∀ (r : NNReal), ↑r ≤ x) → x = ⊤ := by sorry

The theorem `ENNReal.eq_top_of_forall_nnreal_le` states that for every extended nonnegative real number `x`, if all nonnegative real numbers `r` are less than or equal to `x`, then `x` is equal to infinity (∞). This applies to the scenario where `x` is an 'upper bound' for all nonnegative real numbers, and in such a case, `x` must be infinity.

If every non-negative real number is less than or equal to an extended non-negative real number `x`, then `x` equals infinity.


theorem le_update_iff :
    ∀ {ι : Type u_1} {π : ι → Type u_2} [inst : DecidableEq ι] [inst_1 : (i : ι) → Preorder (π i)] {x y : (i : ι) → π i}
      {i : ι} {a : π i}, x ≤ Function.update y i a ↔ x i ≤ a ∧ ∀ (j : ι), j ≠ i → x j ≤ y j :=
  by sorry

The theorem `le_update_iff` states that for all types `ι` and `π` (where `π` is a function of `ι`), where `ι` has decidable equality and every element of `ι` forms a preorder with `π`, for all functions `x` and `y` mapping elements of `ι` to `π`, for all elements `i` of `ι` and `a` of `π`, `x` is less than or equal to the function `y` updated at `i` with `a` if and only if the value of `x` at `i` is less than or equal to `a` and for all `j` not equal to `i`, the value of `x` at `j` is less than or equal to the value of `y` at `j`.

In simpler terms, it states that a function `x` is less than or equal to another function `y` updated with a certain value at a specific point, if and only if `x`'s value at this specific point is less than or equal to the new value, and `x`'s values at all other points are less than or equal to `y`'s corresponding values.

For functions `x:` `ι` `→` `π` and `y:` `ι` `→` `π` over a preordered type `ι` with decidable equality, `x ≤ y.update i a` if and only if `x i ≤ a` and for all `j ≠ i`, `x j ≤ y j`.


theorem MulOpposite.op_inv : ∀ {α : Type u_1} [inst : Inv α] (x : α), MulOpposite.op x⁻¹ = (MulOpposite.op x)⁻¹ := by
  sorry

The theorem `MulOpposite.op_inv` states that for any type `α` that has an inverse operation (specified by the `Inv α` instance), the multiplicative opposite of the inverse of an element `x` (denoted as `MulOpposite.op x⁻¹`) is equal to the inverse of the multiplicative opposite of `x` (denoted as `(MulOpposite.op x)⁻¹`). In other words, taking the multiplicative opposite and taking the inverse commute with each other.

For any type `α` with an inverse operation, the multiplicative inverse of the multiplicative opposite of an element is equal to the multiplicative opposite of the inverse of that element. In other words, `(MulOpposite.op (Inv.inv x)) = Inv.inv (MulOpposite.op x)` for all `x : α`.


theorem MeasureTheory.hitting_le :
    ∀ {Ω : Type u_1} {β : Type u_2} {ι : Type u_3} [inst : ConditionallyCompleteLinearOrder ι] {u : ι → Ω → β}
      {s : Set β} {n m : ι} (ω : Ω), MeasureTheory.hitting u s n m ω ≤ m :=
  by sorry

This theorem, known as `MeasureTheory.hitting_le`, states that for any given types `Ω`, `β`, and `ι`, where `ι` is a conditionally complete linear order, and for any function `u` mapping `ι` and `Ω` to `β`, any set `s` of type `β`, and any values `n` and `m` of type `ι`, and an element `ω` of type `Ω`, the "hitting" measure of `u`, `s`, `n`, `m`, and `ω` is less than or equal to `m`. Here, "hitting" is a concept from measure theory representing a certain kind of interaction between the function `u` and the set `s`.

For any type `Ω`, conditionally complete linear order `ι`, function `u` from `ι × Ω` to `β`, set `s` of type `β`, and elements `n` and `m` of type `ι` and `ω` of type `Ω`, the measure of the set `{i ∈ i | u(i, ω) ∈ s}`, denoted by `# {i | u(i, ω) ∈ s}`, is less than or equal to `m`.


theorem Polynomial.coeff_eq_zero_of_lt_natTrailingDegree :
    ∀ {R : Type u} [inst : Semiring R] {p : Polynomial R} {n : ℕ},
      n < Polynomial.natTrailingDegree p → Polynomial.coeff p n = 0 :=
  by sorry

The theorem `Polynomial.coeff_eq_zero_of_lt_natTrailingDegree` states that for any semiring `R`, polynomial `p` over `R`, and natural number `n`, if `n` is less than the natural trailing degree of the polynomial `p`, then the coefficient of `X^n` in `p` is zero. In other words, all coefficients corresponding to powers of `X` that are less than the natural trailing degree of the polynomial are zero.

For any semiring R, polynomial p over R in X, and natural number n, if the natural trailing degree of p is greater than n, then the coefficient of X^n in p is zero.


theorem Ne.le_iff_lt : ∀ {α : Type u} [inst : PartialOrder α] {a b : α}, a ≠ b → (a ≤ b ↔ a < b) := by sorry

This theorem states that for any given type `α` that has a partial order, and for any two elements `a` and `b` of type `α`, if `a` is not equal to `b`, then `a` is less than or equal to `b` if and only if `a` is less than `b`. In the context of mathematics, it asserts that for two unequal elements in a partially ordered set, the property of one element being less than or equal to the other is equivalent to the property of the first element being strictly less than the second.

For any partially ordered type `α` and elements `a` and `b` of type `α` with `a ≠ b`, we have `a ≤ b` if and only if `a < b`.


/-- The diameter of the empty set vanishes  -/
theorem EMetric.diam_empty : ∀ {α : Type u} [inst : PseudoEMetricSpace α], EMetric.diam ∅ = 0 := by sorry

This theorem states that the diameter of an empty set in a pseudoemetric space always equals zero. In other words, if we have a set in some pseudoemetric space and that set is empty, then the supremum of the extended distances between any two points in the set (which is defined as the diameter) is zero.

In a pseudometric space, the diameter of an empty set is 0.


theorem Real.Angle.toReal_inj : ∀ {θ ψ : Real.Angle}, Real.Angle.toReal θ = Real.Angle.toReal ψ ↔ θ = ψ := by sorry

The theorem `Real.Angle.toReal_inj` states that for any two angles `θ` and `ψ` represented as `Real.Angle`, the function `Real.Angle.toReal` is injective; this means that `θ` and `ψ` are equal if and only if their images under `Real.Angle.toReal` are equal. In other words, converting `θ` and `ψ` to real numbers in the interval `(-π, π]` yields the same number if and only if `θ` and `ψ` are the same angle.

The function `Real.Angle.toReal` maps distinct angles to distinct real numbers in the interval `(-π, π]`.


theorem isOpen_iSup_iff :
    ∀ {α : Type u} {ι : Sort v} {t : ι → TopologicalSpace α} {s : Set α}, IsOpen s ↔ ∀ (i : ι), IsOpen s := by sorry

This theorem states that for any type `α`, sort `ι`, a function `t` from `ι` to `TopologicalSpace α`, and a set `s` of type `α`, the set `s` is open if and only if for every element `i` of sort `ι`, `s` is open. In other words, this theorem characterizes an open set in a topological space, stating that a set `s` is open if all instances of `s` (as defined by the elements from `ι`) are also open in their respective topological space.

A set in a topological space is open if and only if the image of every element in the indexing type under the given function is an open set in its respective topological space.


theorem List.drop_length : ∀ {α : Type u_1} (l : List α), List.drop (List.length l) l = [] := by sorry

This theorem states that for any list `l` of elements of any type `α`, if we drop as many elements from the start of the list as the length of the list itself, we will get an empty list. In other words, if you have a list of `n` elements and you drop `n` elements from it, you will be left with no elements, i.e., an empty list.

For any list `l` of length `n` over type `α`, dropping the first `n` elements results in an empty list.


BoxIntegral.HasIntegral.add

theorem BoxIntegral.HasIntegral.add :
    ∀ {ι : Type u} {E : Type v} {F : Type w} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E]
      [inst_2 : NormedAddCommGroup F] [inst_3 : NormedSpace ℝ F] {I : BoxIntegral.Box ι} [inst_4 : Fintype ι]
      {l : BoxIntegral.IntegrationParams} {f g : (ι → ℝ) → E} {vol : BoxIntegral.BoxAdditiveMap ι (E →L[ℝ] F) ⊤}
      {y y' : F},
      BoxIntegral.HasIntegral I l f vol y →
        BoxIntegral.HasIntegral I l g vol y' → BoxIntegral.HasIntegral I l (f + g) vol (y + y') :=
  by sorry

This theorem states that for any two functions `f` and `g` that both have a box integral over a given box `I` with respect to a given set of integration parameters `l` and a certain volume form `vol`, if `f` has integral `y` and `g` has integral `y'`, then the function `f + g` (which is the sum of `f` and `g`) has an integral that is `y + y'` (the sum of the integrals of `f` and `g`). This is basically an application of the linearity of integration.

The integral of the sum of two functions `f` and `g` over a box `I` with respect to a volume form `vol` and integration parameters `l` is equal to the sum of their integrals.


theorem mul_lt_of_lt_one_left :
    ∀ {α : Type u_1} {a b : α} [inst : MulOneClass α] [inst_1 : Zero α] [inst_2 : Preorder α]
      [inst_3 : MulPosStrictMono α], 0 < b → a < 1 → a * b < b :=
  by sorry

The theorem `mul_lt_of_lt_one_left` states that for any type `α` that supports multiplication, has a multiplicative identity, has a zero, and is a preorder (i.e., supports at least a binary relation that is reflexive and transitive), and moreover obeys the property of strict monotonicity of multiplication by positive elements, then for any two elements `a` and `b` of this type, if `b` is positive and `a` is less than the multiplicative identity (1), then `a * b` is less than `b`.

If `α` is a preorder type with multiplication, identity, zero, and strict monotonicity by positive elements, then for all `a` less than the identity and `b` positive in `α`, `a * b` is less than `b`.


theorem Nat.Linear.ExprCnstr.denote_toNormPoly :
    ∀ (ctx : Nat.Linear.Context) (c : Nat.Linear.ExprCnstr),
      Nat.Linear.PolyCnstr.denote ctx (Nat.Linear.ExprCnstr.toNormPoly c) = Nat.Linear.ExprCnstr.denote ctx c :=
  by sorry

The theorem `Nat.Linear.ExprCnstr.denote_toNormPoly` states that for any context from the set of natural numbers (`Nat.Linear.Context`) and any expression constraint (`Nat.Linear.ExprCnstr`), the denotation of the normalized polynomial constraint derived from this expression constraint (`Nat.Linear.ExprCnstr.toNormPoly c`) within the given context is equivalent to the denotation of the original expression constraint within the same context (`Nat.Linear.ExprCnstr.denote ctx c`). In simple terms, normalizing an expression constraint does not change its denotation (interpretation) within a given context.

The normalization of a natural number expression constraint does not change its denotation within a given context.


theorem Filter.tendstoIxxClass_principal :
    ∀ {α : Type u_1} {s t : Set α} {Ixx : α → α → Set α},
      Filter.TendstoIxxClass Ixx (Filter.principal s) (Filter.principal t) ↔ ∀ x ∈ s, ∀ y ∈ s, Ixx x y ⊆ t :=
  by sorry

This theorem, `Filter.tendstoIxxClass_principal`, states that for any type `α`, and for any sets `s` and `t` of type `α`, and for any function `Ixx` that takes two elements of type `α` and returns a set of type `α`, the function `Ixx` has the property of TendstoIxxClass between the principal filter of `s` and the principal filter of `t` if and only if for all elements `x` and `y` in set `s`, all elements in the set `Ixx x y` are also in set `t`. Here, `TendstoIxxClass` represents a certain kind of "limiting behavior" of the function `Ixx`, specifically, it pertains to how the function `Ixx` behaves for values in `s` tending towards values in `t`.

For any function `Ixx` from a type `α` to sets of `α`, `Filter.tendstoIxxClass_principal` states that `Ixx` tends to the principal filters of `s` and `t` if and only if for all `x, y in s`, every element in `Ixx x y` is in `t`.


/-- The Hausdorff distance between a set and itself is zero.  -/
theorem Metric.hausdorffDist_self_zero :
    ∀ {α : Type u} [inst : PseudoMetricSpace α] {s : Set α}, Metric.hausdorffDist s s = 0 := by sorry

This theorem states that in a pseudometric space, the Hausdorff distance between any set and itself is always zero. The Hausdorff distance is a measure of the greatest of all distances from a point in one set to the closest point in the other set. In this case, since we are comparing a set to itself, the distance between any point and its closest neighbor in the same set is trivially zero, which makes the Hausdorff distance also zero.

In a pseudometric space, the Hausdorff distance between a set and itself is equal to zero.


theorem Set.encard_diff_singleton_add_one :
    ∀ {α : Type u_1} {s : Set α} {a : α}, a ∈ s → Set.encard (s \ {a}) + 1 = Set.encard s := by sorry

This theorem states that for any type `α`, any set `s` of that type, and any element `a` of that type, if `a` is a member of `s`, then the cardinality of the set obtained by removing `a` from `s` plus one is equal to the cardinality of `s`. In other words, if you have a set and remove a single element, the size of the new set is one less than the original set. This is formalizing in Lean what we intuitively understand about counting elements in a set.

For any type `α` and set `s:` `α`, if `a ∈ s`, then the cardinality of `s \ {a}` equals the cardinality of `s`.


theorem ENNReal.exists_nat_gt : ∀ {r : ENNReal}, r ≠ ⊤ → ∃ n, r < ↑n := by sorry

This theorem states that for every extended nonnegative real number `r` that is not equal to infinity, there exists a natural number `n` such that `r` is less than `n`. In other words, any finite extended nonnegative real number is strictly less than some natural number.

For every finite extended non-negative real number `r`, there exists a natural number `n` such that `r` < `n`.


theorem IsMax.not_lt : ∀ {α : Type u_1} [inst : Preorder α] {a b : α}, IsMax a → ¬a < b := by sorry

The theorem `IsMax.not_lt` states that for any type `α` equipped with a preorder (that is, a binary relation that is reflexive and transitive), given any two elements `a` and `b` of type `α`, if `a` is a maximal element in `α` (i.e., no other element in `α` is strictly greater than `a`), then it is not the case that `a` is less than `b`. In other words, a maximal element `a` in a preordered set cannot be strictly less than any other element `b` from the same set.

If `α` is a preordered type and `a` is a maximal element of `α`, then `a` is incomparable with any `b` in `α` such that `b` is strictly greater than `a`.


theorem List.permutationsAux2_snd_cons :
    ∀ {α : Type u_1} {β : Type u_2} (t : α) (ts : List α) (r : List β) (y : α) (ys : List α) (f : List α → β),
      (List.permutationsAux2 t ts r (y :: ys) f).2 =
        f (t :: y :: ys ++ ts) :: (List.permutationsAux2 t ts r ys fun x => f (y :: x)).2 :=
  by sorry

This theorem states that for any two types `α` and `β`, an element `t` of type `α`, a list `ts` of elements of type `α`, a list `r` of elements of type `β`, an element `y` of type `α`, a list `ys` of elements of type `α`, and a function `f` that takes a list of elements of type `α` and returns an element of type `β`, the second element of the tuple returned by the function `List.permutationsAux2` applied to `t`, `ts`, `r` and the list with `y` as the first element and `ys` as the rest of the elements, with function `f`, is equal to the list that has `f` applied to the list where `t` is the first element, `y` is the second element, and the rest of the elements are the concatenation of `ys` and `ts`, as the first element, followed by the second element of the tuple returned by `List.permutationsAux2` applied to `t`, `ts`, `r`, `ys` and a function that takes a list `x` and returns `f` applied to the list with `y` as the first element and `x` as the rest of the elements.

For any types `α` and `β`, given an element `t` of type `α`, lists `ts` and `ys` of elements of type `α`, a list `r` of elements of type `β`, and a function `f` that maps lists of `α` to `β`, the second element of `List.permutationsAux2` applied to `t`, `ts`, `r`, `[y] :: ys`, and `f` is equal to the list obtained by applying `f` to `[t, y]` followed by the second element of `List.permutationsAux2` applied to `t`, `ts`, `r`, `ys`, and the function `x => f [y] ++ x`.


theorem Set.indicator_le_self' :
    ∀ {α : Type u_2} {M : Type u_4} [inst : Preorder M] [inst_1 : Zero M] {s : Set α} {f : α → M},
      (∀ x ∉ s, 0 ≤ f x) → Set.indicator s f ≤ f :=
  by sorry

The theorem `Set.indicator_le_self'` states that for any type `α`, a Preorder `M` that also has a `Zero` instance, a set `s` of `α`, and a function `f` from `α` to `M`, if for all `x` not in `s`, zero is less than or equal to `f(x)`, then the indicator function of `s` applied to `f` is less than or equal to `f`. This essentially means that the values assigned by the indicator function (which assigns `f(x)` for `x` in `s` and `0` otherwise) to each element are always less than or equal to the corresponding values assigned by the original function `f`, under the given condition.

For any Preorder M with a Zero instance, set s, and function f from a type α to M, if f(x) ≤ 0 for all x ∈ α \ s, then χ\_s (x) ≤ f(x) for all x ∈ α, where χ\_s is the indicator function of set s.


/-- The **Cayley-Hamilton Theorem**, that the characteristic polynomial of a matrix,
applied to the matrix itself, is zero.

This holds over any commutative ring.

See `LinearMap.aeval_self_charpoly` for the equivalent statement about endomorphisms.
 -/
theorem Matrix.aeval_self_charpoly :
    ∀ {R : Type u_1} [inst : CommRing R] {n : Type u_4} [inst_1 : DecidableEq n] [inst_2 : Fintype n]
      (M : Matrix n n R), (Polynomial.aeval M) (Matrix.charpoly M) = 0 :=
  by sorry

The Cayley-Hamilton theorem states that the characteristic polynomial of a matrix, when applied to the matrix itself, yields zero. This theorem holds for any commutative ring. In particular, for any commutative ring `R`, and for any matrix `M` with entries in `R` and indices from a decidable and finite type `n`, the algebra homomorphism generated by applying the polynomial `Matrix.charpoly M` to the matrix `M` results in zero. There is an equivalent statement about endomorphisms, `LinearMap.aeval_self_charpoly`.

The characteristic polynomial of a matrix, when evaluated at the matrix itself, yields the zero matrix.


theorem Basis.equivFun_apply :
    ∀ {ι : Type u_1} {R : Type u_3} {M : Type u_6} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
      [inst_3 : Finite ι] (b : Basis ι R M) (u : M), (Basis.equivFun b) u = ⇑(b.repr u) :=
  by sorry

The theorem `Basis.equivFun_apply` states that for any type `ι`, any semiring `R`, any additively commutative monoid `M`, and any `M` module over `R` with a finite basis `b` and any element `u` of `M`, the application of the function `Basis.equivFun` to `u` is equal to the application of the coordinate representation of `u` with respect to the basis `b`. In other words, the function `Basis.equivFun` gives the same result as directly computing the coordinates of `u` in the basis `b`.

For any type `ι`, semiring `R`, additively commutative monoid `M` with a finite basis `b`, and `M` module `u` over `R`, `Basis.equivFun u = coordRep_basis b u`, where `coordRep_basis` denotes the coordinate representation function with respect to `b`.


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

This theorem states that for any type `α`, an index type `ι`, a dependent type `κ` indexed by `ι`, a function `s` that given `i` of type `ι` and `j` of type `κ i` returns a set of elements of type `α`, and an element `a` of type `α`, if `a` is in the set `s i j` for some given `i` and `j`, then `a` is in the union over all `i` and `j` of the sets `s i j`. In other words, if an element belongs to a specific set in a collection of sets indexed by two parameters, it belongs to the union of these sets.

If for all `i:` `ι` and `j:` `κ i`, `a:` `α` belongs to `s i j`, then `a` belongs to the union of all `s i j`.


theorem IsPrimitiveRoot.eq_orderOf :
    ∀ {M : Type u_1} [inst : CommMonoid M] {k : ℕ} {ζ : M}, IsPrimitiveRoot ζ k → k = orderOf ζ := by sorry

This theorem states that for any type `M` that is a commutative monoid, given a natural number `k` and an element `ζ` of `M`, if `ζ` is a primitive root of `k`, then `k` is equal to the order of `ζ`. Here, a primitive root of `k` is an element `ζ` such that `ζ` to the power of `k` is equal to 1, and the order of an element `ζ` is the smallest natural number `n` such that `ζ` to the power of `n` is equal to 1. If no such `n` exists, the order of `ζ` is defined to be 0.

For any commutative monoid `M` and element `ζ` of `M`, if `ζ` is a primitive root of the natural number `k`, then the order of `ζ` equals `k`.


theorem Opposite.op_injective : ∀ {α : Sort u}, Function.Injective Opposite.op := by sorry

The theorem `Opposite.op_injective` states that for all types or sorts `α`, the function `Opposite.op` is injective. In other words, if we have two elements `a₁` and `a₂` from `α` such that applying the function `Opposite.op` to both `a₁` and `a₂` results in the same output, then `a₁` and `a₂` must be the same. Here, `Opposite.op` is the canonical map that maps an element `x` from a type `α` to the opposite type `αᵒᵖ`, which simply wraps `x` in a structure with a single field `unop`.

For all types `α`, if `Opposite.op a₁ = Opposite.op a₂`, then `a₁ = a₂`.


theorem Profinite.NobelingProof.ord_term_aux :
    ∀ {I : Type u} [inst : LinearOrder I] [inst_1 : IsWellOrder I fun x x_1 => x < x_1] {o : Ordinal.{u}}
      (ho : o < Ordinal.type fun x x_1 => x < x_1),
      Profinite.NobelingProof.ord I (Profinite.NobelingProof.term I ho) = o :=
  by sorry

The theorem `Profinite.NobelingProof.ord_term_aux` states that for any type `I`, given a linear order and a well-ordering on `I`, and for any ordinal `o` less than the order type of `I`, when one sends `o` to `I` using the `Profinite.NobelingProof.term` function and then sends the result back to the ordinals using `Profinite.NobelingProof.ord`, one obtains the original ordinal `o`. This demonstrates a property of these two operations acting as a form of an inverse pair for the given conditions.

Given a linear order and a well-ordering on a type `I`, the functions `Profinite.NobelingProof.term` and `Profinite.NobelingProof.ord` form an inverse pair, preserving ordinals below the order type of `I`.


theorem Polynomial.smul_C :
    ∀ {R : Type u} [inst : Semiring R] {S : Type u_1} [inst_1 : SMulZeroClass S R] (s : S) (r : R),
      s • Polynomial.C r = Polynomial.C (s • r) :=
  by sorry

This theorem, `Polynomial.smul_C`, states that for any semiring `R`, and any type `S` which forms a `SMulZeroClass` with `R`, the operation of scalar multiplication `s • Polynomial.C r` (where `s` is a scalar from `S` and `r` is an element of `R`) is equivalent to `Polynomial.C (s • r)`. In other words, scalar multiplication distributes over the constant polynomial constructor `Polynomial.C`. This is a property related to the commutativity of scalar multiplication with respect to polynomial constants.

For any semiring `R` and type `S` forming `SMulZeroClass` with `R`, the scalar multiplication of an element `s` in `S` with a constant polynomial `Polynomial.C r` in `R` is equivalent to the constant polynomial of the scalar multiplication result `s • r`.


ContinuousOn.congr

theorem ContinuousOn.congr :
    ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] {f g : α → β} {s : Set α},
      ContinuousOn f s → Set.EqOn g f s → ContinuousOn g s :=
  by sorry

This theorem states that for any two functions `f` and `g` from a topological space `α` to a topological space `β`, and any set `s` in the space `α`, if the function `f` is continuous on the set `s` and the function `g` is equal to `f` for every point in the set `s`, then the function `g` is also continuous on the set `s`. In mathematical terms, if \(f: \alpha \to \beta\) is continuous on a subset \(S \subset \alpha\) and \(g(x) = f(x)\) for all \(x \in S\), then \(g\) is also continuous on \(S\).

If a function `f` is continuous on a subset `S` of a topological space `α` and `g(x) = f(x)` for all `x` in `S`, then `g` is continuous on `S`.


theorem Finsupp.card_Icc :
    ∀ {ι : Type u_1} {α : Type u_2} [inst : PartialOrder α] [inst_1 : Zero α] [inst_2 : LocallyFiniteOrder α]
      (f g : ι →₀ α),
      (Finset.Icc f g).card = Finset.prod (f.support ∪ g.support) fun i => (Finset.Icc (f i) (g i)).card :=
  by sorry

This theorem states that for any two functions `f` and `g` from a type `ι` to a type `α` which have a partial order, a zero, and a locally finite order, the size (or cardinality) of the finite set formed by including all elements `x` such that `f(x) ≤ x ≤ g(x)` is equal to the product of the sizes of the finite sets formed by including all elements `x` such that `f(i) ≤ x ≤ g(i)`, where `i` ranges over the elements in the union of the supports of `f` and `g`. The support of a function is the set of points where the function is non-zero.
In mathematical terms, if $\text{Icc}$ is the interval $[f(x), g(x)]$ and $\text{card}$ denotes the cardinality of a set, the theorem is stated as:
$$\text{card}(\text{Icc}(f,g)) = \prod_{i \in \text{support}(f) \cup \text{support}(g)} \text{card}(\text{Icc}(f(i),g(i)))$$

The cardinality of the set of elements between the images of two functions with a partial order, zero, and locally finite order is equal to the product of the cardinalities of the sets between their images at each support element.


theorem Nat.div_eq_iff_eq_mul_left : ∀ {a b c : ℕ}, 0 < b → b ∣ a → (a / b = c ↔ a = c * b) := by sorry

This theorem states that for any natural numbers `a`, `b`, and `c`, given that `b` is not zero and `b` divides `a`, the quotient of `a` divided by `b` is equal to `c` if and only if `a` is equal to `c` multiplied by `b`. This theorem provides a relationship between division and multiplication in the context of natural numbers.

For natural numbers `a`, `b`, and `c`, `a = c * b` if and only if `b` non-zero and `b` divides `a`, resulting in `a / b = c`.


theorem Polynomial.hom_eval₂ :
    ∀ {R : Type u} {S : Type v} {T : Type w} [inst : Semiring R] (p : Polynomial R) [inst_1 : Semiring S]
      [inst_2 : Semiring T] (f : R →+* S) (g : S →+* T) (x : S),
      g (Polynomial.eval₂ f x p) = Polynomial.eval₂ (RingHom.comp g f) (g x) p :=
  by sorry

This theorem states that for any semirings `R`, `S`, and `T`, a polynomial `p` with coefficients in `R`, a ring homomorphism `f` from `R` to `S`, another ring homomorphism `g` from `S` to `T`, and an element `x` of `S`, the result of first applying the evaluation function `eval₂` to `f`, `x`, and `p` (which evaluates `p` at `x` after applying `f` to the coefficients of `p`), and then applying `g` to the result, is equal to the result of applying the evaluation function `eval₂` to the composition of `g` and `f`, `g(x)`, and `p`. This illustrates the compatibility of the polynomial evaluation process with the composition of ring homomorphisms.

For any semirings R, S, T, ring homomorphisms f : R -> S and g : S -> T, polynomial p with coefficients in R, and element x in S, the application of g to the evaluation of p at x after applying f to its coefficients is equal to the evaluation of p at g(x) through the composition of f and g.


theorem MeasureTheory.measure_biUnion_null_iff :
    ∀ {α : Type u_1} [inst : MeasurableSpace α] {μ : MeasureTheory.Measure α} {ι : Type u_6} {s : Set ι},
      Set.Countable s → ∀ {t : ι → Set α}, ↑↑μ (⋃ i ∈ s, t i) = 0 ↔ ∀ i ∈ s, ↑↑μ (t i) = 0 :=
  by sorry

This theorem, `MeasureTheory.measure_biUnion_null_iff`, states that for any type `α` with a `MeasurableSpace` instance, a measure `μ` in measure theory, and any type `ι`, if we have a countable set `s` of type `ι`, then for any function `t` mapping elements of `ι` to sets of `α`, the measure of the union of all sets `t i` for all `i` in `s` is zero if and only if the measure of each individual set `t i` is zero for all `i` in `s`. That is to say, in measure theory, a countable union of sets has measure zero if and only if each of the sets in the union has measure zero.

For any countable family of measurable sets in a MeasurableSpace with measure μ, their union has measure zero if and only if each set has measure zero.


theorem Set.iUnion₂_subset_iff :
    ∀ {α : Type u_1} {ι : Sort u_4} {κ : ι → Sort u_7} {s : (i : ι) → κ i → Set α} {t : Set α},
      ⋃ i, ⋃ j, s i j ⊆ t ↔ ∀ (i : ι) (j : κ i), s i j ⊆ t :=
  by sorry

This theorem, `Set.iUnion₂_subset_iff`, states that for all types `α` and `ι`, and for a type family `κ` indexed over `ι`, given a doubly-indexed collection of sets `s` (indexed over both `ι` and `κ i`) and a set `t`, the union over all `i` and `j` of the sets `s i j` is a subset of `t` if and only if for each `i` in `ι` and `j` in `κ i`, the set `s i j` is a subset of `t`. In other words, the union of a collection of sets is within some set `t` precisely when each individual set in the collection is within `t`.

For all types `α`, `ι`, and type families `κ`, and for a collection `s` of sets indexed over `ι` and `κ i`, `⋃ₕ i, j in ι × κ i, s i j ⊆ t` if and only if `∀i ∈ ι, ∀j ∈ κ i, s i j ⊆ t`.


theorem CategoryTheory.Limits.Multifork.condition :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {I : CategoryTheory.Limits.MulticospanIndex C}
      (K : CategoryTheory.Limits.Multifork I) (b : I.R),
      CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.Multifork.ι K (I.fstTo b)) (I.fst b) =
        CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.Multifork.ι K (I.sndTo b)) (I.snd b) :=
  by sorry

The theorem `CategoryTheory.Limits.Multifork.condition` states that for any category `C`, multispan index `I`, and a multifork `K` of `I`, for any object `b` in the right index `I.R` of `I`, the composition of the morphism `I.fst b` after the morphism from the point of `K` to the left object `I.fstTo b` is equal to the composition of the morphism `I.snd b` after the morphism from the point of `K` to the left object `I.sndTo b`. In other words, both paths from the cone point of the multifork to the object `b` in the category `C` through the multispan index `I` are equal.

For any category C, multispan index I, object b in I.R, and multifork K of I, the composition of I.fst b with the morphism from the point of K to I.fstTo b equals the composition of I.snd b with the morphism from the point of K to I.sndTo b.


theorem Computation.results_think :
    ∀ {α : Type u} {s : Computation α} {a : α} {n : ℕ},
      Computation.Results s a n → Computation.Results (Computation.think s) a (n + 1) :=
  by sorry

The theorem `Computation.results_think` states that for any type `α`, computation `s` of that type, element `a` of that type, and a natural number `n`, if the computation `s` terminates after exactly `n` steps with the result `a`, then the computation which is the result of delaying `s` for one "tick" (using the function `Computation.think`) terminates after exactly `n + 1` steps with the same result `a`.

For any type `α`, computation `s` of type `Computation α`, element `a` of type `α`, and natural number `n`, if `s` terminates after exactly `n` steps to yield `a`, then `Computation.think (s)` terminates after exactly `n + 1` steps with result `a`.


theorem mabs_inv : ∀ {α : Type u_1} [inst : Lattice α] [inst_1 : Group α] (a : α), mabs a⁻¹ = mabs a := by sorry

The theorem `mabs_inv` states that for all types `α`, where `α` forms a lattice and a group, the absolute value function `mabs` is invariant under taking the inverse. This means that for any element `a` of the type `α`, the absolute value of the inverse of `a` is equal to the absolute value of `a`. In mathematical terms, this could be written as: for any `a` in the group, |a⁻¹| = |a|.

For any element `a` in a group that forms a lattice, |a⁻¹| = |a|.


/-- The exponential characteristic is positive.  -/
theorem expChar_pos : ∀ (R : Type u) [inst : Semiring R] (q : ℕ) [inst : ExpChar R q], 0 < q := by sorry

This theorem states that the exponential characteristic of a semiring, R, is always positive. In the context of this theorem, the exponential characteristic of a semiring, represented by the natural number, q, is a property that characterizes how exponentiation behaves in that semiring. Therefore, the theorem asserts that for any semiring R and any exponential characteristic q of R, the value of q will always be greater than zero.

The exponential characteristic of any semiring is a positive natural number.


MeasureTheory.Integrable.swap

theorem MeasureTheory.Integrable.swap :
    ∀ {α : Type u_1} {β : Type u_3} {E : Type u_6} [inst : MeasurableSpace α] [inst_1 : MeasurableSpace β]
      {μ : MeasureTheory.Measure α} {ν : MeasureTheory.Measure β} [inst_2 : NormedAddCommGroup E]
      [inst_3 : MeasureTheory.SigmaFinite ν] [inst_4 : MeasureTheory.SigmaFinite μ] ⦃f : α × β → E⦄,
      MeasureTheory.Integrable f (MeasureTheory.Measure.prod μ ν) →
        MeasureTheory.Integrable (f ∘ Prod.swap) (MeasureTheory.Measure.prod ν μ) :=
  by sorry

The theorem `MeasureTheory.Integrable.swap` states that for any two types `α` and `β` representing the spaces of integration, and a type `E` representing a normed, additive commutative group, given a measure `μ` on `α`, a measure `ν` on `β`, and a function `f` from the product of `α` and `β` to `E`, if `f` is integrable with respect to the product measure of `μ` and `ν`, then the composition of `f` with the swap function (which switches the order of the pair `(α, β)` to `(β, α)`) is also integrable with respect to the product measure of `ν` and `μ`. This theorem assumes that both `μ` and `ν` are sigma-finite measures, meaning they can be decomposed into a countable union of sets with finite measure.

If `μ` is a sigma-finite measure on `α`, `ν` is a sigma-finite measure on `β`, and `f : α × β → E` is integrable with respect to the product measure of `μ` and `ν`, then `f` composed with the swap function is integrable with respect to the product measure of `ν` and `μ`.


theorem MeasureTheory.measure_zero_iff_ae_nmem :
    ∀ {α : Type u_1} [inst : MeasurableSpace α] {μ : MeasureTheory.Measure α} {s : Set α},
      ↑↑μ s = 0 ↔ ∀ᵐ (a : α) ∂μ, a ∉ s :=
  by sorry

This theorem states that for any type `α` equipped with a `MeasurableSpace` structure, any measure `μ` on `α`, and any set `s` of elements of `α`, the measure of `s` with respect to `μ` is zero if and only if almost every element of `α` (with respect to the measure `μ`) is not a member of `s`. In other words, a set has zero measure if and only if it does not contain almost all elements.

For any measurable space `(α, Σ, μ)`, a set `s ∈ Σ` has measure zero with respect to `μ` if and only if its complement is almost everywhere contained in `s`.


theorem Ordinal.derivFamily_succ :
    ∀ {ι : Type u} (f : ι → Ordinal.{max u v} → Ordinal.{max u v}) (o : Ordinal.{max u v}),
      Ordinal.derivFamily f (Order.succ o) = Ordinal.nfpFamily f (Order.succ (Ordinal.derivFamily f o)) :=
  by sorry

This theorem states that for any type `ι` and function `f` from `ι` to an ordinal, and for any ordinal `o`, the derivative of `f` at the successor of `o` is equal to the next common fixed point of `f` at the successor of the derivative of `f` at `o`. In simpler terms, it relates the concepts of derivatives and successors in the context of ordinal arithmetic and normal function families. The theorem provides an important property concerning the interplay between the operation of taking derivatives and successors within the specific mathematical structure of ordinals and normal functions.

For any type `ι`, function `f` from `ι` to an ordinal, and ordinal `o`, the derivative of `f` at the successor of `o` is equal to the next common fixed point of `f` at the successor of the derivative of `f` at `o`.


AntilipschitzWith.injective

theorem AntilipschitzWith.injective :
    ∀ {α : Type u_4} {β : Type u_5} [inst : EMetricSpace α] [inst_1 : PseudoEMetricSpace β] {K : NNReal} {f : α → β},
      AntilipschitzWith K f → Function.Injective f :=
  by sorry

The theorem `AntilipschitzWith.injective` states that, for any two types `α` and `β` where `α` is an extended metric space and `β` is a pseudo extended metric space, and given a nonnegative real number `K` and a function `f` from `α` to `β`, if the function `f` has the property `AntilipschitzWith K`, meaning that the extended distance between any two points in `α` is less than or equal to `K` times the extended distance between their images under `f` in `β`, then the function `f` is injective, that is, equal images under `f` have equal preimages. In other words, if a function distorts distances by a bounded factor, then it does not map distinct points to the same point.

If a function between extended metric spaces with the Antilipschitz property with constant K is non-expanding, then it is injective.


theorem affineSpan_le :
    ∀ {k : Type u_1} {V : Type u_2} {P : Type u_3} [inst : Ring k] [inst_1 : AddCommGroup V] [inst_2 : Module k V]
      [S : AddTorsor V P] {s : Set P} {Q : AffineSubspace k P}, affineSpan k s ≤ Q ↔ s ⊆ ↑Q :=
  by sorry

This theorem states that for all types `k`, `V`, and `P` in which `k` is a ring, `V` is an additive commutative group, and `V` is a `k`-module, and for all `s` which is a set of type `P` and `Q` which is an affine subspace of `P` over the ring `k`, the affine span of `s` is a subset of `Q` if and only if `s` is a subset of the carrier of `Q`. This theorem is about the relationship between the affine span of a set of points and a given affine subspace, and it provides a condition under which the set of points is contained within the affine subspace.

For a ring `k`, an additive commutative group `V` that is a `k`-module, a set `s` of type `P` in `V`, and an affine subspace `Q` of `P` over `k`, the affine span of `s` is contained in `Q` if and only if `s` is a subset of the carrier of `Q`.


theorem Nat.mod_eq : ∀ (x y : ℕ), x % y = if 0 < y ∧ y ≤ x then (x - y) % y else x := by sorry

This theorem states that for any two natural numbers `x` and `y`, the modulo of `x` with respect to `y` is equal to the modulo of the difference of `x` and `y` with respect to `y` if `y` is greater than 0 and less than or equal to `x`. Otherwise, the modulo of `x` with respect to `y` is `x` itself. Essentially, it describes how the modulo operation behaves with respect to subtraction and conditions on `y`.

For all natural numbers x and y, if y > 0 and y <= x then x % y = (x - y) % y.


theorem Cardinal.power_add : ∀ {a b c : Cardinal.{u_1}}, a ^ (b + c) = a ^ b * a ^ c := by sorry

This theorem, `Cardinal.power_add`, states that for any three cardinal numbers `a`, `b`, and `c`, the cardinality of the power set of `a` with `b + c` as exponent is equal to the product of the cardinality of the power set of `a` with `b` as exponent and the cardinality of the power set of `a` with `c` as exponent. This is analogous to the power of sums rule in algebra, which states for any real numbers x, y and z, (x^(y+z)) = x^y * x^z.

For any cardinal number `a`, the cardinality of the power set of `a` raised to the power of `b + c` is equal to the product of the cardinalities of the power sets of `a` raised to the powers of `b` and `c`.


theorem isGLB_lt_iff :
    ∀ {α : Type u} [inst : LinearOrder α] {s : Set α} {a b : α}, IsGLB s a → (a < b ↔ ∃ c ∈ s, c < b) := by sorry

This theorem states that for any type `α` that is a linear order, and for any set `s` of type `α` and any two elements `a` and `b` of type `α`, if `a` is a greatest lower bound of set `s`, then `a` is less than `b` if and only if there exists an element `c` in set `s` that is less than `b`. In other words, a greatest lower bound of a set is less than another quantity if and only if there's a member in the set that is also less than this quantity. This theorem is a key property that characterizes greatest lower bounds in the context of linear orders.

For any linear order type `α`, any set `s` of type `α`, and any two elements `a` and `b` of type `α`, if `a` is the greatest lower bound of `s`, then `a < b` if and only if there exists `c` in `s` such that `c < b`.


theorem CliffordAlgebra.reverse_ι :
    ∀ {R : Type u_1} [inst : CommRing R] {M : Type u_2} [inst_1 : AddCommGroup M] [inst_2 : Module R M]
      {Q : QuadraticForm R M} (m : M), CliffordAlgebra.reverse ((CliffordAlgebra.ι Q) m) = (CliffordAlgebra.ι Q) m :=
  by sorry

The theorem `CliffordAlgebra.reverse_ι` states that for any commutative ring `R`, an additive commutative group `M`, a module `M` over `R`, and a quadratic form `Q` on `M`, the reverse of the image of any element `m` of `M` under the canonical linear map `ι` from `M` to the Clifford Algebra of `Q`, is equal to the same image. This means, in mathematical terms, if you map an element from the module to the Clifford Algebra and then apply the grade reversion operation, you get the same element in the Clifford Algebra.

For any commutative ring R, additive commutative group M with a quadratic form Q, and module M over R, the map ι from M to the Clifford Algebra of Q satisfies ι(m) = ι(−m) for all m in M.


ringChar.eq

theorem ringChar.eq : ∀ (R : Type u_1) [inst : NonAssocSemiring R] (p : ℕ) [C : CharP R p], ringChar R = p := by sorry

This theorem states that for any type `R` that forms a non-associative semiring, and any natural number `p` for which `R` has characteristic `p`, the unique characteristic of the semiring `R` (as computed by the `ringChar` function) is equal to `p`. Essentially, this means that the `ringChar` function correctly computes the characteristic of a semiring.

For any non-associative semiring `R` of characteristic `p`, the `ringChar` function returns `p`.


theorem Mathlib.Data.Real.NNReal._auxLemma.33 : ∀ {r : ℝ}, (Real.toNNReal r = 0) = (r ≤ 0) := by sorry

This theorem, `Mathlib.Data.Real.NNReal._auxLemma.33`, states that for any real number `r`, the result of applying the `Real.toNNReal` function (which converts a real number to a non-negative real number, returning `0` if the number is less than `0`) to `r` equals `0` if and only if `r` is less than or equal to `0`. In mathematical terms, for all $r \in \mathbb{R}$, $\text{Real.toNNReal}(r) = 0$ if and only if $r \le 0$.

For all real numbers $r$, $\text{Real.toNNReal}(r) = 0$ if and only if $r \leq 0$.


theorem Finset.coe_inf' :
    ∀ {α : Type u_2} {β : Type u_3} [inst : SemilatticeInf α] {s : Finset β} (H : s.Nonempty) (f : β → α),
      ↑(Finset.inf' s H f) = Finset.inf s (WithTop.some ∘ f) :=
  by sorry

The theorem `Finset.coe_inf'` states that for any semilattice (a partially ordered set in which any two elements have a greatest lower bound) `α` and any nonempty finite set `s` of elements of type `β`, and any function `f` mapping `β` to `α`, the infimum of the image of `s` under `f` (obtained using the `Finset.inf'` function) when raised to the "with top" (a type extension that adds a new "top" element to a type) space is equal to the infimum of the image of `s` under the function composed of `f` and `WithTop.some` (which maps any element to the "with top" space). In other words, adding a top element and calculating the infimum in the resulting extended space is the same as calculating the infimum in the original space and then adding the top element.

For any semilattice α, nonempty finite set s of elements β, and function f : β → α, the infimum of the image of s under f in the extended space with top element is equal to the infimum of the image of s under the function composed of f and the inclusion map to the extended space.


theorem LieSubmodule.lie_le_right :
    ∀ {R : Type u} {L : Type v} {M : Type w} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L]
      [inst_3 : AddCommGroup M] [inst_4 : Module R M] [inst_5 : LieRingModule L M] (N : LieSubmodule R L M)
      (I : LieIdeal R L), ⁅I, N⁆ ≤ N :=
  by sorry

The theorem `LieSubmodule.lie_le_right` states that for any commutative ring `R`, Lie ring `L`, and additive commutative group `M` that's a module over `R` and a Lie ring module over `L`, and for any Lie submodule `N` of `R, L, M` and any Lie ideal `I` of `R, L`, the Lie bracket of `I` and `N` is a subset of `N`. This theorem is essentially saying that the action of a Lie ideal on a Lie submodule (by means of the Lie bracket) stays within the submodule.

For any commutative ring `R`, Lie ring `L`, additive commutative group `M` (as an `R`-module and a `L`-Lie module), Lie submodule `N` of `R`, `L`, `M`, and Lie ideal `I` of `R`, `L`, the Lie bracket of `I` and `N` is a subset of `N`.


Set.Finite.partiallyWellOrderedOn

theorem Set.Finite.partiallyWellOrderedOn :
    ∀ {α : Type u_2} {r : α → α → Prop} {s : Set α} [inst : IsRefl α r],
      Set.Finite s → Set.PartiallyWellOrderedOn s r :=
  by sorry

The theorem `Set.Finite.partiallyWellOrderedOn` states that for any given type `α`, relation `r` on `α`, and set `s` of type `α`, where `r` is a reflexive relation (meaning that every element is related to itself), if the set `s` is finite, then `s` is partially well-ordered by the relation `r`. In other words, for any infinite sequence drawn from the set `s`, there exist two indices `m` and `n` such that `m` is less than `n` and the `m`-th element of the sequence is related to the `n`-th element via `r`.

If `α` is a type, `r` is a reflexive relation on `α`, and `s` is a finite set of `α` with respect to `=`, then `s` is partially ordered by `r`.


theorem lt_of_le_of_ne' : ∀ {α : Type u} [inst : PartialOrder α] {a b : α}, a ≤ b → b ≠ a → a < b := by sorry

This theorem, named `lt_of_le_of_ne'`, states that for any partially ordered set of type α, if an element `a` is less than or equal to another element `b` and `b` is not equal to `a`, then `a` is strictly less than `b`. This encapsulates the intuitive idea that if one element is not more than another and the two are not identical, then it must be that the first element is indeed less than the second.

If `a` is less than or equal to `b` and `a` is not equal to `b` in a partially ordered set, then `a` is strictly less than `b`.


theorem Decidable.not_imp_symm : ∀ {a b : Prop} [inst : Decidable a], (¬a → b) → ¬b → a := by sorry

This theorem states that for any two propositions `a` and `b`, where `a` is decidable, if we have a function from the negation of `a` to `b`, and the negation of `b` holds, then `a` must be true. Essentially, it is stating that if `a` being false implies `b`, and `b` is false, then `a` must be true, which is a form of contraposition in logic.

If `a` is decidable and there exists a function from ∼`a` to `b` when ∼`b` holds, then `a` is true. (This is a form of contrapositive of the conditional `a → b` in logic, where `→` denotes material implication.)


theorem Ordnode.dual_rotateR :
    ∀ {α : Type u_1} (l : Ordnode α) (x : α) (r : Ordnode α),
      Ordnode.dual (Ordnode.rotateR l x r) = Ordnode.rotateL (Ordnode.dual r) x (Ordnode.dual l) :=
  by sorry

The theorem `Ordnode.dual_rotateR` states that for any type `α`, and for any ordered nodes `l` and `r`, and an element `x` of the type `α`, the operation of taking the dual of the right rotation of `l`, `x`, and `r` is equal to the left rotation of the dual of `r`, `x`, and the dual of `l`. Here, duality refers to the operation of reversing the order of elements in the ordered node structure, while right and left rotations are operations used to balance binary search trees after insertions or deletions.

For any type `α` and ordered nodes `l`, `r`, and `x` of type `α`, the dual of the right rotation of `l`, `x`, and `r` equals the left rotation of the dual of `r`, `x`, and the dual of `l`.


theorem Rat.normalize_zero : ∀ {d : ℕ} (nz : d ≠ 0), Rat.normalize 0 d nz = 0 := by sorry

The theorem `Rat.normalize_zero` states that for any natural number `d` that is not zero, if we use the `Rat.normalize` function to normalize zero and `d`, the result will be zero. In other words, the normalized form of the rational number formed by the integer 0 and any non-zero natural number `d` is always 0.

For any non-zero natural number `d`, `Rat.normalize 0 d` equals zero.


theorem Polynomial.roots_zero : ∀ {R : Type u} [inst : CommRing R] [inst_1 : IsDomain R], Polynomial.roots 0 = 0 := by
  sorry

The theorem `Polynomial.roots_zero` states that for any type `R` that is a commutative ring and an integral domain, the roots of the zero polynomial are an empty multiset. This is consistent with the mathematical convention, as the zero polynomial does not have any roots in an integral domain.

In an integral domain, the zero polynomial has no roots.


theorem List.zip_map :
    ∀ {α : Type u_1} {γ : Type u_2} {β : Type u_3} {δ : Type u_4} (f : α → γ) (g : β → δ) (l₁ : List α) (l₂ : List β),
      List.zip (List.map f l₁) (List.map g l₂) = List.map (Prod.map f g) (List.zip l₁ l₂) :=
  by sorry

The theorem `List.zip_map` states that for any types `α`, `γ`, `β`, and `δ`, and any functions `f : α → γ` and `g : β → δ`, if you have two lists `l₁ : List α` and `l₂ : List β`, applying `f` to each element of `l₁` and `g` to each element of `l₂`, and then zipping these two lists together is equal to first zipping `l₁` and `l₂` together and then applying the function `Prod.map f g` (which applies `f` to the first component of a pair and `g` to the second) to each pair in the zipped list. In other words, zipping two mapped lists is equivalent to mapping the zipped list with the appropriately pair-wise function.

For any types `α`, `γ`, `β`, and `δ`, and functions `f : α → γ` and `g : β → δ`, the zip of the lists `List.map f l₁` and `List.map g l₂` is equal to `List.map (Prod.map f g) (List.zip l₁ l₂)`.


theorem interior_eq_empty_iff_dense_compl :
    ∀ {X : Type u} {s : Set X} [inst : TopologicalSpace X], interior s = ∅ ↔ Dense sᶜ := by sorry

The theorem `interior_eq_empty_iff_dense_compl` states that for any type `X` and a set `s` of `X` in a given topological space, the interior of `s` is empty if and only if the complement of `s` (`sᶜ`) is dense in that topological space. In other words, it says that a set's interior being empty is equivalent to every point in the topological space belonging to the closure of the set's complement.

A set's interior is empty if and only if its complement is dense in the topological space.


theorem Mathlib.SetTheory.Cardinal.ENat._auxLemma.1 : ∀ {m n : ℕ∞}, (↑m < ↑n) = (m < n) := by sorry

This theorem from the Mathlib library in Set Theory's Cardinal module states that for any two extended natural numbers `m` and `n`, the inequality of their cardinalities (`m` is less than `n`) is equivalent to the inequality of the numbers themselves. In other words, the cardinality of `m` is less than the cardinality of `n` if and only if `m` is less than `n`.

For any extended natural numbers `m` and `n`, `m` is less than `n` if and only if the cardinality of `m` is less than the cardinality of `n`.


theorem mem_nhds_left :
    ∀ {α : Type ua} [inst : UniformSpace α] (x : α) {s : Set (α × α)}, s ∈ uniformity α → {y | (x, y) ∈ s} ∈ nhds x :=
  by sorry

This theorem states that for any type `α` equipped with a Uniform Space structure, any element `x` of `α`, and any set `s` of pairs of elements from `α` that is in the uniformity of `α`, the set of all elements `y` such that `(x, y)` is in `s` belongs to the neighborhood filter of `x`. In simpler terms, it states that if we have a set of pairs that is 'close' according to the uniformity of the space, then the set of all 'partners' of `x` within that set is a neighborhood of `x`. This theorem is about the relationship between uniform spaces and the concept of neighborhood in topology.

For any uniform space `(α, Σ)` and `x ∈ α`, if `s ∈ Σ` and `(x, y) ∈ s`, then `y ∈ νx` where `νx` is the neighborhood filter of `x`.


theorem CategoryTheory.composePath_toPath :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X Y : C} (f : X ⟶ Y),
      CategoryTheory.composePath (Quiver.Hom.toPath f) = f :=
  by sorry

The theorem `CategoryTheory.composePath_toPath` states that for any given category `C` and any two objects `X` and `Y` in `C`, if there is a morphism `f` from `X` to `Y`, then converting this morphism to a path using `Quiver.Hom.toPath` and then composing this path using `CategoryTheory.composePath` will yield the original morphism `f`. Essentially, it asserts the equivalence between the morphism `f` and its corresponding path representation when composed back to a morphism.

For any category C and objects X, Y with a morphism f : X -> Y, the composed path of f's path representation and the identity path at Y equals f itself. (CategoryTheory.composePath (Quiver.Hom.toPath f) (CategoryTheory.pathId Y) = f)


/-- If `a` semiconjugates `x` to `y` and `x'` to `y'`,
then it semiconjugates `x * x'` to `y * y'`.  -/
theorem SemiconjBy.mul_right :
    ∀ {S : Type u_1} [inst : Semigroup S] {a x y x' y' : S},
      SemiconjBy a x y → SemiconjBy a x' y' → SemiconjBy a (x * x') (y * y') :=
  by sorry

This theorem states that if a element `a` of a semigroup `S` semiconjugates two pairs of elements `(x, y)` and `(x', y')`, i.e., `a * x = y * a` and `a * x' = y' * a`, then `a` also semiconjugates the product of these pairs `(x * x', y * y')`. In other words, if the multiplication of `a` and `x` changes the order of multiplication with respect to `y`, and the same holds for `x'` and `y'`, then the same property holds for the products `x * x'` and `y * y'`.

If `a` semiconjugates `(x, y)` and `(x', y')` in a semigroup `S`, then `a` semiconjugates their product `(x * x', y * y')`.


theorem Polynomial.mem_degreeLE :
    ∀ {R : Type u} [inst : Semiring R] {n : WithBot ℕ} {f : Polynomial R},
      f ∈ Polynomial.degreeLE R n ↔ Polynomial.degree f ≤ n :=
  by sorry

This theorem states that for any semiring `R`, any value `n` of type `WithBot ℕ` (which is essentially a natural number that can also be "bottom" or undefined), and any polynomial `f` over `R`, the polynomial `f` is in the `R`-submodule of `R[X]` consisting of polynomials of degree ≤ `n` if and only if the degree of the polynomial `f` is less than or equal to `n`. The degree of a polynomial is defined as the largest exponent in it, or "bottom" if the polynomial is equal to zero.

For any semiring R, a polynomial f over R is in the R-submodule of polynomials of degree ≤ n if and only if the degree of f is less than or equal to n.


Nat.Primrec'.const

theorem Nat.Primrec'.const : ∀ {n : ℕ} (m : ℕ), Nat.Primrec' fun x => m := by sorry

This theorem states that for any natural number `n` and `m`, the function that always returns `m` (i.e., a constant function) is primitive recursive. In other words, regardless of the input `x`, the function always outputs the constant value `m`, and this function is defined to be primitive recursive. Primitive recursive functions are a class of functions that can be obtained by a restricted set of operations, and the fact that a constant function is within this class is what this theorem asserts.

The constant function from natural numbers to a constant value is a primitive recursive function.


theorem isConj_iff_eq : ∀ {α : Type u_1} [inst : CommMonoid α] {a b : α}, IsConj a b ↔ a = b := by sorry

This theorem states that for any type `α` that is a commutative monoid, and for any two elements `a` and `b` of `α`, `a` is conjugate to `b` if and only if `a` is equal to `b`. In mathematical terms, the proposition "there exists a unit `c` such that `c * a * c⁻¹ = b`" is equivalent to the proposition "`a` equals `b`".

For any commutative monoid type `α`, element equality `(a = b)` is equivalent to the existence of a unit `c` such that `c * a * c⁻¹ = b` (conjugate equality).


theorem Complex.zero_re : 0.re = 0 := by sorry

This theorem states that the real part of the complex number zero is zero. In the field of complex numbers, each number is represented as a combination of a real part and an imaginary part. This theorem confirms that for the complex number zero, the real part is also zero.

The real part of the complex number zero is equal to zero.


theorem Nat.Coprime.gcd_mul_left_cancel : ∀ {k n : ℕ} (m : ℕ), Nat.Coprime k n → Nat.gcd (k * m) n = Nat.gcd m n := by
  sorry

The theorem `Nat.Coprime.gcd_mul_left_cancel` states that for any natural numbers `k`, `n` and `m`, if `k` and `n` are coprime (their greatest common divisor is `1`), then the greatest common divisor of `k * m` and `n` is the same as the greatest common divisor of `m` and `n`. In other words, multiplying `m` with a number that is coprime to `n` does not change the greatest common divisor of `m` and `n`.

If natural numbers `k`, `n`, and `m` are coprime, then the greatest common divisor of `k * m` and `n` equals the greatest common divisor of `m` and `n`.


theorem MeasureTheory.SimpleFunc.finMeasSupp_iff :
    ∀ {α : Type u_1} {β : Type u_2} {m : MeasurableSpace α} [inst : Zero β] {μ : MeasureTheory.Measure α}
      {f : MeasureTheory.SimpleFunc α β},
      MeasureTheory.SimpleFunc.FinMeasSupp f μ ↔ ∀ (y : β), y ≠ 0 → ↑↑μ (↑f ⁻¹' {y}) < ⊤ :=
  by sorry

This theorem states that a `MeasureTheory.SimpleFunc` `f` has finite measure support with respect to measure `μ` if and only if for any value `y` in the codomain, if `y` is not zero then the measure of the preimage of `y` under `f` is less than infinity. In other words, the function `f` is equal to zero except on a set of finite measure.

A function `f` in the category of `MeasureTheory.SimpleFunc` has finite measure support with respect to measure `μ` if and only if for all codomain values `y` different from zero, the preimage of `y` under `f` has finite measure.


theorem star_lt_star_iff :
    ∀ {R : Type u} [inst : NonUnitalSemiring R] [inst_1 : PartialOrder R] [inst_2 : StarOrderedRing R] {x y : R},
      star x < star y ↔ x < y :=
  by sorry

This theorem is a statement about objects in a certain kind of mathematical structure called a 'star ordered ring', which is a non-unital semiring with a partial order and a star operation. The theorem states that for any two elements 'x' and 'y' in such a ring 'R', the star of 'x' is less than the star of 'y' if and only if 'x' is less than 'y'. In other words, the star operation preserves the order of the elements in these rings.

In a star ordered ring, the star operation preserves the order, that is, x ≤ y if and only if *x* ≤ *y*.


theorem AList.lookupFinsupp_apply :
    ∀ {α : Type u_1} {M : Type u_2} [inst : Zero M] [inst_1 : DecidableEq α] (l : AList fun _x => M) (a : α),
      (AList.lookupFinsupp l) a = Option.getD (AList.lookup a l) 0 :=
  by sorry

The theorem `AList.lookupFinsupp_apply` states that for any type `α`, another type `M` that has a zero element, and an instance of decidable equality on `α`, given an association list `l` of type `α` to `M` and a value `a` of type `α`, the application of the function `AList.lookupFinsupp` on `l` to `a` is equal to the result of the function `Option.getD` applied to the lookup of `a` in `l` with a default value of zero. In other words, it asserts that looking up a key `a` in the finitely supported function derived from an association list `l` is the same as retrieving the value associated with `a` in `l`, or zero if `a` is not in `l`.

For any type `α` with decidable equality, and an association list `l` of type `α` to `M` with a zero element `M`, the application of `AList.lookupFinsupp l a` is equal to `Option.getD (AList.find l a)` or `0`.


/-- **Alias** of `IsClosedMap.isClosed_range`. -/
theorem IsClosedMap.closed_range :
    ∀ {X : Type u_1} {Y : Type u_2} {f : X → Y} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y],
      IsClosedMap f → IsClosed (Set.range f) :=
  by sorry

The theorem `IsClosedMap.closed_range` states that for any function `f` mapping from type `X` to type `Y`, where `X` and `Y` are equipped with a topological space structure, if `f` is a closed map (meaning the image of any closed set in `X` under `f` is also a closed set in `Y`), then the range of `f` (which is the set of all the outputs `f` can produce) is a closed set in `Y`. In other words, if `f` preserves the property of being closed under mapping, then the entire set of possible outputs of `f` is also a closed set.

If `f` is a closed map from a topological space `(X, τX)` to another topological space `(Y, τY)`, then the range of `f` is a closed set in `(Y, τY)`.


theorem Set.preimage_eq_iff_eq_image :
    ∀ {α : Type u} {β : Type v} {f : α → β},
      Function.Bijective f → ∀ {s : Set β} {t : Set α}, f ⁻¹' s = t ↔ s = f '' t :=
  by sorry

The theorem `Set.preimage_eq_iff_eq_image` states that for all types `α` and `β`, and a function `f` from `α` to `β` that is bijective, for any set `s` of type `β` and set `t` of type `α`, the preimage of `s` under `f` equals `t` if and only if `s` equals the image of `t` under `f`. This is capturing the relationship between the operations of taking preimages and images for a bijective function. In mathematical language, this would be written as: for a bijective function $f: \alpha \rightarrow \beta$, $f^{-1}(S) = T$ if and only if $S = f(T)$.

For a bijective function $f: \alpha \rightarrow \beta$, the preimage $f^{-1}(S)$ of a set $S \subseteq \beta$ equals the set $T \subseteq \alpha$ if and only if $S$ equals the image $f(T)$ under $f$.


theorem Set.add_image_prod : ∀ {α : Type u_2} [inst : Add α] {s t : Set α}, (fun x => x.1 + x.2) '' s ×ˢ t = s + t := by
  sorry

This theorem, `Set.add_image_prod`, states that for any type `α` equipped with an addition operation, and any sets `s` and `t` of this type, the image of the Cartesian product `s ×ˢ t` under the function `(x.1 + x.2)` is equal to the sum of the sets `s` and `t`. In other words, if you take every pair of elements from `s` and `t`, add them together, and collect all the results into a set, you end up with the same set as if you just added `s` and `t` together directly.

For any set `α` equipped with an addition operation, the image of the Cartesian product `s × t` under the function `λ (x, y) => x + y` is equal to the set `s ∪ t`.


theorem Fintype.card_perm :
    ∀ {α : Type u_1} [inst : DecidableEq α] [inst_1 : Fintype α],
      Fintype.card (Equiv.Perm α) = Nat.factorial (Fintype.card α) :=
  by sorry

The theorem `Fintype.card_perm` states that for any type `α` that has decidable equality and is a finite type, the number of bijections (permutations) from `α` to itself is equal to the factorial of the number of elements in `α`. In mathematical terms, if `α` is a finite set then the number of permutations of `α` is `n!` where `n` is the cardinality of `α`.

For a finite type `α` with decidable equality, the number of bijections from `α` to itself is equal to the factorial of its cardinality.


theorem strictMono_smul_left_of_pos :
    ∀ {α : Type u_1} {β : Type u_2} {a : α} [inst : SMul α β] [inst_1 : Preorder α] [inst_2 : Preorder β]
      [inst_3 : Zero α] [inst_4 : PosSMulStrictMono α β], 0 < a → StrictMono fun x => a • x :=
  by sorry

The theorem `strictMono_smul_left_of_pos` states that for any types `α` and `β`, given a scalar `a` of type `α`, with `α` being a type on which scalar multiplication is defined and having a strict preorder structure, and `β` being a type with a preorder structure, also assuming `α` has a zero element and for any `α` and `β`, positive scalar multiplication is strictly monotone, if `a` is positive (i.e., greater than zero), then the function that multiplies every element of `β` by `a` is strictly monotone. The strict monotonicity means that if any element `b` is greater than an element `c`, then `a • b` is also greater than `a • c`.

If `α` is a type with a strict preorder, scalar multiplication is strictly monotone on `α`, and `a` is a positive scalar in `α`, then the function that maps each element `x` in a type `β` with a preorder to `a * x` is strictly increasing.


theorem abs_abs :
    ∀ {α : Type u_1} [inst : Lattice α] [inst_1 : AddGroup α]
      [inst_2 : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1]
      [inst_3 : CovariantClass α α (Function.swap fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] (a : α), |(|a|)| = |a| :=
  by sorry

The theorem `abs_abs` states that for any type `α` that forms a lattice, an additive group, and satisfies two specific covariance conditions, the absolute value of the absolute value of any element `a` of type `α` is equal to the absolute value of `a`. In mathematical terms, it asserts that for any `a` in such a type `α`, ||a|| = |a|.

For any type `α` that forms a lattice, an additive group, and satisfies the given covariance conditions, the absolute value of an element is equal to the absolute value of its absolute value, i.e., |||a||| = |a|.


theorem SetTheory.PGame.add_lf_add_right :
    ∀ {y z : SetTheory.PGame}, SetTheory.PGame.LF y z → ∀ (x : SetTheory.PGame), SetTheory.PGame.LF (y + x) (z + x) :=
  by sorry

The theorem `SetTheory.PGame.add_lf_add_right` states that for any pre-games `y` and `z`, if `y` is less or fuzzy compared to `z` (meaning that if you start with `z` instead of `0`, the Left player can win), then for any pre-game `x`, the addition of `x` to `y` is also less or fuzzy compared to the addition of `x` to `z`. In other words, adding the same pre-game `x` to both `y` and `z` maintains the less or fuzzy relation between `y` and `z`.

If pre-games `y` is less or fuzzy than `z`, then the sum of any pre-game `x` with `y` is less or fuzzy than the sum of `x` with `z`.


theorem CategoryTheory.Limits.HasBinaryBiproduct.mk :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
      {P Q : C}, CategoryTheory.Limits.BinaryBiproductData P Q → CategoryTheory.Limits.HasBinaryBiproduct P Q :=
  by sorry

This theorem states that in category theory, given a category `C` with zero morphisms, and two objects `P` and `Q` in `C`, if there exists a `BinaryBiproductData` for `P` and `Q`, then `P` and `Q` have a binary biproduct.

In simpler terms, it's saying that if we have some sort of structure (`BinaryBiproductData`) relating two objects in a category that has "zero" morphisms (mappings between objects), then those two objects have a binary biproduct. A binary biproduct is a specific type of "product" and "coproduct" pair in the category.

In a category with zero morphisms, the existence of `BinaryBiproductData` for objects `P` and `Q` implies the existence of a binary biproduct for `P` and `Q`.


HasDerivAt.neg

theorem HasDerivAt.neg :
    ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {F : Type v} [inst_1 : NormedAddCommGroup F]
      [inst_2 : NormedSpace 𝕜 F] {f : 𝕜 → F} {f' : F} {x : 𝕜}, HasDerivAt f f' x → HasDerivAt (fun x => -f x) (-f') x :=
  by sorry

The theorem `HasDerivAt.neg` states that for any type `𝕜` which forms a nontrivially normed field, a type `F` which forms a normed add commutative group and also a normed space over `𝕜`, a function `f` from `𝕜` to `F`, its derivative `f'` at a point `x` in `𝕜`, if `f` has the derivative `f'` at the point `x` (that is, `f` satisfies the equation `f x' = f x + (x' - x) • f' + o(x' - x)` where `x'` converges to `x`), then the function `-f` (the negation of `f`) has the derivative `-f'` (the negation of `f'`) at the same point `x`.

If `𝕜` is a nontrivially normed field, `F` is a normed add commutative group and normed space over `𝕜`, `f : 𝕜 → F` has derivative `f'` at `x ∈ 𝕜`, then `-f` has derivative `-f'` at `x`.


theorem Finset.self_mem_range_succ : ∀ (n : ℕ), n ∈ Finset.range (n + 1) := by sorry

This theorem states that for any natural number `n`, `n` is an element of the set of natural numbers less than `n + 1`. In mathematical terms, for all natural numbers `n`, `n` belongs to the set `{0, 1, 2, ..., n}`.

For every natural number `n`, `n` is an element of the set `{m | m < n + 1}`.


theorem Fin.exists_castSucc_eq : ∀ {n : ℕ} {i : Fin (n + 1)}, (∃ j, Fin.castSucc j = i) ↔ i ≠ Fin.last n := by sorry

This theorem states that for any natural number `n` and any `i : Fin (n + 1)`, there exists a `j` such that `j` cast to `Fin (n + 1)` using `Fin.castSucc` equals `i` if and only if `i` is not the greatest value of `Fin (n+1)`. In other words, every element of `Fin (n + 1)` except for the highest one can be obtained by embedding some element of `Fin n` into `Fin (n + 1)` using the `Fin.castSucc` function.

For any natural number `n` and `i : Fin (n + 1)` not equal to the greatest element, there exists a `j : Fin n` such that `i` is the image of `j` under the `Fin.castSucc` function.


theorem Int.coe_nat_gcd : ∀ (m n : ℕ), Int.gcd ↑m ↑n = Nat.gcd m n := by sorry

This theorem, named `Int.coe_nat_gcd`, states that for any two natural numbers `m` and `n`, the greatest common divisor (gcd) of `m` and `n` calculated in the domain of integers is the same as the gcd of `m` and `n` calculated in the domain of natural numbers. This is denoted as `Int.gcd ↑m ↑n = Nat.gcd m n`, where `↑m` and `↑n` represent the coercion of the natural numbers `m` and `n` to integers.

The greatest common divisor of the coerced natural numbers to integers is equal to the greatest common divisor of the original natural numbers. In mathematical notation: `Int.gcd (coerce m to Int) (coerce n to Int) = Nat.gcd m n`.


theorem ciSup_unique :
    ∀ {α : Type u_1} {ι : Sort u_4} [inst : ConditionallyCompleteLattice α] [inst_1 : Unique ι] {s : ι → α},
      ⨆ i, s i = s default :=
  by sorry

This theorem states that for any type `α` which forms a conditionally complete lattice, and another type `ι` with a unique element, then the supremum (denoted by ⨆) of a function `s : ι → α` over all elements of `ι` is equal to the value of `s` at the default element of `ι`. This makes sense intuitively, as if there is only one element in `ι`, then the supremum of the function values over all `ι` should be just the function value at that unique element.

For any conditionally complete lattice `α` and type `ι` with a unique element, the supremum of a function `s : ι → α` is equal to `s!0`, where `!` denotes the unique element operator.


theorem lt_or_lt_of_mul_lt_mul :
    ∀ {α : Type u_1} [inst : LinearOrder α] [inst_1 : Mul α]
      [inst_2 : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1]
      [inst_3 : CovariantClass α α (Function.swap fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1] {a₁ a₂ b₁ b₂ : α},
      a₁ * b₁ < a₂ * b₂ → a₁ < a₂ ∨ b₁ < b₂ :=
  by sorry

The theorem `lt_or_lt_of_mul_lt_mul` states that for any type `α` that has a linear order and a multiplication operation, and satisfies the covariance property for both multiplication and its swap function (which basically means `α` is an ordered commutative ring), given four elements `a₁`, `a₂`, `b₁`, `b₂` from `α`, if the product of `a₁` and `b₁` is less than the product of `a₂` and `b₂`, then `a₁` is less than `a₂` or `b₁` is less than `b₂`. In simpler terms, given two pairs of numbers, if one pair's product is smaller than the other, then at least one of the components of the smaller pair is less than its corresponding component in the larger pair. This is a formalization of a property of multiplication in ordered commutative rings.

In an ordered commutative ring, if a1 * b1 < a2 * b2, then a1 < a2 or b1 < b2.


theorem Mathlib.Computability.TuringMachine._auxLemma.16 :
    ∀ {α : Type u_1} {a : α} {b : Option α}, (a ∈ b) = (b = some a) := by sorry

This theorem, named `Mathlib.Computability.TuringMachine._auxLemma.16` in the Lean theorem prover, states that for any type `α` and any elements `a` of type `α` and `b` of type `Option α`, `a` is in `b` if and only if `b` is equal to `some a`. In other words, an element `a` is contained in an option `b` if and only if that option is not `none`, but specifically the option of `a`.

For any type `α` and `a : α`, ` Option.equal (some a) (some x) ≃ (x = a) ` (where `Option` is the Lean option type).


theorem memℓp_infty_iff :
    ∀ {α : Type u_1} {E : α → Type u_2} [inst : (i : α) → NormedAddCommGroup (E i)] {f : (i : α) → E i},
      Memℓp f ⊤ ↔ BddAbove (Set.range fun i => ‖f i‖) :=
  by sorry

The theorem `memℓp_infty_iff` states that for any types `α` and `E` (where `E` is a function from `α`), and for any instance of a normed add commutative group on `E`, and for any function `f` from `α` to `E`, the function `f` belongs to `ℓ^∞` (i.e., `f` is in `Memℓp` for `p = ∞`) if and only if the set of norms of `f` is bounded above (i.e., there exists an upper bound for the set of norms of `f`). In other words, a function `f` is in the space `ℓ^∞` if and only if the magnitudes of its values are bounded from above.

A function from a type to a normed add commutative group belongs to the space `ℓ^∞` if and only if its norms are bounded above.


theorem Set.wcovBy_insert : ∀ {α : Type u_1} (x : α) (s : Set α), s ⩿ insert x s := by sorry

The theorem `Set.wcovBy_insert` states that for any type `α`, any element `x` of type `α`, and any set `s` of type `α`, the set `s` is a weak cover of the set obtained by inserting `x` into `s`. This implies that every element in the set obtained by inserting `x` into `s` is also an element of `s`, i.e., `s` contains all the elements of the insert operation.

For any type `α`, any set `s` of `α`, and any `x` in `α`, the set `s` is a weak cover of the set `s.insert x`.