/-- For every set `s` and a countable collection of measures `μ i` there exists a measurable
superset `t ⊇ s` such that each measure `μ i` takes the same value on `s` and `t`.  -/
theorem MeasureTheory.exists_measurable_superset_forall_eq :
    ∀ {α : Type u_1} {ι : Sort u_5} [inst : MeasurableSpace α] [inst_1 : Countable ι] (μ : ι → MeasureTheory.Measure α)
      (s : Set α), ∃ t, s ⊆ t ∧ MeasurableSet t ∧ ∀ (i : ι), ↑↑(μ i) t = ↑↑(μ i) s :=
  by sorry

The theorem `MeasureTheory.exists_measurable_superset_forall_eq` states that for any given set `s` and any countable collection of measures `μ i`, there exists a measurable superset `t` of `s` such that for each measure `μ i`, the measure of `t` is equal to the measure of `s`. Here, `α` is the type of the sets we are measuring, `ι` is the index type for the countable collection of measures, `MeasurableSpace α` is the structure that determines which sets in `α` are measurable, and `Countable ι` means that `ι` is a countable index set. A `MeasureTheory.Measure α` is a measure on the measurable space `α`. The ⊆ symbol denotes subset or equal to, meaning every element of `s` is also an element of `t`.

Given any set `s` and a countable collection of measures `μ i` on the measurable space `(α, MeasurableSpace α)`, there exists a measurable superset `t` of `s` such that for all `i`, the measure `μ i(t)` equals `μ i(s)`.


theorem Nat.compare_def_le :
    ∀ (a b : ℕ), compare a b = if a ≤ b then if b ≤ a then Ordering.eq else Ordering.lt else Ordering.gt := by sorry

This theorem states that for any two natural numbers `a` and `b`, the comparison operation `compare a b` is defined as follows: if `a` is less than or equal to `b`, then check if `b` is less than or equal to `a`; if it is, then `a` and `b` are equal (`Ordering.eq`), otherwise `a` is less than `b` (`Ordering.lt`). If `a` is not less than or equal to `b`, then `a` is greater than `b` (`Ordering.gt`).

For all natural numbers `a` and `b`, `compare a b` is `Ordering.eq` if and only if `a` is less than or equal to `b` and `b` is less than or equal to `a`, and `compare a b` is `Ordering.lt` if and only if `a` is less than `b` and `b` is greater than or equal to `a`.


theorem Composition.one_le_blocksFun :
    ∀ {n : ℕ} (c : Composition n) (i : Fin (Composition.length c)), 1 ≤ Composition.blocksFun c i := by sorry

This theorem states that for any natural number `n` and any composition `c` of that number, the value of the `blocksFun` function at any index `i` (which is a finite number with bound `length c`) will always be greater than or equal to 1. In other words, every block in the composition has at least one element.

For any natural number `n` and composition `c` of length `l` over `n`, the function `blocksFun` at index `i` (where `0 ≤ i < l`) satisfies `blocksFun i ≥ 1`.


Convex.vadd

theorem Convex.vadd :
    ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : OrderedSemiring 𝕜] [inst_1 : AddCommMonoid E] [inst_2 : Module 𝕜 E]
      {s : Set E}, Convex 𝕜 s → ∀ (z : E), Convex 𝕜 (z +ᵥ s) :=
  by sorry

The theorem `Convex.vadd` states that for any ordered semiring `𝕜`, any additive commutative monoid `E` that also is a module over `𝕜`, and any set `s` of elements of `E` which is convex, the translated set `(z +ᵥ s)` is also convex for any element `z` of `E`. In other words, if `s` is a convex set in a vector space, then translating the set by adding a fixed vector `z` to all elements of the set retains the convexity property.

For any ordered semiring `𝕜`, additive commutative monoid `E` over `𝕜` that is an `𝕜`-module, and convex set `s` in `E`, the translated set `(z + s)` is convex for all `z` in `E`.


theorem RatFunc.denom_C : ∀ {K : Type u} [inst : Field K] (c : K), RatFunc.denom (RatFunc.C c) = 1 := by sorry

This theorem, `RatFunc.denom_C`, states that for any field `K` and any element `c` in this field, the denominator of the constant rational function `RatFunc.C c` (which represents the constant rational function `c`) is `1`. In other words, when a constant is viewed as a rational function, its denominator is always `1`.

For any field `K` and constant `c` in `K`, the denominator of the constant rational function `RatFunc.C c` is `1`.


theorem Mathlib.Topology.Instances.ENNReal._auxLemma.70 :
    ∀ {α : Type u} [inst : LinearOrder α] [inst_1 : OrderTop α] {a b : α}, (min a b = ⊤) = (a = ⊤ ∧ b = ⊤) := by sorry

This theorem, `Mathlib.Topology.Instances.ENNReal._auxLemma.70`, states that for any type `α` that is endowed with a linear order and a top element, given any two elements `a` and `b` from `α`, the minimum of `a` and `b` being equal to the top element is equivalent to both `a` and `b` being equal to the top element. In other words, in such a setup, the only way for the minimum of `a` and `b` to be the top element is if both `a` and `b` themselves are the top element.

For any type endowed with a linear order and a top element, the minimum of two elements is the top element if and only if both elements are the top element.


theorem RatFunc.denom_X : ∀ {K : Type u} [inst : Field K], RatFunc.denom RatFunc.X = 1 := by sorry

The theorem `RatFunc.denom_X` states that for any field `K`, the denominator of the rational function represented by the polynomial variable (also known as indeterminate), i.e., `RatFunc.X`, is always 1. In other words, when we treat a polynomial variable as a rational function in any field, its denominator, when normalized so that it's monic, is invariably 1.

For any field K, the denominator of the rational function represented by the polynomial variable X in Lean 4 is equal to 1.


theorem map_inv_int_cast_smul :
    ∀ {M : Type u_5} {M₂ : Type u_6} [inst : AddCommGroup M] [inst_1 : AddCommGroup M₂] {F : Type u_9}
      [inst_2 : FunLike F M M₂] [inst_3 : AddMonoidHomClass F M M₂] (f : F) (R : Type u_10) (S : Type u_11)
      [inst_4 : DivisionRing R] [inst_5 : DivisionRing S] [inst_6 : Module R M] [inst_7 : Module S M₂] (z : ℤ) (x : M),
      f ((↑z)⁻¹ • x) = (↑z)⁻¹ • f x :=
  by sorry

This theorem, `map_inv_int_cast_smul`, states that for any given types `M` and `M₂` that are additive commutative groups, a type `F` that is a function-like from `M` to `M₂` and also an additive monoid homomorphism, types `R` and `S` that are division rings, and `M` and `M₂` are modules over `R` and `S` respectively, then for any integer `z` and element `x` of type `M`, applying the function `f` to the scalar multiplication of `x` by the inverse of the integer `z` cast into type `R` is the same as the scalar multiplication of the function `f` applied to `x` by the inverse of `z` cast into type `S`. In mathematical notation, this can be represented as `f((1/z) * x) = (1/z) * f(x)`. This theorem is a property of linear maps, showing that they preserve scalar multiplication, even when scalars are integers.

For additive commutative groups M and M₂, an additive monoid homomorphism F from M to M₂ over division rings R and S, and x in M and z an integer, the application of F to the scalar multiplication of x by the inverse of z in R is equal to the scalar multiplication of F(x) by the inverse of z in S. In other words, F(x * (1/z)) = (1/z) * F(x).


theorem Vector.exists_eq_cons : ∀ {n : ℕ} {α : Type u_1} (v : Vector α (Nat.succ n)), ∃ a as, v = a ::ᵥ as := by sorry

The theorem `Vector.exists_eq_cons` states that for any natural number `n` and any type `α`, for any vector `v` of length `n+1` with elements of type `α`, there exists an element `a` of type `α` and a vector `as` such that `v` is the result of prepending `a` to `as`. In other words, any `n+1` length vector can be expressed as a head element followed by a vector of length `n`.

For any natural number `n` and type `α`, given a vector `v` of length `n+1` in `α`, there exists an element `a` in `α` and a vector `as` of length `n` such that `v = [a] ++ as`.


theorem dite_dite_distrib_left :
    ∀ {α : Sort u_1} {p q : Prop} [inst : Decidable p] [inst_1 : Decidable q] {a : p → α} {b : ¬p → q → α}
      {c : ¬p → ¬q → α},
      (dite p a fun hp => dite q (b hp) (c hp)) =
        if hq : q then dite p a fun hp => b hp hq else dite p a fun hp => c hp hq :=
  by sorry

This theorem, named `dite_dite_distrib_left`, states that for any propositions `p` and `q`, and any functions `a`, `b`, `c` of types `p → α`, `¬p → q → α`, and `¬p → ¬q → α` respectively, the expression `(dite p a fun hp => dite q (b hp) (c hp))` is equivalent to the expression `if hq : q then dite p a fun hp => b hp hq else dite p a fun hp => c hp hq`. Here, `dite` is a dependent if-then-else construct in Lean, `p` and `q` are propositions, and `α` is some sort expression. This theorem essentially says that under certain conditions, the nesting order of two dependent if-then-else constructs can be swapped.

For any propositions p and q and functions a, b, and c, the dependent if-then-elses `dite p a fun hp => dite q (b hp) (c hp)` and `if hq : q then dite p a fun hp => b hp hq else dite p a fun hp => c hp hq` are equivalent.


Filter.HasBasis.restrict

/-- If `{s i | p i}` is a basis of a filter `l` and each `s i` includes `s j` such that
`p j ∧ q j`, then `{s j | p j ∧ q j}` is a basis of `l`.  -/
theorem Filter.HasBasis.restrict :
    ∀ {α : Type u_1} {ι : Sort u_4} {l : Filter α} {p : ι → Prop} {s : ι → Set α},
      Filter.HasBasis l p s →
        ∀ {q : ι → Prop}, (∀ (i : ι), p i → ∃ j, p j ∧ q j ∧ s j ⊆ s i) → Filter.HasBasis l (fun i => p i ∧ q i) s :=
  by sorry

This theorem states that, given a filter `l` on some type `α`, indexed by a type `ι`, if `{s i | p i}` forms a basis of this filter and for every `i` such that `p i` is true, there exists a `j` such that both `p j` and `q j` are true and the set `s j` is a subset of `s i`, then the collection `{s j | p j ∧ q j}` also forms a basis of filter `l`. In simpler terms, if a filter has a basis where every element includes another set fulfilling some additional property, then the filter also has a basis composed of those included sets.

If `{s i | p i}` is a basis for a filter `l` on type `α` indexed by `ι`, and for all `i`, if `p i` holds then there exists a `j` such that `p j` and `q j` hold and `s j` is a subset of `s i`, then `{s j | p j ∧ q j}` is also a basis for filter `l`.


/-- A product of a function `f : Fin (n + 1) → β` over all `Fin (n + 1)`
is the product of `f x`, for some `x : Fin (n + 1)` times the remaining product  -/
theorem Fin.prod_univ_succAbove :
    ∀ {β : Type u_2} [inst : CommMonoid β] {n : ℕ} (f : Fin (n + 1) → β) (x : Fin (n + 1)),
      (Finset.prod Finset.univ fun i => f i) = f x * Finset.prod Finset.univ fun i => f (Fin.succAbove x i) :=
  by sorry

The theorem `Fin.prod_univ_succAbove` states that for any finite commutative monoid `β`, any natural number `n`, and any function `f` from `Fin (n + 1)` to `β`, and any `x` in `Fin (n + 1)`, the product of `f` over all elements in `Fin (n + 1)` is equal to the product of `f x` times the product of `f` over the elements in `Fin (n + 1)`, where the latter product excludes `x` by using the `Fin.succAbove` function.

In simpler terms, it states that the total product of a function over a finite set is equal to the product of the function's value at a certain point and the product of the function's value at the rest of the points in the set.

For any finite commutative monoid β, natural number n, and function f from Fin (n + 1) to β, the product of f over Fin (n + 1) equals the product of f (x) and the product of f over Fin (n + 1) \{x}, where x is an element of Fin (n + 1) and Fin.succAbove is used to exclude it.


theorem Mathlib.CategoryTheory.PUnit._auxLemma.1 : ∀ {α : Sort u_1} [inst : Subsingleton α] (x y : α), (x = y) = True :=
  by sorry

This theorem, from the Mathlib library in Category Theory, states that for any type `α` that is a subsingleton (i.e., a type that has at most one inhabitant), any two elements `x` and `y` of `α` are necessarily equal. This is expressed by the equality `(x = y) = True`. In other words, in a subsingleton type, all elements are identical.

In a subsingleton type, all elements are equal.


/-- **Hölder inequality**: the scalar product of two functions is bounded by the product of their
`L^p` and `L^q` norms when `p` and `q` are conjugate exponents. A version for `NNReal`-valued
functions. For an alternative version, convenient if the infinite sums are already expressed as
`p`-th powers, see `inner_le_Lp_mul_Lq_hasSum`.  -/
theorem NNReal.inner_le_Lp_mul_Lq_tsum :
    ∀ {ι : Type u} {f g : ι → NNReal} {p q : ℝ},
      Real.IsConjExponent p q →
        (Summable fun i => f i ^ p) →
          (Summable fun i => g i ^ q) →
            (Summable fun i => f i * g i) ∧
              ∑' (i : ι), f i * g i ≤ (∑' (i : ι), f i ^ p) ^ (1 / p) * (∑' (i : ι), g i ^ q) ^ (1 / q) :=
  by sorry

The Hölder's Inequality theorem states that for any type `ι`, functions `f` and `g` from `ι` to nonnegative real numbers, and real numbers `p` and `q` which are conjugate exponents, if the infinite sums of the `p`-th powers of `f(i)` and the `q`-th powers of `g(i)` exist (are summable), then the infinite sum of the products `f(i) * g(i)` also exists, and is less than or equal to the product of the `p`-th root of the sum of `p`-th powers of `f(i)` and the `q`-th root of the sum of `q`-th powers of `g(i)`. This is a version of Hölder's inequality for nonnegative real-valued functions.

For real numbers p, q > 0 with p^{-1} + q^{-1} = 1, and functions f, g from an index set ι to nonnegative real numbers with summable p-th and q-th powers, the sum of products f(i) * g(i) is less than or equal to the product of the p-th root of the sum of the p-th powers of f(i) and the q-th root of the sum of the q-th powers of g(i), for all i in ι.


theorem Real.zero_lt_one : 0 < 1 := by sorry

This theorem is stating that zero is less than one in the set of real numbers. It is a fundamental truth in mathematics that forms the basis for many other mathematical concepts and operations. The theorem doesn't require any specific conditions or assumptions, it is universally valid.

The theorem asserts that 0 < 1 in the set of real numbers.


theorem Equiv.Perm.extendDomain_mul :
    ∀ {α : Type u} {β : Type v} {p : β → Prop} [inst : DecidablePred p] (f : α ≃ Subtype p) (e e' : Equiv.Perm α),
      Equiv.Perm.extendDomain e f * Equiv.Perm.extendDomain e' f = Equiv.Perm.extendDomain (e * e') f :=
  by sorry

The theorem `Equiv.Perm.extendDomain_mul` states that for all types `α` and `β`, and for a given predicate `p` on `β`, under a decidable condition on `p`, the operation `Equiv.Perm.extendDomain` on the product of two permutations `e` and `e'` of `α`, when applied with a bijection `f` from `α` to the subtype of `β` satisfying `p`, yields the same result as the product of the `Equiv.Perm.extendDomain` of `e` and `e'` individually applied with the same bijection `f`. In other words, the extension of the domain of the product of two permutations is the product of the extensions of the domains of the two permutations, when the permutations are bijective with a subset of another type.

Given types `α`, `β`, a predicate `p` on `β` decidable under a condition, and bijective permutations `e` and `e'` of `α` with domains included in the subtype of `β` satisfying `p`, the extension of their product permutation equals the product of their individual extensions using the same bijection.


theorem left_ne_zero_of_mul_eq_one :
    ∀ {M₀ : Type u_2} [inst : MulZeroOneClass M₀] [inst_1 : Nontrivial M₀] {a b : M₀}, a * b = 1 → a ≠ 0 := by sorry

This theorem states that for any type `M₀` that has a multiplication operation, a zero element, and a one element (i.e., belongs to the `MulZeroOneClass`), and is nontrivial (i.e., not every element is equal to every other), if the product of two elements `a` and `b` equals one, then `a` cannot be zero.

If `M₀` is a nontrivial type with multiplication, zero, and one, then `a * b = 1` implies `a ≠ 0`.


theorem QuotientAddGroup.norm_lift_apply_le :
    ∀ {M : Type u_1} {N : Type u_2} [inst : SeminormedAddCommGroup M] [inst_1 : SeminormedAddCommGroup N]
      {S : AddSubgroup M} (f : NormedAddGroupHom M N) (hf : ∀ x ∈ S, f x = 0) (x : M ⧸ S),
      ‖(QuotientAddGroup.lift S (NormedAddGroupHom.toAddMonoidHom f) hf) x‖ ≤ ‖f‖ * ‖x‖ :=
  by sorry

This theorem states that for any seminormed additive commutative groups `M` and `N`, a subgroup `S` of `M`, a normed group homomorphism `f` from `M` to `N`, and a function `hf` that maps any element `x` in `S` to zero via `f`, the norm of the application of the "lifted" group homomorphism `QuotientAddGroup.lift S (NormedAddGroupHom.toAddMonoidHom f) hf` to an element `x` in the quotient group `M ⧸ S` is less than or equal to the product of the norm of `f` and the norm of `x`. Here, "lifted" refers to the process where a homomorphism defined on an original group is extended to a homomorphism defined on the quotient group. The norm ‖.‖ measures the "size" or "length" of an element in a normed group.

For any seminormed additive commutative groups M and N, subgroup S of M, normed group homomorphism f from M to N, and function hf mapping any x in S to zero via f, the norm of the lifted homomorphism QuotientAddGroup.lift (S, f, hf) applied to x in the quotient group M / S is less than or equal to the product of the norm of f and the norm of x.


theorem Units.map_id : ∀ (M : Type u) [inst : Monoid M], Units.map (MonoidHom.id M) = MonoidHom.id Mˣ := by sorry

The theorem `Units.map_id` states that for all types `M` equipped with a monoid structure, the homomorphism induced on units by the identity map on `M` is itself the identity map on the group of units of `M`. In other words, mapping each unit of a monoid `M` via the identity function results in the identity map on the units of `M`. This theorem shows the compatibility of unit mapping and identity mapping in the context of monoids.

For all monoids M, the identity map on M preserves the identity element when restricted to the group of units of M.


BoundedContinuousFunction.integrable

theorem BoundedContinuousFunction.integrable :
    ∀ {X : Type u_1} [inst : MeasurableSpace X] [inst_1 : TopologicalSpace X] [inst_2 : OpensMeasurableSpace X]
      (μ : MeasureTheory.Measure X) {E : Type u_2} [inst_3 : NormedAddCommGroup E] [inst_4 : SecondCountableTopology E]
      [inst_5 : MeasurableSpace E] [inst_6 : BorelSpace E] [inst_7 : MeasureTheory.IsFiniteMeasure μ]
      (f : BoundedContinuousFunction X E), MeasureTheory.Integrable (⇑f) μ :=
  by sorry

This theorem states that for any measure space `X` with a corresponding topological space and open measurable space structures, along with a measure `μ` on `X`, and any normed additive commutative group `E` with a second countable topology, a measurable space structure, and a Borel space structure, if `μ` is a finite measure, then any bounded continuous function `f` from `X` to `E` is integrable with respect to `μ`. Being integrable means that the function is almost everywhere strongly measurable and has a finite integral.

For any finite measure `μ` on a measure space `(X, Σ)` with a corresponding topological space and open measurable space structures, and any second countable normed additive commutative group `(E, +, ||.||)` with a Borel space structure, every bounded continuous function `f : X → E` is integrable with respect to `μ`.


theorem NNReal.tendsto_inverse_atTop_nhds_zero_nat : Filter.Tendsto (fun n => (↑n)⁻¹) Filter.atTop (nhds 0) := by sorry

This theorem states that the sequence of the reciprocals of natural numbers (which is expressed as the function `(fun n => (↑n)⁻¹)`) tends to zero as the numbers go to infinity, represented by `Filter.atTop`. More formally, for every neighborhood of zero, there exists a natural number such that the reciprocals of all natural numbers greater than or equal to it fall into that neighborhood. This is expressed in Lean 4 using the `Filter.Tendsto` predicate, with `(fun n => (↑n)⁻¹)` as the function, `Filter.atTop` denoting the domain filter (representing the sequence going to infinity), and `(nhds 0)` as the codomain filter (representing the neighborhood of zero).

The sequence of reciprocals of natural numbers tends to zero as the numbers approach infinity. (Mathematically expressed as: For every neighborhood of zero, there exists a natural number such that the reciprocals of all natural numbers greater than or equal to it lie within that neighborhood.)


theorem MvPowerSeries.algebraMap_apply :
    ∀ {σ : Type u_1} {R : Type u_2} {A : Type u_3} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A]
      {r : R}, (algebraMap R (MvPowerSeries σ A)) r = (MvPowerSeries.C σ A) ((algebraMap R A) r) :=
  by sorry

The theorem `MvPowerSeries.algebraMap_apply` states that for any type `σ`, any commutative semiring `R`, any semiring `A`, and any element `r` of `R`, if `A` has an algebra structure over `R`, then applying the algebra map from `R` to the multivariate power series over `A` in the variable `σ` to `r` is equivalent to applying the map `MvPowerSeries.C` to the result of applying the algebra map from `R` to `A` to `r`. In simple terms, it says that the multivariate power series of an element in a given algebra structure can be computed by first mapping the element to the algebra and then constructing a constant multivariate power series from this mapped value.

For any commutative semiring `R`, type `σ`, semiring `A` with an algebra structure over `R`, and element `r` in `R`, the application of the algebra map from `R` to the multivariate power series over `A` in the variable `σ` to `r` equals the constant multivariate power series over `A` obtained from applying the algebra map from `R` to `A` to `r`.


theorem System.Platform.numBits_eq : System.Platform.numBits = 32 ∨ System.Platform.numBits = 64 := by sorry

The theorem `System.Platform.numBits_eq` states that the word size of the current platform, as defined by `System.Platform.numBits`, is either 32 or 64. That is, it asserts that the platform is either a 32-bit or a 64-bit system.

The theorem `System.Platform.numBits_eq` asserts that `System.Platform.numBits` is equal to either 32 or 64.


theorem RelSeries.smash.proof_2 :
    ∀ {α : Type u_1} {r : Rel α α} (p q : RelSeries r) (i : Fin (p.length + q.length + 1)),
      ¬↑i < p.length → ↑i - p.length < q.length + 1 :=
  by sorry

This theorem states that for any type `α` and any relation `r` on `α`, given two series of relations `p` and `q` and a finite index `i` that is less than the sum of the lengths of `p` and `q` plus one, if it is not the case that the value of `i` is less than the length of `p`, then the value of `i` subtracted by the length of `p` is less than the length of `q` plus one. This theorem is about manipulating the indices involved in 'smashing' together two series of relations.

For any type `α` and relation `r` on `α`, if index `i` is not less than the length of `p` in a series of relations `p` and `q`, then `i - length(p) < length(q) + 1`.


theorem Int.ediv_mul_le : ∀ (a : ℤ) {b : ℤ}, b ≠ 0 → a / b * b ≤ a := by sorry

This theorem states that for all integers `a` and non-zero integer `b`, the result of integer division of `a` by `b` when multiplied by `b` is less than or equal to `a`. Intuitively, this is because integer division truncates any remainder, so multiplying the quotient by the divisor will not exceed the original dividend.

For all integers a and non-zero b, the result of their integer division a ∕ b satisfies a ≤ (a ∕ b) * b.


/-- The **extreme value theorem**: a continuous function realizes its minimum on a compact set.  -/
theorem IsCompact.exists_isMinOn :
    ∀ {α : Type u_2} {β : Type u_3} [inst : LinearOrder α] [inst_1 : TopologicalSpace α] [inst_2 : TopologicalSpace β]
      [inst_3 : ClosedIicTopology α] {s : Set β},
      IsCompact s → Set.Nonempty s → ∀ {f : β → α}, ContinuousOn f s → ∃ x ∈ s, IsMinOn f s x :=
  by sorry

The **extreme value theorem** states that for any given continuous function that maps from a compact set in a topological space to a linearly ordered set with an order-closed lower set topology, there exists a point in the compact set where the function reaches its minimum value. In other words, a continuous function will always have a minimum value on a compact set. Moreover, if the set is non-empty, then this minimum point is guaranteed to be within the set itself.

A continuous function on a compact set in a topological space attains its minimum value in the set.


theorem Polynomial.exists_root_of_splits' :
    ∀ {K : Type v} {L : Type w} [inst : CommRing K] [inst_1 : Field L] (i : K →+* L) {f : Polynomial K},
      Polynomial.Splits i f → Polynomial.degree (Polynomial.map i f) ≠ 0 → ∃ x, Polynomial.eval₂ i x f = 0 :=
  by sorry

This theorem states that if a polynomial `f` of type `K` splits over a field `L`, denoted as `Polynomial.Splits i f`, where `i` is a ring homomorphism from `K` to `L`, and if the degree of the polynomial `f` mapped into `L` is non-zero, then there exists a root `x` in the field `L` such that the polynomial `f` evaluates to zero at `x`, i.e., `Polynomial.eval₂ i x f = 0`. In other words, a non-zero degree polynomial that splits over a field will always have at least one root in that field.

If a polynomial of non-zero degree `f` splits over a field `L` via homomorphism `i`, then there exists a root `x` in `L` such that `f(x) = 0`.


theorem Asymptotics.isTheta_const_smul_left :
    ∀ {α : Type u_1} {F : Type u_4} {E' : Type u_6} {𝕜 : Type u_14} [inst : Norm F] [inst_1 : SeminormedAddCommGroup E']
      [inst_2 : NormedField 𝕜] {g : α → F} {f' : α → E'} {l : Filter α} [inst_3 : NormedSpace 𝕜 E'] {c : 𝕜},
      c ≠ 0 → ((fun x => c • f' x) =Θ[l] g ↔ f' =Θ[l] g) :=
  by sorry

This theorem states that, for all types `α`, `F`, `E'`, and `𝕜`, given a norm on `F`, a seminorm on `E'`, a normed field `𝕜`, functions `g : α → F` and `f' : α → E'`, a filter `l` on `α`, and a normed space `𝕜` over `E'`, and a constant `c : 𝕜` such that `c` is not equal to zero, then the function that maps `x` to `c` multiplies `f'(x)` is Big Theta (`=Θ`) of `g` with respect to the filter `l` if and only if `f'` is Big Theta of `g` with respect to `l`. In simpler terms, if you have a function `f'` and you scale it by a non-zero constant `c`, it has the same order of growth as `g` if and only if the original function `f'` has the same order of growth as `g`.

For all types `α`, `F`, `E'`, and normed fields `𝕜`, if `c` is a non-zero constant, `g : α → F`, `f' : α → E'`, and `f' ∝ g` (Big Theta relation) with respect to a filter `l` on `α` holds, then `cf' ∝ g` (Big Theta relation) also holds.


theorem exists_Ioc_subset_of_mem_nhds :
    ∀ {α : Type u} [inst : TopologicalSpace α] [inst_1 : LinearOrder α] [inst_2 : OrderTopology α] {a : α} {s : Set α},
      s ∈ nhds a → (∃ l, l < a) → ∃ l < a, Set.Ioc l a ⊆ s :=
  by sorry

This theorem states that for any type `α` that has a topological space structure, a linear order and an order topology, and for any element `a` of type `α` and a set `s` of type `α`, if `s` is a neighborhood of `a` and there exists an element `l` that is less than `a`, then there exists an element `l` that is less than `a` such that the left-open right-closed interval from `l` to `a` is a subset of `s`. In other words, given a neighborhood around a point in an ordered topological space and an element less than the point, we can always find a left-open right-closed interval that fits within the neighborhood and whose upper limit is the given point.

For any ordered topological space `(α, ≤, τ)` and `a ∈ α` with `s ∈ ν(a)` (the neighborhood filter of `a`), if there exists `l < a` such that `(l, a] ⊆ s`, then there exists such `l` with `(l, a] ∈ τ`.


theorem iteratedDerivWithin_zero :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {F : Type u_2} [inst_1 : NormedAddCommGroup F]
      [inst_2 : NormedSpace 𝕜 F] {f : 𝕜 → F} {s : Set 𝕜}, iteratedDerivWithin 0 f s = f :=
  by sorry

The theorem `iteratedDerivWithin_zero` states that for any given non-trivial normed field `𝕜`, any normed additive commutative group `F`, a normed space structure over `𝕜` and `F`, a function `f` from `𝕜` to `F`, and a set `s` of `𝕜`, the zero-th iterated derivative of the function `f` within the set `s` is just the function `f` itself. In other words, applying the operation of taking the derivative zero times leaves any function unchanged.

For any normed field 𝕜, normed additive commutative group F, normed space structure on F over 𝕜, function f from 𝕜 to F, and set s of 𝕜, the zero-th iterated derivative of f within s equals f.


theorem IsAlgClosed.of_exists_root :
    ∀ (k : Type u) [inst : Field k],
      (∀ (p : Polynomial k), Polynomial.Monic p → Irreducible p → ∃ x, Polynomial.eval x p = 0) → IsAlgClosed k :=
  by sorry

The theorem `IsAlgClosed.of_exists_root` states that for any field `k`, if for all monic, irreducible polynomials `p` over `k` there exists an `x` such that when `x` is plugged into `p`, the result is `0`, then `k` is an algebraically closed field. In more traditional mathematical language, this theorem asserts that a field is algebraically closed if all monic irreducible polynomials over that field have at least one root in the field.

A field is algebraically closed if every monic irreducible polynomial over it has a root in the field.


theorem MeasureTheory.Ioo_ae_eq_Ico' :
    ∀ {α : Type u_1} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} [inst : PartialOrder α] {a b : α},
      ↑↑μ {a} = 0 → Set.Ioo a b =ᶠ[MeasureTheory.Measure.ae μ] Set.Ico a b :=
  by sorry

This theorem states that for any partially ordered type `α`, a given measurable space `m0` over that type, a measure `μ`, and any two elements `a` and `b` of type `α`, if the measure of the singleton set `{a}` is zero, then the left-open right-open interval `(a, b)` is almost everywhere equal to the left-closed right-open interval `[a, b)` with respect to the measure `μ`. "Almost everywhere" means that the set of points where the two intervals differ is a null set under the measure `μ`.

For any partially ordered type `α`, measurable space `m0` over `α`, measure `μ`, and elements `a` and `b` of `α` with `μ({a}) = 0`, the left-open right-open interval `(a, b)` is almost everywhere equal to the left-closed right-open interval `[a, b)` with respect to `μ`.


theorem Set.preimage_mul_const_Iic_of_neg :
    ∀ {α : Type u_1} [inst : LinearOrderedField α] (a : α) {c : α},
      c < 0 → (fun x => x * c) ⁻¹' Set.Iic a = Set.Ici (a / c) :=
  by sorry

This theorem states that for any type `α` that is a linear ordered field and any two elements `a` and `c` of this type, if `c` is less than zero, then the preimage of the set of all elements less than or equal to `a` under the function `x ↦ x * c` (i.e., the set of all `x` such that `x * c` is less than or equal to `a`) is equal to the set of all elements greater than or equal to `a / c`. In other words, multiplying by a negative constant `c` and taking the preimage reverses the direction of the inequality.

For any linear ordered field `α` and elements `a, c` of `α` with `c < 0`, the preimage of the set of `x` with `x * c ≤ a` is equal to the set of `x` with `x ≥ a / c`.


theorem Cardinal.toENat_eq_nat : ∀ {a : Cardinal.{u_1}} {n : ℕ}, Cardinal.toENat a = ↑n ↔ a = ↑n := by sorry

The theorem `Cardinal.toENat_eq_nat` states that for any Cardinal `a` and natural number `n`, the application of the function `Cardinal.toENat` to `a` is equal to the natural number `n` (denoted as `↑n`) if and only if `a` is itself equal to `n`. In other words, the function `Cardinal.toENat` precisely preserves the numerical value when mapping a Cardinal to a natural number, for all finite Cardinals.

For any Cardinal `a` and natural number `n`, `Cardinal.toENat a = ↑n` if and only if `a = n`.


theorem PMF.bind_pure : ∀ {α : Type u_1} (p : PMF α), PMF.bind p PMF.pure = p := by sorry

The theorem `PMF.bind_pure` states that for any probability mass function `p` over a certain type `α`, if we apply the bind operation on `p` with the pure probability mass function, we get back the original probability mass function `p`. In other words, binding any probability mass function with the pure function (which assigns the probability of `1` to a single point and `0` elsewhere) is an identity operation in the context of probability mass functions.

For any probability mass function `p` over type `α`, `bind p (pure ℙ1) = p`, where `pure ℙ1` is the pure probability mass function assigning mass 1 to a single point and 0 elsewhere.


theorem Nat.Partrec.Code.eval_curry :
    ∀ (c : Nat.Partrec.Code) (n x : ℕ),
      Nat.Partrec.Code.eval (Nat.Partrec.Code.curry c n) x = Nat.Partrec.Code.eval c (Nat.pair n x) :=
  by sorry

The theorem `Nat.Partrec.Code.eval_curry` states that for any natural number code `c`, and any natural numbers `n` and `x`, evaluating the result of currying `c` with `n` at `x` is equivalent to evaluating `c` at the pair of `n` and `x`. In other words, the currying operation in the context of `Nat.Partrec.Code` behaves as expected: it binds the first argument of the input code to a specific value and the result is a code that takes one less argument.

For any natural number code `c`, evaluating `c (n, x)` is equivalent to evaluating `(Nat.Partrec.Code.eval_curry c n) x` in `Nat.Partrec.Code`.


theorem Group.rank_le :
    ∀ (G : Type u_3) [inst : Group G] [h : Group.FG G] {S : Finset G},
      Subgroup.closure ↑S = ⊤ → Group.rank G ≤ S.card :=
  by sorry

The theorem `Group.rank_le` states that for any finitely generated group `G`, if the `Subgroup` generated by a finite set `S` of elements in `G` equals the entire group (`⊤`), then the rank of the group `G` (i.e., the minimum number of generators required to generate `G`) is less than or equal to the cardinality of the set `S`.

If a finitely generated group `G` is equal to the subgroup generated by a finite set `S` of elements in `G`, then the rank of `G` is less than or equal to the cardinality of `S`.


theorem add_neg_le_iff_le_add :
    ∀ {α : Type u} [inst : AddGroup α] [inst_1 : LE α]
      [inst_2 : CovariantClass α α (Function.swap fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] {a b c : α},
      a + -b ≤ c ↔ a ≤ c + b :=
  by sorry

The theorem `add_neg_le_iff_le_add` states that for any type `α` that is an add group and has a less than or equal to (`LE`) operation, and is covariant under the operation of swapping the arguments of addition and the less than or equal to operations, the statement "a plus the additive inverse of b is less than or equal to c" is equivalent to the statement "a is less than or equal to c plus b", for all elements `a`, `b`, `c` of type `α`. In other words, for all elements in an additive group, subtracting a value from one side of an inequality is equivalent to adding that value to the other side.

For all elements `a`, `b`, `c` in an additive group with a covariant `LE` operation, `a + (-b) ≤ c` is equivalent to `a ≤ c + b`.


theorem ENNReal.mul_lt_mul_left : ∀ {a b c : ENNReal}, a ≠ 0 → a ≠ ⊤ → (a * b < a * c ↔ b < c) := by sorry

This theorem states that for all extended nonnegative real numbers `a`, `b`, and `c`, if `a` is neither zero nor infinity (`⊤` represents infinity in this context), then `a` multiplied by `b` is less than `a` multiplied by `c` if and only if `b` is less than `c`. In other words, if `a` is a positive, finite extended nonnegative real number, then multiplication by `a` preserves the order of `b` and `c`.

For all extended nonnegative real numbers `a` neither zero nor infinity, `a * b` < `a * c` if and only if `b` < `c`.


theorem dist_dist_dist_le_left :
    ∀ {α : Type u} [inst : PseudoMetricSpace α] (x y z : α), dist (dist x z) (dist y z) ≤ dist x y := by sorry

This theorem states that for any pseudometric space (a set equipped with a function that measures distances between elements of the set) and for any three elements within that space (x, y, and z), the absolute difference between the distance from x to z and the distance from y to z is less than or equal to the distance from x to y.

For any pseudometric space and elements x, y, z in it, |d(x, z) - d(y, z)| ≤ d(x, y), where d is the distance function.


theorem succChain_spec :
    ∀ {α : Type u_1} {r : α → α → Prop} {s : Set α},
      (∃ t, IsChain r s ∧ SuperChain r s t) → SuperChain r s (SuccChain r s) :=
  by sorry

The theorem `succChain_spec` states that for any type `α`, relation `r`, and set `s` of type `α`, if there exists a chain `t` which is both a chain in the relation `r` and a superchain of `s`, then the successor chain of `s` (as computed by `SuccChain`) is also a superchain of `s` in the relation `r`. This implies that the `SuccChain` function correctly finds a superchain whenever one exists.

If a relation `r` on type `α` has a chain `t` that is both a chain in `r` and a superchain of a set `s`, then the successor chain of `s` in `r` (as computed by `SuccChain`) is also a superchain of `s`.


theorem Equiv.Perm.extendDomain_one :
    ∀ {α : Type u} {β : Type v} {p : β → Prop} [inst : DecidablePred p] (f : α ≃ Subtype p),
      Equiv.Perm.extendDomain 1 f = 1 :=
  by sorry

The theorem `Equiv.Perm.extendDomain_one` states that for any types `α` and `β`, a predicate `p` on `β`, and a decidable predicate instance on `p`, if we have an equivalence `f` between `α` and the subtype of `β` that satisfies `p`, then extending the domain of the identity permutation (denoted as `1`) using `f` results in the identity permutation. In other words, the process of extending the domain of the identity permutation using an equivalence does not change the permutation itself.

Given types α and β, a predicate p on β with a decidable instance, and an equivalence f between α and the subtype of β satisfying p, the extension of the identity permutation on α using f remains the identity permutation.


theorem Mathlib.Topology.Basic._auxLemma.20 : ∀ {α : Type u} {s : Set α}, Set.Nonempty s = (s ≠ ∅) := by sorry

This theorem states that for any type `α` and any set `s` of type `α`, the property that `s` is nonempty (i.e., `Set.Nonempty s`) is equivalent to the statement that `s` is not the empty set (i.e., `s ≠ ∅`). This establishes an equivalence between two different ways of expressing the non-emptiness of a set.

The theorem asserts that a set `s` of type `α` is nonempty if and only if it is not equal to the empty set. In Lean notation, `Set.Nonempty s ��nvdash= s ≠ ∅`.


theorem Mathlib.Topology.Basic._auxLemma.19 :
    ∀ {X : Type u} [inst : TopologicalSpace X] (s : Set X), (closure s = ∅) = (s = ∅) := by sorry

This theorem states that for any given set `s` in a topological space `X`, the closure of `s` is empty, denoted as `closure s = ∅`, if and only if `s` itself is empty, expressed as `s = ∅`. In other words, the theorem establishes the equivalence between the condition of `s` being an empty set and its closure also being an empty set in a given topological space.

The closure of an empty set in a topological space is empty if and only if the original set is empty.


theorem Polynomial.eraseLead_coeff_of_ne :
    ∀ {R : Type u_1} [inst : Semiring R] {f : Polynomial R} (i : ℕ),
      i ≠ Polynomial.natDegree f → Polynomial.coeff (Polynomial.eraseLead f) i = Polynomial.coeff f i :=
  by sorry

The theorem `Polynomial.eraseLead_coeff_of_ne` states that for any semiring `R`, any polynomial `f` of type `R`, and any natural number `i`, if `i` is not equal to the degree of the polynomial `f` (in other words, `i ≠ Polynomial.natDegree f`), then the coefficient of the `i`-th term of the polynomial obtained by erasing the leading term of `f` (`Polynomial.eraseLead f`) is equal to the coefficient of the `i`-th term of the original polynomial `f`. In mathematical terms, this could be written as: if $i \neq \deg(f)$, then the coefficient of $x^i$ in $f - \text{lead}(f)$ is same as the coefficient of $x^i$ in $f$. Here, $\text{lead}(f)$ denotes the leading term of $f$.

If the degree of a polynomial `f` in a semiring `R` does not equal `i`, then the coefficient of `x^i` in `Polynomial.eraseLead f` equals the coefficient of `x^i` in `f`.


ContDiffWithinAt.continuousWithinAt

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

This theorem states that for any nontrivially normed field `𝕜` and normed additive commutative groups `E` and `F` that are also normed spaces over the field `𝕜`, given a function `f` from `E` to `F`, a set `s` of `E`, a point `x` in `E`, and a natural number or infinity `n`, if the function `f` is continuously differentiable within the set `s` at the point `x` to the degree `n`, then the function `f` is also continuous at the point `x` within the set `s`. In other words, continuous differentiability within a set at a point implies continuity within the set at that point.

If a continuously differentiable function between two normed spaces is given over a set in a nontrivially normed field, then it is continuous at any point within that set.


theorem Irrational.of_neg : ∀ {x : ℝ}, Irrational (-x) → Irrational x := by sorry

This theorem states that for any real number 'x', if the negation of 'x' (-x) is irrational (meaning that it cannot be expressed as a ratio of two integers), then 'x' itself is also irrational.

If a real number x has an irrational negation, then x is irrational.


theorem AddLECancellable.le_tsub_of_add_le_right :
    ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : AddCommSemigroup α] [inst_2 : Sub α] [inst_3 : OrderedSub α]
      {a b c : α}, AddLECancellable b → a + b ≤ c → a ≤ c - b :=
  by sorry

The theorem `AddLECancellable.le_tsub_of_add_le_right` states that for any type `α` that has the structure of a preorder, an additive commutative semigroup, and an ordered subtraction, given three elements `a`, `b`, and `c` of `α`, if `b` satisfies the `AddLECancellable` property (which means that for all `b` and `c` in `α`, if `b + a` is less than or equal to `c + a` then `b` is less than or equal to `c`), and if the sum of `a` and `b` is less than or equal to `c`, then `a` is less than or equal to the result of subtracting `b` from `c`. In simpler terms, this theorem gives us a way to compare two elements `a` and `c - b` in a preorder where addition and subtraction interact in a specific way, under certain conditions involving `b`.

Given an additive commutative semigroup `α` with an ordered subtraction and an element `b` satisfying `AddLECancellable` property, if `a + b ≤ c` and `b` is less than or equal to `c`, then `a ≤ c - b`.


theorem Ici_mem_nhdsSet_Icc :
    ∀ {α : Type u_1} [inst : LinearOrder α] [inst_1 : TopologicalSpace α] [inst_2 : OrderClosedTopology α] {a b c : α},
      a < b → Set.Ici a ∈ nhdsSet (Set.Icc b c) :=
  by sorry

This theorem states that for any type `α` that has a linear order, a topological space structure, and an order-closed topology, and for any three elements `a`, `b`, and `c` of this type, if `a` is less than `b`, then the left-closed right-infinite interval starting from `a` is an element of the filter of neighborhoods of the left-closed right-closed interval from `b` to `c`. In other words, the set of all elements greater than or equal to `a` is in the vicinity of the set of all elements between `b` and `c` (inclusive) in the given topological structure.

For any type `α` with a linear order, topology, and order-closed topology, if `a < b <= c`, then the filter of neighborhoods of the interval [`b, c`] contains the set `{x : α | x >= a}`.


theorem MeasureTheory.measure_vadd :
    ∀ {G : Type u} {α : Type w} {m : MeasurableSpace α} [inst : AddGroup G] [inst_1 : AddAction G α]
      [inst_2 : MeasurableSpace G] [inst_3 : MeasurableVAdd G α] (c : G) (μ : MeasureTheory.Measure α)
      [inst_4 : MeasureTheory.VAddInvariantMeasure G α μ] (s : Set α), ↑↑μ (c +ᵥ s) = ↑↑μ s :=
  by sorry

This theorem, `MeasureTheory.measure_vadd`, states that for any given type `G`, type `α`, a measure space `m` of type `α`, an additive group structure on `G`, an action of the group `G` on the set `α`, a measurable space structure on `G`, a `MeasurableVAdd` structure which means that the action of `G` on `α` is measurable, a constant `c` of type `G`, a measure `μ` from the `MeasureTheory`, and the `VAddInvariantMeasure` structure which means that the measure `μ` is invariant under the action of `G`, then for any set `s` of type `α`, the measure of the set obtained by adding `c` to every element in `s` is the same as the measure of the set `s` itself. In the language of mathematics, this can be written as: if $G$ is a group acting on a set $α$ and $μ$ is a $G$-invariant measure on $α$, then for any $c∈G$ and any measurable set $s⊂α$, we have $μ(c + s) = μ(s)$.

Given a group action on a measure space with a $G$-invariant measure, for any measurable set and constant in the group, the measure of the set translated by the constant is equal to the measure of the original set.


theorem Irreducible.dvd_iff :
    ∀ {α : Type u_1} [inst : Monoid α] {x y : α}, Irreducible x → (y ∣ x ↔ IsUnit y ∨ Associated x y) := by sorry

The theorem `Irreducible.dvd_iff` states that for any type `α` that forms a `Monoid`, and any two elements `x` and `y` from `α`, if `x` is irreducible, then `y` divides `x` if and only if `y` is a unit, or `x` is associated with `y`. Here, `y` being a unit means that there exists an element which when multiplied with `y` gives the identity of the monoid. `x` is associated with `y` means that `x` can be represented as `y` multiplied by a unit.

For any monoid `α` and irreducible elements `x` and `y` in `α`, `y` divides `x` if and only if `y` is a unit or `x` is associates with `y`.


theorem EReal.nhds_top_basis : Filter.HasBasis (nhds ⊤) (fun x => True) fun x => Set.Ioi ↑x := by sorry

This theorem states that the neighborhood filter at positive infinity (`nhds ⊤`) in the extended real numbers (`EReal`) has a basis where each basis element is an interval of the form `(x, ∞)`, where `x` is a real number. In other words, every neighborhood of positive infinity can be generated by taking unions of sets that are open intervals extending to positive infinity from some real number.

The neighborhood filter at positive infinity in the extended real numbers has a basis consisting of intervals of the form (x, ∞), where x is a real number.


theorem Set.Ici_diff_Ioi_same : ∀ {α : Type u_1} [inst : PartialOrder α] {a : α}, Set.Ici a \ Set.Ioi a = {a} := by
  sorry

This theorem states that for any type `α` which has a partial order, the set difference between the left-closed right-infinite interval starting from a particular value `a` and the left-open right-infinite interval starting from the same value `a`, is the singleton set containing only `a`. In mathematical terms, it's saying that if you remove from the set of all elements greater than or equal to `a` those strictly greater than `a`, you're left with the set containing only `a`.

For any type `α` with a partial order, the left-closed right-infinite interval and the left-open right-infinite interval starting from `a` differ by a singleton set containing only `a`.


theorem Monotone.map_iInf_le :
    ∀ {α : Type u_1} {β : Type u_2} {ι : Sort u_5} [inst : CompleteLattice α] {s : ι → α} [inst_1 : CompleteLattice β]
      {f : α → β}, Monotone f → f (iInf s) ≤ ⨅ i, f (s i) :=
  by sorry

The theorem `Monotone.map_iInf_le` states that for any types `α`, `β`, and `ι`, given that `α` and `β` are complete lattices, a function `f` from `α` to `β`, and `s` as a function from `ι` to `α`, if the function `f` is monotone (i.e., if `a ≤ b` then `f(a) ≤ f(b)`), then the value of `f` at the infimum (greatest lower bound) of the set `s` is less than or equal to the infimum of the set obtained by applying `f` to each element of `s`. In mathematical notation it is written as `f(inf s) ≤ inf {f(s(i)) | i in ι}`.

If `α` and `β` are complete lattices, `f` is a monotone function from `α` to `β`, and `s` maps `ι` to `α`, then `f(∧ x in ι. s x) ≤ ∧ i in ι. f(s i)`.


theorem Mathlib.Order.Filter.Ker._auxLemma.1 :
    ∀ {α : Type u_2} {f : Filter α} {a : α}, (a ∈ Filter.ker f) = ∀ s ∈ f, a ∈ s := by sorry

This theorem states that for any type `α`, any filter `f` on `α`, and any element `a` of `α`, `a` is in the kernel of `f` if and only if `a` is in every set `s` in `f`. In other words, an element belongs to the kernel of a filter precisely when it belongs to every set that the filter contains.

An element belongs to the kernel of a filter if and only if it is an element of every set in the filter.


theorem Rat.cast_abs : ∀ {K : Type u_5} [inst : LinearOrderedField K] {q : ℚ}, ↑|q| = |↑q| := by sorry

This theorem states that for any rational number `q` and any linear ordered field `K`, the absolute value of `q` after being cast to `K` is the same as the absolute value of `q` itself cast to `K`. In other words, the operation of taking the absolute value commutes with the operation of casting from the rationals to another field. This can be written in mathematical notation as `|cast(q)| = cast(|q|)`.

For any rational number q and linear ordered field K, the absolute value of q after being cast to K equals the absolute value of q itself when cast to K, that is, |cast(q)| = cast(|q|).


theorem solvable_of_solvable_injective :
    ∀ {G : Type u_1} {G' : Type u_2} [inst : Group G] [inst_1 : Group G'] {f : G →* G'},
      Function.Injective ⇑f → ∀ [inst_2 : IsSolvable G'], IsSolvable G :=
  by sorry

The theorem `solvable_of_solvable_injective` states that for any two types `G` and `G'` that have a group structure, if there is an injective group homomorphism `f` from `G` to `G'`, and if the group `G'` is solvable, then the group `G` is also solvable. This theorem is essentially saying that the solvability of a group is preserved under injective homomorphisms.

If `f` is an injective group homomorphism from the solvable group `G` to `G'`, then `G` is also a solvable group.


theorem Pi.single_injective :
    ∀ {I : Type u} (f : I → Type v₁) [inst : DecidableEq I] [inst_1 : (i : I) → Zero (f i)] (i : I),
      Function.Injective (Pi.single i) :=
  by sorry

This theorem states that for any type `I`, any type-valued function `f` on `I`, any element `i` of `I`, and given that the elements of `f(i)` have a zero and that `I` has decidable equality, then the function `Pi.single i`, which creates a function from `I` to `f(j)` that is zero everywhere except at `i`, where it has a specified value, is injective. In other words, if `Pi.single i x = Pi.single i y` then `x = y`. Injective refers to the property that different inputs will produce different outputs, so no two different values `x` and `y` from `f(i)` can produce the same function when applied to `Pi.single i`.

For any type `I`, function `f` on `I` with decidable equality, and `i` in `I` such that `f(i)` has a zero, the function `Pi.single i : I -> f i` is an injective function.


IsSubmonoid.image

/-- The image of a submonoid under a monoid hom is a submonoid of the codomain.  -/
theorem IsSubmonoid.image :
    ∀ {M : Type u_1} [inst : Monoid M] {γ : Type u_3} [inst_1 : Monoid γ] {f : M → γ},
      IsMonoidHom f → ∀ {s : Set M}, IsSubmonoid s → IsSubmonoid (f '' s) :=
  by sorry

The theorem `IsSubmonoid.image` states that for any given types `M` and `γ`, where `M` and `γ` are monoids, and for any function `f` from `M` to `γ` which is a monoid homomorphism, for any subset `s` of `M` that is a submonoid, the image of `s` under `f` is a submonoid of `γ`. In simpler terms, the image of a submonoid under a monoid homomorphism is also a submonoid.

If `f` is a monoid homomorphism from monoid `M` to monoid `γ`, and `s` is a submonoid of `M`, then `f(s)` is a submonoid of `γ`.


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

The theorem `Polynomial.leadingCoeff_X_pow` states that for any semiring `R` and any natural number `n`, the leading coefficient of the polynomial `X` raised to the power `n` is `1`. Here, `X` is the polynomial variable, and the leading coefficient of a polynomial is the coefficient of the term with the highest degree. Hence, regardless of the power `n`, the leading coefficient is always `1` for `X^n`.

For any semiring R, the leading coefficient of the polynomial X raised to the power n is 1.


theorem Zsqrtd.nonneg_cases :
    ∀ {d : ℕ} {a : ℤ√↑d},
      Zsqrtd.Nonneg a → ∃ x y, a = { re := ↑x, im := ↑y } ∨ a = { re := ↑x, im := -↑y } ∨ a = { re := -↑x, im := ↑y } :=
  by sorry

The theorem `Zsqrtd.nonneg_cases` states that for any natural number `d` and an element `a` of the quadratic integer ring `ℤ√↑d` which is nonnegative (as defined by `Zsqrtd.Nonneg`), there exist integers `x` and `y` such that `a` is equal to `x + yi`, `x - yi`, or `-x + yi`. That is, any nonnegative element of the quadratic integer ring can be expressed in one of these three forms.

For any nonnegative element `a` in the quadratic integer ring `ℤ√↑d`, there exist integers `x` and `y` such that `a` can be expressed as `x + yi`, `x - yi`, or `-x + yi`.


theorem Directed.exists_mem_subset_of_finset_subset_biUnion :
    ∀ {α : Type u_1} {ι : Type u_2} [inst : Nonempty ι] {f : ι → Set α},
      Directed (fun x x_1 => x ⊆ x_1) f → ∀ {s : Finset α}, ↑s ⊆ ⋃ i, f i → ∃ i, ↑s ⊆ f i :=
  by sorry

The theorem `Directed.exists_mem_subset_of_finset_subset_biUnion` states that for any type `α` and `ι` where `ι` is nonempty, given a directed family of sets `f : ι → Set α` directed with respect to the subset (`⊆`) relation, if a set `s` of finite elements of `α` is a subset of the union of all sets in the family, then there exists a member set `i` in the family such that `s` is a subset of `i`. This theorem essentially provides a guarantee that a subset of the union of a directed family of sets is actually a subset of some specific member in that family.

Given a nonempty indexed family of sets `f : ι → Set α` directed with respect to subset relation, if a finite set `s` is a subset of the union of all sets in the family, then there exists `i ∈ ι` such that `s` is a subset of `f i`.


theorem Mathlib.Order.MinMax._auxLemma.7 :
    ∀ {α : Type u} [inst : LinearOrder α] {a b c : α}, (min a b < c) = (a < c ∨ b < c) := by sorry

This theorem, called `Mathlib.Order.MinMax._auxLemma.7`, states that for any type `α` under a linear order, and any three values `a`, `b`, and `c` of type `α`, the condition that the minimum of `a` and `b` is less than `c` holds true if and only if either `a` is less than `c` or `b` is less than `c`. This is a fundamental property of minimum values in any ordered set.

For any type under a linear order, the minimum of two elements is less than a third element if and only if one of the first two elements is less than the third.


/-- If an element `b` becomes add-right-regular after adding to it on the right
an add-right-regular element, then `b` is add-right-regular. -/
theorem IsAddRightRegular.of_add :
    ∀ {R : Type u_1} [inst : AddSemigroup R] {a b : R}, IsAddRightRegular (b + a) → IsAddRightRegular b := by sorry

This theorem states that for any type `R` that is an additive semigroup, if an element `b` of `R` becomes "add-right-regular" after adding an "add-right-regular" element `a` to it on the right, then `b` itself is "add-right-regular". Here, an "add-right-regular" element `c` in `R` is defined as an element such that the function which adds `c` to any element on its right is injective, i.e., for any two different elements `x` and `y` in `R`, `x + c` differs from `y + c`.

If `b` becomes add-right-regular after adding an add-right-regular element `a` to it in an additive semigroup `R`, then `b` is add-right-regular.


theorem MulChar.equivToUnitHom_symm_coe :
    ∀ {R : Type u} [inst : CommMonoid R] {R' : Type v} [inst_1 : CommMonoidWithZero R'] (f : Rˣ →* R'ˣ) (a : Rˣ),
      (MulChar.equivToUnitHom.symm f) ↑a = ↑(f a) :=
  by sorry

This theorem states that for all commutative monoids `R` and `R'` (where `R'` has a zero element), and for all homomorphisms `f` from the units of `R` to the units of `R'`, and any unit `a` of `R`, if we apply the inverse of the equivalence `MulChar.equivToUnitHom` to `f` and then apply the result to the coercion of `a` (which implicitly converts `a` from a unit to a general element of `R`), it is equivalent to applying `f` to `a` and then coercing the result to a general element of `R'`. This theorem essentially states that the equivalence `MulChar.equivToUnitHom` preserves the behavior of the homomorphism `f` and its interaction with the coercion operation.

For all commutative monoids `R` and `R'`, homomorphisms `f` from the units of `R` to the units of `R'`, and units `a` of `R`, the application of `f.to_fun` followed by coercion from `R` to `R'` is equal to the application of `f` to `a` and coercion from `R` to `R'`. (Here, `f.to_fun` denotes the function component of the homomorphism `f`.)


theorem isNoetherianRing_of_ringEquiv :
    ∀ (R : Type u_1) [inst : Ring R] {S : Type u_2} [inst_1 : Ring S],
      R ≃+* S → ∀ [inst : IsNoetherianRing R], IsNoetherianRing S :=
  by sorry

The theorem `isNoetherianRing_of_ringEquiv` states that for any two types `R` and `S` that have a ring structure, if `R` is a Noetherian ring and there exists a ring isomorphism between `R` and `S`, then `S` is also a Noetherian ring. In other words, the property of being a Noetherian ring is preserved under a ring isomorphism. In mathematical terms, if $R$ is a Noetherian ring and there exists an isomorphism of rings between $R$ and $S$, then $S$ is also a Noetherian ring.

If `R` is a Noetherian ring and there exists a ring isomorphism between `R` and `S`, then `S` is also a Noetherian ring. (Mathematically: If $R$ is a Noetherian ring and there exists a ring isomorphism between $R$ and $S$, then $S$ is also a Noetherian ring.)


theorem Mathlib.Combinatorics.SimpleGraph.Prod._auxLemma.3 : ∀ {α : Sort u_1} {a b : α}, (a = b) = (b = a) := by sorry

This theorem states that for any type `α` and any two elements `a` and `b` of that type, the proposition that `a` is equal to `b` is the same as the proposition that `b` is equal to `a`. In other words, equality is symmetric: if `a` equals `b`, then `b` equals `a`, for all `a` and `b` of any type `α`.

For all types `α` and elements `a` and `b` of type `α`, the proposition `a = b` is equivalent to the proposition `b = a`.


theorem Mathlib.Combinatorics.SimpleGraph.Prod._auxLemma.1 : ∀ {a b : Prop}, (a ∧ b) = (b ∧ a) := by sorry

This theorem states that, for all propositions 'a' and 'b', the conjunction of 'a' and 'b' is equivalent to the conjunction of 'b' and 'a'. In other words, the order of the propositions in a logical "and" operation does not matter: 'a' and 'b' is the same as 'b' and 'a'. This is a demonstration of the commutative property in logic.

The theorem asserts the commutativity of conjunction, that is, for all propositions 'a' and 'b', 'a' and 'b' is equivalent to 'b' and 'a'.


/-- An additive character maps `0` to `1`.  -/
theorem AddChar.map_zero_one :
    ∀ {A : Type u_1} {M : Type u_2} [inst : AddMonoid A] [inst_1 : Monoid M] (ψ : AddChar A M), ψ 0 = 1 := by sorry

This theorem states that for any additive character `ψ` from a type `A` which is an additive monoid, to a type `M` which is a monoid, the value of `ψ` at `0` is `1`. In other words, an additive character always maps the additive identity (which is `0` in this context) to the multiplicative identity (which is `1`).

For any additive character ψ from an additive monoid A to a monoid M, ψ(0) = 1.


ConvexOn.add

theorem ConvexOn.add :
    ∀ {𝕜 : Type u_1} {E : Type u_2} {β : Type u_5} [inst : OrderedSemiring 𝕜] [inst_1 : AddCommMonoid E]
      [inst_2 : OrderedAddCommMonoid β] [inst_3 : SMul 𝕜 E] [inst_4 : DistribMulAction 𝕜 β] {s : Set E} {f g : E → β},
      ConvexOn 𝕜 s f → ConvexOn 𝕜 s g → ConvexOn 𝕜 s (f + g) :=
  by sorry

The theorem `ConvexOn.add` states that for any type `𝕜` with an ordered semiring structure, another type `E` with an addition commutative monoid structure, and a third type `β` with an ordered addition commutative monoid structure, if `𝕜` and `β` have scalar multiplication and `𝕜` and `β` have a distributive multiplication action, then given a set `s` of elements of type `E` and two functions `f` and `g` from `E` to `β`, if both `f` and `g` are convex on `s`, then their pointwise sum `(f + g)` is also convex on `s`.

In other words, the sum of two convex functions on a given set is also a convex function on that set.

If `𝕜` is an ordered semiring, `E` is an additive commutative monoid, and `β` is an ordered additive commutative monoid with distributive multiplication actions of `𝕜` over both `E` and `β`, then the pointwise sum of two convex functions from `E` to `β` is convex.


theorem Multiset.lcm_dvd :
    ∀ {α : Type u_1} [inst : CancelCommMonoidWithZero α] [inst_1 : NormalizedGCDMonoid α] {s : Multiset α} {a : α},
      Multiset.lcm s ∣ a ↔ ∀ b ∈ s, b ∣ a :=
  by sorry

This theorem states that for any type `α` that is a Cancel Commutative Monoid with Zero and a Normalized GCD Monoid, and for any multiset `s` of type `α` and any element `a` of type `α`, the least common multiple (lcm) of the multiset `s` divides `a` if and only if every element `b` in the multiset `s` divides `a`. In brief, the lcm of a multiset is a common multiple that divides another number precisely when every element in the multiset divides that number.

For any cancel commutative monoid with zero and normalized GCD `α`, the least common multiple of a multiset `s` in `α` divides every element `a` in `s` if and only if it divides `a`.


theorem FirstOrder.Language.ElementarilyEquivalent.theory_model_iff :
    ∀ {L : FirstOrder.Language} {M : Type w} {N : Type u_1} [inst : FirstOrder.Language.Structure L M]
      [inst_1 : FirstOrder.Language.Structure L N] {T : FirstOrder.Language.Theory L},
      FirstOrder.Language.ElementarilyEquivalent L M N → (M ⊨ T ↔ N ⊨ T) :=
  by sorry

This theorem states that for any first-order language `L`, any two types `M` and `N`, and any theory `T` of `L` (where `M` and `N` are both structures of `L`), if `M` and `N` are elementarily equivalent in `L` (meaning they satisfy the same sentences of `L`), then `M` is a model of `T` if and only if `N` is a model of `T`. In other words, if two structures are elementarily equivalent, then any theory that one structure satisfies is also satisfied by the other structure.

If two first-order structures `M` and `N` of a language `L` are elementarily equivalent, then `M` is a model of theory `T` in `L` if and only if `N` is a model of `T`.


theorem biSup_prod :
    ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_4} [inst : CompleteLattice α] {f : β × γ → α} {s : Set β} {t : Set γ},
      ⨆ x ∈ s ×ˢ t, f x = ⨆ a ∈ s, ⨆ b ∈ t, f (a, b) :=
  by sorry

The theorem `biSup_prod` states that for any types `α`, `β`, and `γ`, where `α` is a complete lattice, and for any function `f` from the product of `β` and `γ` to `α`, and for any sets `s` of `β` and `t` of `γ`, the supremum (⨆, also known as the least upper bound or join) of `f` over the cartesian product of the sets `s` and `t` is equal to the supremum of the supremums of `f` applied to pairs `(a, b)` where `a` is an element of `s` and `b` is an element of `t`. This theorem demonstrates a property of supremums over product sets in the context of complete lattices.

For any complete lattice α, function f from the product of sets β × γ to α, and sets s ⊆ β and t ⊆ γ, the supremum of f over s × t equals the supremum of the supremums of f over pairs (a, b) with a ∈ s and b ∈ t.


theorem CategoryTheory.Limits.imageSubobjectMap_arrow :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {W X Y Z : C} {f : W ⟶ X}
      [inst_1 : CategoryTheory.Limits.HasImage f] {g : Y ⟶ Z} [inst_2 : CategoryTheory.Limits.HasImage g]
      (sq : CategoryTheory.Arrow.mk f ⟶ CategoryTheory.Arrow.mk g) [inst_3 : CategoryTheory.Limits.HasImageMap sq],
      CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.imageSubobjectMap sq)
          (CategoryTheory.Subobject.arrow (CategoryTheory.Limits.imageSubobject g)) =
        CategoryTheory.CategoryStruct.comp (CategoryTheory.Subobject.arrow (CategoryTheory.Limits.imageSubobject f))
          sq.right :=
  by sorry

The theorem `CategoryTheory.Limits.imageSubobjectMap_arrow` states that, in any category `C` with morphisms `f: W ⟶ X` and `g: Y ⟶ Z` that have images, and a commutative square `sq` from the arrow of `f` to the arrow of `g`, the composition of the imageSubobjectMap of `sq` with the arrow of the image subobject of `g` is equal to the composition of the arrow of the image subobject of `f` with the right object of `sq`. This theorem is a fundamental result in category theory pertaining to the interaction between morphisms, their images, and subobjects, and it illustrates the alignment of structures preserved under the processes of image formation and morphism composition.

In any category with commutative squares and morphisms with images, the image of the subobject of the composite morphism under the left morphism is equal to the composition of the image of the subobject of the left morphism and the right object of the square.


theorem isPreconnected_Ico :
    ∀ {α : Type u} [inst : ConditionallyCompleteLinearOrder α] [inst_1 : TopologicalSpace α] [inst_2 : OrderTopology α]
      [inst_3 : DenselyOrdered α] {a b : α}, IsPreconnected (Set.Ico a b) :=
  by sorry

This theorem states that for any type `α` which has a conditionally complete linear order, a topological space structure, an order topology and is densely ordered, the left-closed right-open interval from `a` to `b`, denoted as `Set.Ico a b`, is preconnected. In mathematical terms, it means that there is no non-trivial open partition for this interval. That is, for any open sets `u` and `v`, if the interval is a subset of the union of `u` and `v`, and there are points in the interval that belong to both `u` and `v`, then there must exist a point in the interval that belongs to the intersection of `u` and `v`.

For any densely ordered type `α` with a conditionally complete linear order, topology, and order topology, the left-closed right-open interval `Set.Ico a b` is preconnected, meaning there is no open partition with no point in their intersection if the interval is a subset of their union and contains common points.


theorem FirstOrder.Language.Formula.realize_equivSentence_symm_con :
    ∀ {L : FirstOrder.Language} (M : Type w) [inst : FirstOrder.Language.Structure L M] {α : Type u'}
      [inst_1 : FirstOrder.Language.Structure (FirstOrder.Language.withConstants L α) M]
      [inst_2 : FirstOrder.Language.LHom.IsExpansionOn (FirstOrder.Language.lhomWithConstants L α) M]
      (φ : FirstOrder.Language.Sentence (FirstOrder.Language.withConstants L α)),
      (FirstOrder.Language.Formula.Realize (FirstOrder.Language.Formula.equivSentence.symm φ) fun a =>
          ↑(FirstOrder.Language.con L a)) ↔
        M ⊨ φ :=
  by sorry

This theorem states that for any first-order language `L`, a type `M`, and a type `{α : Type u'}`, given the structures `inst : FirstOrder.Language.Structure L M`, `inst_1 : FirstOrder.Language.Structure (FirstOrder.Language.withConstants L α) M`, and a condition `inst_2 : FirstOrder.Language.LHom.IsExpansionOn (FirstOrder.Language.lhomWithConstants L α) M` that the language homomorphism with constants is an expansion on `M`, any sentence `φ` of the language with constants can be realized as a formula (by the inverse function of the bijection `FirstOrder.Language.Formula.equivSentence`) such that the assignment of constants to the formula corresponds to the constant symbols indexed by elements of the parameter set `α`. The theorem further claims that this realization is equivalent to the model `M` satisfying the sentence `φ`. That is, when the variables in the formula are replaced with their corresponding constants from `M`, the formula evaluates to `true` if and only if `M` satisfies `φ`.

For any first-order language L, type M, and constant type α, given that the language homomorphism with constants is an expansion on M, any sentence φ of the language with constants can be realized as an equivalent formula in which the constants correspond to elements of α, and this formula holds in M if and only if M satisfies φ.


/-- If the distance between consecutive points of a sequence is estimated by a summable series,
then the original sequence is a Cauchy sequence.  -/
theorem cauchySeq_of_dist_le_of_summable :
    ∀ {α : Type u_1} [inst : PseudoMetricSpace α] {f : ℕ → α} (d : ℕ → ℝ),
      (∀ (n : ℕ), dist (f n) (f (Nat.succ n)) ≤ d n) → Summable d → CauchySeq f :=
  by sorry

This theorem states that given a sequence `f` of elements of a pseudometric space and a sequence `d` of real numbers, if the distance between each consecutive pair of points in the sequence `f` is less than or equal to the corresponding term in the sequence `d`, and the sequence `d` is summable (i.e., the sum of its terms converges to a finite value), then the sequence `f` is a Cauchy sequence.

In other words, if we can bound the distances between consecutive points of a sequence by a series that sums to a finite value, then the sequence itself exhibits the Cauchy property, which means it converges in its space. A sequence is Cauchy if, intuitively, elements become arbitrarily close to each other as we progress through the sequence.

Given a sequence `f` in a pseudometric space and a summable sequence `d` of distances between consecutive terms in `f`, if every distance is less than or equal to the corresponding term in `d`, then `f` is a Cauchy sequence.


theorem Mathlib.Combinatorics.SimpleGraph.Basic._auxLemma.42 :
    ∀ {α : Type u} (x : α) (a b : Set α), (x ∈ a ∩ b) = (x ∈ a ∧ x ∈ b) := by sorry

This theorem, `Mathlib.Combinatorics.SimpleGraph.Basic._auxLemma.42`, is a statement about sets in any type `α`. Given any element `x` of type `α` and any two sets `a` and `b` of type `α`, it states that `x` is an element of the intersection of `a` and `b` if and only if `x` is an element of `a` and `x` is an element of `b`. In other words, the membership of an element in the intersection of two sets is equivalent to the membership of that element in both sets.

For any type `α` and sets `a` and `b` in `α`, the element `x` belongs to the intersection `a ∩ b` if and only if `x` belongs to both `a` and `b` (i.e., `x ∈ a` and `x ∈ b`).


theorem IsAdjoinRoot.algebraMap_apply :
    ∀ {R : Type u} {S : Type v} [inst : CommRing R] [inst_1 : Ring S] {f : Polynomial R} [inst_2 : Algebra R S]
      (h : IsAdjoinRoot S f) (x : R), (algebraMap R S) x = h.map (Polynomial.C x) :=
  by sorry

The theorem `IsAdjoinRoot.algebraMap_apply` states that for any commutative ring `R`, ring `S`, polynomial `f` of `R`, and element `x` of `R`, and given that `S` is an algebra over `R` where `S` adjoins a root of `f`, the application of the algebra map from `R` to `S` on `x` is equivalent to the mapping of the constant polynomial of `x` under `h`, where `h` is the function representing the root of `f` adjoined to `S`. In mathematical terms, it means that the algebra map of `x` coincides with applying the root-adjoining map `h` to the constant polynomial of `x`.

For any commutative rings R and S, polynomial f of R, and element x of R, if S is an algebra over R extending the roots of f, then the algebra map of x from R to S equals the application of the root of f adjoined to S to the constant polynomial of x.


theorem measurable_iff_comap_le :
    ∀ {α : Type u_1} {β : Type u_2} {m₁ : MeasurableSpace α} {m₂ : MeasurableSpace β} {f : α → β},
      Measurable f ↔ MeasurableSpace.comap f m₂ ≤ m₁ :=
  by sorry

This theorem states that for any two types `α` and `β`, along with measurable spaces `m₁` and `m₂` defined over `α` and `β` respectively, and a function `f` from `α` to `β`, the function `f` is measurable if and only if the reverse image of the measurable space under `f` is a subset of `m₁`. In other words, a function between two measurable spaces is measurable if the preimage of every measurable set in the codomain space (as per `m₂`) is a measurable set in the domain space (as per `m₁`). This formalizes the connection between the measurability of a function and the structure of the measurable spaces it maps between.

A function between two measurable spaces is measurable if and only if the preimage of every measurable set in the codomain space is measurable in the domain space.


theorem ZMod.prime_ne_zero : ∀ (p q : ℕ) [hp : Fact (Nat.Prime p)] [hq : Fact (Nat.Prime q)], p ≠ q → ↑q ≠ 0 := by sorry

The theorem `ZMod.prime_ne_zero` states that for any two natural numbers `p` and `q`, if `p` and `q` are both prime numbers, then if `p` is not equal to `q`, the modular inverse of `q` is not zero. In other words, if two natural numbers are distinct primes, then the modular inverse of one cannot be zero.

If two natural numbers `p` and `q` are distinct prime numbers, then there is no modular inverse `x` such that `q` mod `p` = `x` \* `p`.


theorem Mathlib.Combinatorics.SimpleGraph.Basic._auxLemma.18 : ∀ {V : Type u} (v w : V), ⊥.Adj v w = False := by sorry

This theorem, `Mathlib.Combinatorics.SimpleGraph.Basic._auxLemma.18`, states that for any given type `V` and any two instances `v` and `w` of that type, it is not possible for `v` and `w` to be adjacent in the bottom (least) simple graph. In other words, there are no adjacent vertices in the empty simple graph.

In the empty simple graph, there are no adjacent vertices.


theorem AddOpposite.addSemiconjBy_op :
    ∀ {α : Type u} [inst : Add α] {a x y : α},
      AddSemiconjBy (AddOpposite.op a) (AddOpposite.op y) (AddOpposite.op x) ↔ AddSemiconjBy a x y :=
  by sorry

The theorem `AddOpposite.addSemiconjBy_op` states that for any type `α` equipped with addition (`Add α`), and for any elements `a`, `x`, and `y` of `α`, the element `a` is additive semiconjugate to `x` by `y` if and only if the additive opposite of `a` is additive semiconjugate to the additive opposite of `x` by the additive opposite of `y`. In mathematical terms, `a + x = y + a` if and only if `-a + -x = -y + -a`.

For all types `α` with addition and elements `a`, `x`, `y` in `α`, `a` is additive semiconjugate to `x` by `y` if and only if the additive opposite of `a` is additive semiconjugate to the additive opposite of `x` by the additive opposite of `y`. In symbols, `a + x = y + a` if and only if `-a + -x = -y + -a`.


theorem intervalIntegral.integral_zero :
    ∀ {E : Type u_3} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {a b : ℝ} {μ : MeasureTheory.Measure ℝ},
      ∫ (x : ℝ) in a..b, 0 ∂μ = 0 :=
  by sorry

This theorem states that for any real numbers `a` and `b`, and for any measure `μ`, the definite integral of the function which is identically zero over the interval from `a` to `b` is zero. This is valid regardless of the specific nature of the normed add commutative group `E` and the normed space `E` over the real numbers.

For any real numbers `a` and `b`, and for any measure `μ`, the definite integral of the zero function over the interval [`a`, `b`] is zero.


theorem SimpleGraph.chromaticNumber_le_iff_colorable :
    ∀ {V : Type u} {G : SimpleGraph V} {n : ℕ}, SimpleGraph.chromaticNumber G ≤ ↑n ↔ SimpleGraph.Colorable G n := by
  sorry

The theorem `SimpleGraph.chromaticNumber_le_iff_colorable` states that for any graph `G` of type `SimpleGraph V` and for any natural number `n`, the chromatic number of `G` is less than or equal to `n` if and only if `G` can be colored with at most `n` colors. Here, the chromatic number of a graph is the minimum number of colors needed to color that graph, and a graph is considered colorable with at most `n` colors if there exists a coloring of the graph using `n` or fewer colors.

The chromatic number of a simple graph `G` equals or is less than a natural number `n` if and only if `G` is colorable using at most `n` colors.


theorem SzemerediRegularity.card_eq_of_mem_parts_chunk :
    ∀ {α : Type u_1} [inst : Fintype α] {P : Finpartition Finset.univ} {hP : Finpartition.IsEquipartition P}
      {G : SimpleGraph α} {ε : ℝ} {U : Finset α} {hU : U ∈ P.parts} {s : Finset α},
      s ∈ (SzemerediRegularity.chunk hP G ε hU).parts →
        s.card = Fintype.card α / SzemerediRegularity.stepBound P.parts.card ∨
          s.card = Fintype.card α / SzemerediRegularity.stepBound P.parts.card + 1 :=
  by sorry

This theorem, "SzemerediRegularity.card_eq_of_mem_parts_chunk", asserts that for any type 'α' with finite elements (indicated by the instance 'Fintype α'), given an equipartition 'P' of the set of all elements of type 'α', a simple graph 'G' on 'α', a real number 'ε', a subset 'U' that is an element of the parts of 'P', and another subset 's', if 's' is an element of the parts of the chunk of the regularity lemma applied to 'P', 'G', 'ε', and 'U', then the number of elements in 's' is either the total number of elements in 'α' divided by the step bound of the number of parts in 'P' or this value plus one.

In other words, each part of the chunk created by Szemeredi's Regularity Lemma will have a size that's equal to the size of the universal set divided by a certain bound (obtained from the original partition's size), or that value incremented by one, thereby ensuring a level of uniformity or "equitable" distribution in the size of the chunks.

Given an equipartition P of a finite set α, a simple graph G on α, real number ε, and a subset U of α belonging to a chunk of Szemeredi's Regularity Lemma applied to P, G, and ε, the size of subset s in the chunk containing U satisfies |s| = |α| / bound(P) or |α| / bound(P) + 1.


/-- Eta rule for structured arrows. Prefer `StructuredArrow.eta` for rewriting, since equality of
objects tends to cause problems.  -/
theorem CategoryTheory.StructuredArrow.eq_mk :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂}
      [inst_1 : CategoryTheory.Category.{v₂, u₂} D] {S : D} {T : CategoryTheory.Functor C D}
      (f : CategoryTheory.StructuredArrow S T), f = CategoryTheory.StructuredArrow.mk f.hom :=
  by sorry

This theorem, referred to as the Eta rule for structured arrows, states that for any structured arrow `f` in the context of two categories `C` and `D` where `S` is an object in `D` and `T` is a functor from `C` to `D`, `f` is equal to the structured arrow constructed using the morphism `f.hom` from `S` to the functor application `T.obj Y`. In other words, a structured arrow is completely determined by its underlying morphism. For rewriting, it is recommended to use `StructuredArrow.eta` instead, as equality of objects can introduce complications.

For any structured arrow `f` from object `X` in category `C` to object `Y` in category `D`, where `T` is a functor from `C` to `D`, the structured arrow `f` is equal to the structured arrow constructed using `f.hom` and `T.obj Y`.


theorem Set.projIic_of_mem :
    ∀ {α : Type u_1} [inst : LinearOrder α] {b x : α} (hx : x ∈ Set.Iic b),
      Set.projIic b x = { val := x, property := hx } :=
  by sorry

This theorem states that for any type `α` equipped with a linear order, and for any elements `b` and `x` of type `α` where `x` belongs to the set `Set.Iic b` (which represents the left-infinite right-closed interval `(-∞, b]`), the projection of `x` onto the interval `(-∞, b]` using the `Set.projIic` function yields `x` itself. In other words, if `x` is already in the interval `(-∞, b]`, its projection onto this interval does not change its value.

For any type `α` with a linear order, and any `b` in `α` and `x` in the interval `(-∞, b]`, the projection of `x` onto `(-∞, b]` using `Set.projIic` equals `x`.


List.Sublist.filter

theorem List.Sublist.filter :
    ∀ {α : Type u_1} (p : α → Bool) {l₁ l₂ : List α},
      List.Sublist l₁ l₂ → List.Sublist (List.filter p l₁) (List.filter p l₂) :=
  by sorry

This theorem states that for any type `α`, any boolean function `p`, and any two lists `l₁` and `l₂` of type `α`, if `l₁` is a sublist of `l₂`, then the list obtained by filtering `l₁` using `p` is also a sublist of the list obtained by filtering `l₂` using `p`. In simpler terms, if one list is inside another, applying the same filter to both will result in a smaller list still inside the larger one, assuming the filter function behaves the same for every element.

If `l₁` is a sublist of `l₂` and `p` is a boolean function, then the sublist of `l₁` obtained by applying `p` is a sublist of the sublist of `l₂` obtained by applying `p`.


theorem CategoryTheory.essentiallySmall_of_small_of_locallySmall :
    ∀ (C : Type u) [inst : CategoryTheory.Category.{v, u} C] [inst_1 : Small.{w, u} C]
      [inst_2 : CategoryTheory.LocallySmall.{w, v, u} C], CategoryTheory.EssentiallySmall.{w, v, u} C :=
  by sorry

This theorem states that for any type `C` which is a category (given by `CategoryTheory.Category C`), if `C` is a small category (given by `Small C`) and is locally small (given by `CategoryTheory.LocallySmall C`), then `C` is essentially small (given by `CategoryTheory.EssentiallySmall C`). In terms of category theory, a category is small if its objects form a set (rather than a proper class), locally small if for any two objects there is a set of morphisms between them, and essentially small if it is equivalent to a small category. This theorem thus asserts that a small and locally small category is essentially small.

A small and locally small category is essentially small.


theorem IsClosed.upperSemicontinuous_indicator :
    ∀ {α : Type u_1} [inst : TopologicalSpace α] {β : Type u_2} [inst_1 : Preorder β] {s : Set α} {y : β}
      [inst_2 : Zero β], IsClosed s → 0 ≤ y → UpperSemicontinuous (Set.indicator s fun _x => y) :=
  by sorry

The theorem `IsClosed.upperSemicontinuous_indicator` states that for any type `α` equipped with a topology, any preordered type `β` with a zero element, any closed set `s` of type `α`, and any non-negative `y` of type `β`, the function defined by the set indicator of `s` with constant value `y` is upper semicontinuous. In other words, for every `ε > 0` and every `x`, if any element `x'` is close enough to `x`, then the value of the indicator function at `x'` is at most the value of the indicator function at `x` plus `ε`. This indicator function returns `y` if the input element is in the set `s`, and `0` otherwise.

For any closed set `s` in a topological space `α` and any non-negative `y`, the set indicator function of `s` with constant value `y` is upper semicontinuous.


theorem pos_and_pos_or_neg_and_neg_of_mul_pos :
    ∀ {α : Type u_1} {a b : α} [inst : MulZeroClass α] [inst_1 : LinearOrder α] [inst_2 : PosMulMono α]
      [inst_3 : MulPosMono α], 0 < a * b → 0 < a ∧ 0 < b ∨ a < 0 ∧ b < 0 :=
  by sorry

The theorem `pos_and_pos_or_neg_and_neg_of_mul_pos` asserts that for any type `α` with multiplication and zero, along with a linear order, and where multiplication is monotonic with respect to nonnegative elements both on the left and right, if the product of two elements `a` and `b` is positive, then either both `a` and `b` are positive, or both `a` and `b` are negative. This is a formalization of the elementary property of real numbers that the product of two numbers is positive if and only if the two numbers have the same sign.

If `α` is a type with multiplication, zero, and a linear order such that multiplication is monotonic with respect to nonnegative elements on both sides, then `a * b` is positive if and only if either `a` or `b` is positive.


/-- The lift of a supremum is the supremum of the lifts.  -/
theorem Cardinal.lift_iSup :
    ∀ {ι : Type v} {f : ι → Cardinal.{w}},
      BddAbove (Set.range f) → Cardinal.lift.{u, w} (iSup f) = ⨆ i, Cardinal.lift.{u, w} (f i) :=
  by sorry

The theorem `Cardinal.lift_iSup` states that for any type `ι` and any function `f` from `ι` to Cardinals, if the range of `f` is bounded above, then lifting the supremum of `f` (i.e., the largest cardinal number in the image of `f`) to the maximum of the universes `u` and `w` is the same as taking the supremum of the set of all cardinals obtained by lifting each value of `f(i)` to the same universes. In other words, the lift operation commutes with the supremum operation.

For any type `ι` and function `f` from `ι` to Cardinals with a bounded above range, the supremum of the cardinals obtained by lifting each `f(i)` equals the lift of the supremum of `f(i)`.


theorem small_subset : ∀ {α : Type v} {s t : Set α}, t ⊆ s → ∀ [inst : Small.{u, v} ↑s], Small.{u, v} ↑t := by sorry

The theorem `small_subset` states that for any type `α` and for any two sets `s` and `t` of that type, if `t` is a subset of `s` and if `s` is a "small" set (where "small" is defined by the `Small.{u, v}` typeclass), then `t` is also a small set. This theorem asserts that the property of being "small" is preserved under taking subsets.

If `s` is a small set and `t` is a subset of `s`, then `t` is also a small set.


theorem EReal.coe_ennreal_injective : Function.Injective ENNReal.toEReal := by sorry

The theorem `EReal.coe_ennreal_injective` states that the function `ENNReal.toEReal`, which is the canonical map converting nonnegative extended reals to extended reals, is injective. In other words, if `ENNReal.toEReal x = ENNReal.toEReal y`, then `x = y`. This means that no two different nonnegative extended reals map to the same extended real under this function.

The theorem `EReal.coe_ennreal_injective` asserts that the function `ENNReal.toEReal` mapping non-negative extended reals to extended reals is an injection.


/-- If `f` is a commutative operation on bools such that `f false false = false`, then `bitwise f`
is also commutative.  -/
theorem Nat.bitwise_comm :
    ∀ {f : Bool → Bool → Bool},
      (∀ (b b' : Bool), f b b' = f b' b) → ∀ (n m : ℕ), Nat.bitwise f n m = Nat.bitwise f m n :=
  by sorry

This theorem states that given a binary operation `f` on booleans which is commutative and has the property that `f false false = false`, then the function `Nat.bitwise f`, which applies `f` bitwise to two natural numbers `n` and `m`, is also commutative. In other words, `Nat.bitwise f n m` equals `Nat.bitwise f m n` for any two natural numbers `n` and `m` under these conditions on `f`.

Given a commutative and idempotent boolean operation `f` with `f false false = false`, the bitwise application `Nat.bitwise f` of this operation on natural numbers is commutative.


/-- The Schnirelmann density of a set not containing `1` is `0`.  -/
theorem schnirelmannDensity_eq_zero_of_one_not_mem :
    ∀ {A : Set ℕ} [inst : DecidablePred fun x => x ∈ A], 1 ∉ A → schnirelmannDensity A = 0 := by sorry

This theorem states that the Schnirelmann density of a set, which does not include the natural number `1`, is `0`. The Schnirelmann density is a concept in number theory, defined as the infimum of the ratio of the cardinality of intersection of set `A` and the set of natural numbers from `1` to `n`, to `n`, where `n` ranges over all positive natural numbers. In simpler terms, if a set of natural numbers doesn't include `1`, when we calculate the Schnirelmann density (which includes counting the number of elements shared with the set `{1, ..., n}` for each `n`), the result will always be `0`.

The Schnirelmann density of a set without the natural number 1 is 0.


theorem ENNReal.ofReal_eq_ofReal_iff : ∀ {p q : ℝ}, 0 ≤ p → 0 ≤ q → (ENNReal.ofReal p = ENNReal.ofReal q ↔ p = q) := by
  sorry

The theorem `ENNReal.ofReal_eq_ofReal_iff` states that for any two real numbers `p` and `q` that are both nonnegative (i.e., `0 ≤ p` and `0 ≤ q`), the function `ENNReal.ofReal` applied to `p` equals the same function applied to `q` if and only if `p` equals `q`. In other words, `ENNReal.ofReal` is injective for nonnegative real numbers.

For non-negative real numbers `p` and `q`, `ENNReal.ofReal p = ENNReal.ofReal q` if and only if `p = q`.


theorem Mathlib.Topology.Basic._auxLemma.75 :
    ∀ {X : Type u} {s : Set X} [inst : TopologicalSpace X],
      IsClosed s = ∀ (a : X), ClusterPt a (Filter.principal s) → a ∈ s :=
  by sorry

This theorem states that, for any type `X` and a set `s` of type `X` in a topological space, the set `s` is closed if and only if for every element `a` of type `X`, if `a` is a cluster point of the principal filter of `s`, then `a` belongs to `s`.

In more mathematical terms, a set `s` in a topological space is closed if for every point `a`, if every neighborhood of `a` intersects with `s` (meaning `a` is a cluster point of `s`), then `a` is an element of `s`. This is essentially the definition of a closed set - a set which contains all its limit points or cluster points.

A set in a topological space is closed if and only if it contains all its cluster points.


/-- Expressing `HasFDerivAt f f' x` in terms of `HasDerivAt`  -/
theorem hasFDerivAt_iff_hasDerivAt :
    ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {F : Type v} [inst_1 : NormedAddCommGroup F]
      [inst_2 : NormedSpace 𝕜 F] {f : 𝕜 → F} {x : 𝕜} {f' : 𝕜 →L[𝕜] F}, HasFDerivAt f f' x ↔ HasDerivAt f (f' 1) x :=
  by sorry

The theorem `hasFDerivAt_iff_hasDerivAt` establishes an equivalence between the properties `HasFDerivAt f f' x` and `HasDerivAt f (f' 1) x` for a given function `f` from a nontrivially normed field `𝕜` to a normed additive commutative group `F`. That is, it provides a way to express the derivative of a function at a point in the domain, in terms of two different derivative concepts: `HasFDerivAt` and `HasDerivAt`. Specifically, it states that a function `f` has a continuous linear map `f'` as its derivative at point `x` (`HasFDerivAt f f' x`) if and only if the function `f` has `f' 1` as its derivative at the point `x` (`HasDerivAt f (f' 1) x`).

A function between a nontrivially normed field and a normed additive commutative group has a continuous linear derivative at a point if and only if it has that derivative's value as its derivative at that point.


theorem Mathlib.Topology.Basic._auxLemma.52 : ∀ {a b : Prop}, (a ∧ b) = (b ∧ a) := by sorry

This theorem, named `Mathlib.Topology.Basic._auxLemma.52`, states the commutative property of logical conjunction. Given any two propositional variables `a` and `b`, the proposition "`a` and `b`" is equivalent to the proposition "`b` and `a`". That is, the conjunction of `a` and `b` is the same as the conjunction of `b` and `a`. In other words, the order in which the propositions are conjoined does not change the truth value of the statement.

The theorem `Mathlib.Topology.Basic._auxLemma.52` asserts the commutativity of logical conjunction, that is, `a ∧ b ≡ b ∧ a` for all propositional variables `a` and `b`.


theorem Mathlib.MeasureTheory.Measure.ProbabilityMeasure._auxLemma.2 : (¬False) = True := by sorry

This theorem, in the Mathlib's Measure Theory module, asserts a basic logical proposition that the negation of 'False' is 'True'. In other words, it states that if 'False' does not occur (is negated), then the result is 'True'. This is a fundamental principle in classical logic and boolean algebra.

The theorem asserts that the negation of False is True. In mathematical notation, ¬False = True.


theorem Mathlib.Topology.Basic._auxLemma.62 :
    ∀ {X : Type u} {x : X} {s : Set X} [inst : TopologicalSpace X],
      (x ∈ closure s) = ∀ t ∈ nhds x, Set.Nonempty (t ∩ s) :=
  by sorry

This theorem states that for any type `X`, any element `x` of `X`, and any set `s` of `X`, in the context of a topological space over `X`, the element `x` is in the closure of the set `s` if and only if for every neighborhood `t` of `x`, the intersection of `t` and `s` is not empty. In other words, a point belongs to the closure of a set if every neighborhood of that point intersects the set.

A point `x` in a topological space lies in the closure of a set `s` if and only if for every neighborhood `t` of `x`, the intersection `t ∩ s` is non-empty.


theorem ENNReal.rpow_le_rpow_iff : ∀ {x y : ENNReal} {z : ℝ}, 0 < z → (x ^ z ≤ y ^ z ↔ x ≤ y) := by sorry

This theorem in Lean 4 states that for all extended nonnegative real numbers `x` and `y`, and for any real number `z` that is greater than zero, the statement "x raised to the power of z is less than or equal to y raised to the power of z" is equivalent to the statement "x is less than or equal to y". Here, `ENNReal` denotes the set of extended nonnegative real numbers, which is typically denoted as [0, ∞] in standard mathematical notation.

For all `x, y ∈ ENNReal` and `z > 0`, `x^z ≤ y^z` if and only if `x ≤ y`.


theorem tendsto_pow_atTop_atTop_of_one_lt :
    ∀ {α : Type u_1} [inst : LinearOrderedRing α] [inst_1 : Archimedean α] {r : α},
      1 < r → Filter.Tendsto (fun n => r ^ n) Filter.atTop Filter.atTop :=
  by sorry

This theorem states that for any type `α` that is a linear ordered ring and Archimedean (i.e., there is no infinite element), given any element `r` from `α` such that `r` is greater than 1, the function that raises `r` to the power `n` tends to infinity as `n` tends to infinity. In mathematical terms, if $1 < r$ for an `r` in an Archimedean linear ordered ring, then the limit as `n` goes to infinity of `r^n` is also infinity.

In an Archimedean linear ordered ring, if $1 < r$, then $\lim\_{n \to \infty} r^n = \infty$.


theorem Set.Finite.exists_lt_map_eq_of_forall_mem :
    ∀ {α : Type u} {β : Type v} [inst : LinearOrder α] [inst_1 : Infinite α] {t : Set β} {f : α → β},
      (∀ (a : α), f a ∈ t) → Set.Finite t → ∃ a b, a < b ∧ f a = f b :=
  by sorry

This theorem states that for any types `α` and `β`, given a linear order on `α` and assuming `α` is infinite, if we have a set `t` of type `β` and a function `f` from `α` to `β` such that every element of `α` maps into the set `t`, if the set `t` is finite, then there exists two elements `a` and `b` in `α` where `a` is less than `b` and they map to the same element in `β` under the function `f`. This essentially says that if you have an infinite domain and a finite range, some elements in the domain must map to the same element in the range - a discrete version of the Pigeonhole Principle.

Given an infinite linear order `α` and a function `f` from `α` to a finite set `t` of type `β` such that the image of every element in `α` is in `t`, there exist distinct elements `a` and `b` in `α` with `a` less than `b` such that `f(a) = f(b)`.


/-- If an element `b` becomes add-left-regular after adding to it on the left
an add-left-regular element, then `b` is add-left-regular. -/
theorem IsAddLeftRegular.of_add :
    ∀ {R : Type u_1} [inst : AddSemigroup R] {a b : R}, IsAddLeftRegular (a + b) → IsAddLeftRegular b := by sorry

The theorem `IsAddLeftRegular.of_add` states that for any type `R` with an addition operation (forming an additive semigroup), if an element `b` of `R` becomes add-left-regular when an add-left-regular element `a` is added to it from the left, then `b` itself is also an add-left-regular element. Here, an element is considered add-left-regular if the function that adds it to any other element from the left is injective, meaning each input maps to a unique output.

If an element `b` in an additive semigroup `R` becomes add-left-regular when an add-left-regular element `a` is added to it from the left, then `b` is also an add-left-regular element.


CompleteLattice.SetIndependent.mono

theorem CompleteLattice.SetIndependent.mono :
    ∀ {α : Type u_1} [inst : CompleteLattice α] {s : Set α},
      CompleteLattice.SetIndependent s → ∀ {t : Set α}, t ⊆ s → CompleteLattice.SetIndependent t :=
  by sorry

The theorem `CompleteLattice.SetIndependent.mono` states that for any type `α` that forms a complete lattice, if a set `s` of elements of `α` is independent (meaning every element in `s` is disjoint from the supremum of the remaining elements in `s`), then for any subset `t` of `s`, `t` is also independent. In other words, independence is preserved under taking subsets in a complete lattice.

In a complete lattice, any independent subset is closed under subsets.


/-- The conditional cdf is lower or equal to 1 for all `a : α`.  -/
theorem ProbabilityTheory.condCDF_le_one :
    ∀ {α : Type u_1} {mα : MeasurableSpace α} (ρ : MeasureTheory.Measure (α × ℝ)) (a : α) (x : ℝ),
      ↑(ProbabilityTheory.condCDF ρ a) x ≤ 1 :=
  by sorry

The theorem `ProbabilityTheory.condCDF_le_one` states that for any type `α`, its associated measurable space `mα`, a measure `ρ` on the product space of `α` and the real numbers `ℝ`, and any `a` in `α` and `x` in `ℝ`, the conditional cumulative distribution function (CDF) of the measure given the value `a` on `α` is always less than or equal to 1. This aligns with the property that the cumulative distribution function of a probability measure cannot exceed 1.

For any measurable space `(α, mα)`, measure `ρ` on `α × ℝ`, and `a ∈ α` and `x ∈ ℝ`, the conditional CDF of `ρ` given `a` satisfies `ρ(a, ∞) ≤ 1`.


theorem MeasureTheory.snorm_le_nnreal_smul_snorm_of_ae_le_mul :
    ∀ {α : Type u_1} {F : Type u_3} {G : Type u_4} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α}
      [inst : NormedAddCommGroup F] [inst_1 : NormedAddCommGroup G] {f : α → F} {g : α → G} {c : NNReal},
      (∀ᵐ (x : α) ∂μ, ‖f x‖₊ ≤ c * ‖g x‖₊) →
        ∀ (p : ENNReal), MeasureTheory.snorm f p μ ≤ c • MeasureTheory.snorm g p μ :=
  by sorry

This theorem states that for any measurable space `α` and measures `μ` on `α`, along with two normed addition commutative groups `F` and `G`, and functions `f : α → F` and `g : α → G` with a non-negative real number `c`, if almost everywhere in the measure space `α` the non-negative norm of `f` at `x` is less than or equal to `c` multiplied by the non-negative norm of `g` at `x`, then for every extended non-negative real number `p`, the `ℒp` seminorm of `f` is less than or equal to `c` times the `ℒp` seminorm of `g`.
In mathematical notation, given $f : \alpha \rightarrow F$, $g : \alpha \rightarrow G$ and a non-negative real number $c$, if $\|f(x)\|_{+} \leq c \cdot \|g(x)\|_{+}$ holds almost everywhere, then $\|f\|_{p} \leq c \cdot \|g\|_{p}$ for all extended non-negative real number $p$, where $\|.\|_{+}$ denotes the non-negative norm and $\|.\|_{p}$ denotes the `ℒp` seminorm.

If the almost everywhere non-negative norm of a function `f` is less than or equal to the product of a constant `c` and the almost everywhere non-negative norm of another function `g`, then the `ℒp` seminorm of `f` is less than or equal to `c` times the `ℒp` seminorm of `g` for all extended non-negative real numbers `p`.