theorem Set.image_empty : ∀ {α : Type u_1} {β : Type u_2} (f : α → β), f '' ∅ = ∅ := by sorry

This theorem states that for any function `f` from an arbitrary type `α` to another arbitrary type `β`, the image of the empty set under `f` is also the empty set. In mathematical terms, if we have a function `f: α → β`, then `f(∅) = ∅`. This means that if we apply the function `f` to each element in the empty set, we will get an empty set as no elements exist to apply the function to.

For any function `f: α → β`, `f(∅) = ∅`, where `∅` denotes the empty set.


Associated.symm

theorem Associated.symm : ∀ {α : Type u_1} [inst : Monoid α] {x y : α}, Associated x y → Associated y x := by sorry

The theorem `Associated.symm` states that for any given type `α` that forms a `Monoid`, if two elements `x` and `y` of `α` are `Associated` (meaning one of them is the other multiplied by a unit on the right), then the reverse is also true, i.e., `y` is `Associated` with `x`. In other words, the `Associated` relationship between `x` and `y` is symmetric.

If `x` and `y` are associated elements in a monoid `α`, then `y` is associated with `x`.


theorem List.mem_cons : ∀ {α : Type u_1} {a b : α} {l : List α}, a ∈ b :: l ↔ a = b ∨ a ∈ l := by sorry

This theorem, `List.mem_cons`, states that for any type `α` and any elements `a` and `b` of that type and any list `l` of type `α`, the proposition that `a` is an element of the list composed of `b` followed by `l` is equivalent to the disjunction of the propositions that `a` equals `b` or `a` is an element of `l`. In other words, an element `a` is in the list formed by prepending `b` to `l` if and only if `a` is equal to `b` or `a` is in the list `l`.

For any type `α`, list `l` of length `≥ 1` over `α`, and elements `a` and `b` of `α`, `a ∈ list.cons b l` if and only if `a = b` or `a ∈ l`.


theorem Disjoint.le_bot :
    ∀ {α : Type u_1} [inst : SemilatticeInf α] [inst_1 : OrderBot α] {a b : α}, Disjoint a b → a ⊓ b ≤ ⊥ := by sorry

The theorem `Disjoint.le_bot` states that for any type `α` equipped with an inf-semilattice structure and a bottom element `⊥`, if two elements `a` and `b` of `α` are disjoint (in the sense that for any `x` in `α`, if `x` is less than or equal to both `a` and `b`, then `x` must also be less than or equal to `⊥`), then the infimum (greatest lower bound) of `a` and `b` is less than or equal to `⊥`. Essentially, this states that the infimum of any two disjoint elements in this structure cannot exceed the bottom element of the structure.

If `α` is an inf-semilattice with bottom element `⊥`, and `a` and `b` are disjoint elements of `α`, then `∧(a, b) ≤ ⊥`.


theorem Mathlib.Algebra.GroupWithZero.Defs._auxLemma.1 :
    ∀ {M₀ : Type u_1} [inst : MulZeroClass M₀] [inst_1 : NoZeroDivisors M₀] {a b : M₀}, (a * b = 0) = (a = 0 ∨ b = 0) :=
  by sorry

This theorem, from the Mathlib Algebra GroupWithZero Definitions, states that for any type `M₀` that is a multiplication zero class and has no zero divisors, and for any two elements `a` and `b` of type `M₀`, the condition that the product `a * b` equals zero is equivalent to either `a` equals zero or `b` equals zero. This is essentially a formalization of the standard mathematical property that in a domain (a ring without zero divisors), the product of two elements equals zero if and only if one of the elements is zero.

In a multiplication zero class `M₀` without zero divisors, `a * b = 0` if and only if `a = 0` or `b = 0`.


HasFDerivAt.fderiv

theorem HasFDerivAt.fderiv :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {f : E → F}
      {f' : E →L[𝕜] F} {x : E}, HasFDerivAt f f' x → fderiv 𝕜 f x = f' :=
  by sorry

The theorem `HasFDerivAt.fderiv` states that for any nontrivially normed field `𝕜`, normed additive commutative groups `E` and `F`, and normed vector spaces over `𝕜` for `E` and `F`, given a function `f : E → F`, a continuous linear map `f' : E →L[𝕜] F` and an element `x : E`, if `f` has `f'` as a derivative at `x` (in the sense that `f x'` approaches `f x + f' (x' - x)` as `x'` tends to `x`), then the Fréchet derivative of `f` at `x` also equals `f'`. This means that if a function `f` has a derivative at a point, then it matches the Fréchet derivative at that point.

If a function `f : E -> F` between normed vector spaces over a nontrivially normed field, with continuous linear derivative `f'`, satisfies `f x' - f x -> 0` as `x' -> x`, then `f'` is the Fréchet derivative of `f` at `x`.


IsClosed.preimage

theorem IsClosed.preimage :
    ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {f : X → Y},
      Continuous f → ∀ {t : Set Y}, IsClosed t → IsClosed (f ⁻¹' t) :=
  by sorry

This theorem states that, given two types `X` and `Y` each equipped with a topological structure (represented by `TopologicalSpace X` and `TopologicalSpace Y` respectively), for any function `f` from `X` to `Y` that is continuous, if a set `t` in `Y` is closed (denoted by `IsClosed t`), then the preimage of `t` under `f` is also closed in `X` (where `f ⁻¹' t` denotes the preimage of `t` under `f`). In other words, continuous functions map closed sets to closed sets under the operation of taking preimages.

If `f` is a continuous function between topological spaces `X` and `Y`, and `t` is a closed set in `Y`, then the preimage `f ⁻¹' t` is a closed set in `X`.


theorem Subtype.coe_eta :
    ∀ {α : Sort u_1} {p : α → Prop} (a : { a // p a }) (h : p ↑a), { val := ↑a, property := h } = a := by sorry

This theorem, `Subtype.coe_eta`, states that for any type `α` and any property `p` defined on elements of `α`, for each element `a` of the subtype `{ a // p a }` (i.e., the set of elements `a` in `α` for which `p(a)` holds) and whenever `p` holds for the coercion of `a` (notated `↑a`), the object created by the subtype constructor `{ val := ↑a, property := h }` is the same as `a` itself. Basically, it proves that if `a` is an element of a subtype characterized by a property `p`, then the element `a` can be reconstructed from its coerced value `↑a` and its property `h`.

For any type `α` and property `p` on `α`, if `a` is an element of the subtype `{ x // p x }` and `p (↑a)` holds, then `a = { val := ↑a, property := rfl }`.


theorem Int.cast_negSucc : ∀ {R : Type u} [inst : AddGroupWithOne R] (n : ℕ), ↑(Int.negSucc n) = -↑(n + 1) := by sorry

The theorem `Int.cast_negSucc` states that for any type `R` which forms an additive group with a distinguished one element, and for any natural number `n`, the casting of the negative successor of `n` (in the integers) to `R` is equal to the negation of the result of casting `n+1` to `R`. In other words, it formalizes our intuitive understanding of negation and successor operations across different numerical types.

For any additive group type R and natural number n, the casting of the negative successor of n to R equals the additive inverse of the casting of n+1 to R.


Commute.all

theorem Commute.all : ∀ {S : Type u_2} [inst : CommMagma S] (a b : S), Commute a b := by sorry

This theorem states that for any type `S` that forms a commutative magma (i.e., a set equipped with an associative and commutative binary operation), and for any two elements `a` and `b` of `S`, `a` and `b` commute. In other words, multiplying `a` and `b` in either order gives the same result, formally expressed as `a * b = b * a`.

For any commutative magma `S` and elements `a`, `b` in `S`, `a * b` equals `b * a`.


theorem Mathlib.Data.Fintype.Basic._auxLemma.25 :
    ∀ {α : Type u_1} {s : Set α} [inst : Fintype ↑s] {a : α}, (a ∈ Set.toFinset s) = (a ∈ s) := by sorry

This theorem, named `Mathlib.Data.Fintype.Basic._auxLemma.25`, states that for any type `α`, any set `s` of elements of type `α`, a finiteness instance for the set `s`, and an element `a` of type `α`, the element `a` belongs to the finite set generated from `s` (i.e., `Set.toFinset s`) if and only if the element `a` belongs to the original set `s`. This theorem connects the membership status of an element between a set and the finite set generated from it.

For any type `α`, set `s` of elements from `α`, and a finiteness instance for `s`, an element `a` belongs to the finite set generated from `s` if and only if it belongs to `s`.


theorem Set.range_subset_iff :
    ∀ {α : Type u_1} {ι : Sort u_4} {f : ι → α} {s : Set α}, Set.range f ⊆ s ↔ ∀ (y : ι), f y ∈ s := by sorry

The theorem `Set.range_subset_iff` states that for any type `α`, any sort `ι`, any function `f` from `ι` to `α`, and any set `s` of type `α`, the range of the function `f` is a subset of the set `s` if and only if for every element `y` in `ι`, the function applied to `y` (`f y`) is an element of the set `s`. In simpler terms, it shows the equivalence between the claim that all image points of `f` lie in `s` and the claim that for each input `y`, its image `f(y)` is in `s`.

For any function `f` from a type `ι` to a set `α`, and any set `s ⊆ α`, the range of `f` is a subset of `s` if and only if every image point `y ∈ ι` satisfies `f y ∈ s`.


theorem mem_of_mem_nhds : ∀ {X : Type u} {x : X} {s : Set X} [inst : TopologicalSpace X], s ∈ nhds x → x ∈ s := by sorry

This theorem states that for any type `X`, any element `x` of this type, and any set `s` of elements of type `X`, given that `X` is a topological space, if `s` is a neighborhood of `x` (i.e., `s` is in the neighborhood filter of `x`), then `x` belongs to the set `s`. In other words, any point is a member of every one of its neighborhoods in a given topological space.

In a topological space, any point is contained in every neighborhood of that point.


Commute.eq

/-- Equality behind `Commute a b`; useful for rewriting.  -/
theorem Commute.eq : ∀ {S : Type u_2} [inst : Mul S] {a b : S}, Commute a b → a * b = b * a := by sorry

The theorem `Commute.eq` states that for any type `S` equipped with a multiplication operation, if two elements `a` and `b` of `S` commute (that is, `a * b = b * a`), then the product of `a` and `b` is equal to the product of `b` and `a`. In other words, this theorem provides a way of rewriting commutative multiplications in a different order.

If `a` and `b` are commuting elements of a multiplicative monoid `S`, then `a * b = b * a`. Hence, `a * b` is equal to `b * a`.


Continuous.smul

theorem Continuous.smul :
    ∀ {M : Type u_1} {X : Type u_2} {Y : Type u_3} [inst : TopologicalSpace M] [inst_1 : TopologicalSpace X]
      [inst_2 : TopologicalSpace Y] [inst_3 : SMul M X] [inst_4 : ContinuousSMul M X] {f : Y → M} {g : Y → X},
      Continuous f → Continuous g → Continuous fun x => f x • g x :=
  by sorry

This theorem states that for any types `M`, `X`, and `Y`, if `M` and `X` are equipped with a topological space structure and a scalar multiplication operation that is continuous, and if `f` is a continuous function from `Y` to `M` and `g` is a continuous function from `Y` to `X`, then the function which takes an input `x` from `Y` and maps it to the scalar product of `f(x)` and `g(x)` is also continuous.

Given continuous scalar multiplication operations on types `M` and `X`, and continuous functions `f: Y → M` and `g: Y → X`, the function `x ↦ (f x) ⊤ (g x)` from `Y` to `M` is continuous, where `⊤` denotes the scalar product.


theorem CategoryTheory.MonoidalCategory.id_tensorHom :
    ∀ {C : Type u} [𝒞 : CategoryTheory.Category.{v, u} C] [inst : CategoryTheory.MonoidalCategory C] (X : C) {Y₁ Y₂ : C}
      (f : Y₁ ⟶ Y₂),
      CategoryTheory.MonoidalCategory.tensorHom (CategoryTheory.CategoryStruct.id X) f =
        CategoryTheory.MonoidalCategory.whiskerLeft X f :=
  by sorry

This theorem states that for any category `C` that is also a monoidal category, and for any objects `X`, `Y₁`, `Y₂` in `C`, with a morphism `f` from `Y₁` to `Y₂`, applying the tensorHom function to the identity morphism on `X` and `f` is the same as whiskering on the left of `X` with `f`. In other words, using the identity morphism on `X` in a tensor operation is equivalent to a left whiskering operation on `X`. This corresponds to the naturality condition for monoidal categories in category theory.

For any monoidal category C and objects X, Y₁, Y₂ with morphism f : Y₁ → Y₂, the tensorHom identity morphism X → Hom(C(X, Y₁), C(X, Y₂)) ≅ left whiskering of X with f.


theorem inv_ne_zero : ∀ {G₀ : Type u_3} [inst : GroupWithZero G₀] {a : G₀}, a ≠ 0 → a⁻¹ ≠ 0 := by sorry

This theorem states that for any type `G₀` that forms a group with an identity element zero, the inverse of any non-zero element `a` from `G₀` is also non-zero. In mathematical terms, if `a` belongs to a group with zero and `a` is not equal to zero, then the inverse of `a` (`a⁻¹`) is not equal to zero.

In a group with identity element zero, the inverse of a non-zero element is also non-zero.


theorem add_neg_self : ∀ {G : Type u_1} [inst : AddGroup G] (a : G), a + -a = 0 := by sorry

This theorem states that for any given type `G` equipped with the structure of an additive group, the sum of any element `a` and its additive inverse `-a` is always zero. In mathematical terms, it asserts the fundamental group property that each element plus its opposite equals the additive identity, which is zero in this context.

For any additive group `G` and element `a` in `G`, `a + (-a) = 0`.


theorem Real.Angle.sign_coe_pi_div_two : Real.Angle.sign ↑(Real.pi / 2) = 1 := by sorry

The theorem `Real.Angle.sign_coe_pi_div_two` asserts that the sign of the angle π/2 (in radians), when represented as a real number, is 1. This is equivalent to stating that the sign of the sine of π/2 equals 1. In other words, it confirms that any angle strictly between 0 and π (both exclusive) has a sign of 1, and in this case the specific angle is π/2.

The sign of the real number representation of π/2 radians is 1. Equivalently, the sine of π/2 is positive.


theorem Nat.succ_sub_succ_eq_sub : ∀ (n m : ℕ), Nat.succ n - Nat.succ m = n - m := by sorry

This theorem states that for any two natural numbers `n` and `m`, subtracting `m` from the successor of `n` (which is `n+1`) is the same as subtracting `m` from `n`. In other words, if you increment both `n` and `m` by 1, the difference between them remains unchanged.

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


theorem CategoryTheory.eqToHom_trans :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X Y Z : C} (p : X = Y) (q : Y = Z),
      CategoryTheory.CategoryStruct.comp (CategoryTheory.eqToHom p) (CategoryTheory.eqToHom q) =
        CategoryTheory.eqToHom ⋯ :=
  by sorry

The theorem `CategoryTheory.eqToHom_trans` states that for any category `C` and for any three objects `X`, `Y`, and `Z` in `C`, if we have two equalities `p: X = Y` and `q: Y = Z`, then the composition of the morphisms obtained from these equalities via the `eqToHom` function, i.e., `CategoryTheory.CategoryStruct.comp (CategoryTheory.eqToHom p) (CategoryTheory.eqToHom q)`, is equal to the morphism obtained from the transitivity of `p` and `q` using the `eqToHom` function. In other words, this theorem is a statement about the compatibility of the `eqToHom` function with the transitivity of equalities in a category.

For any category `C` and objects `X`, `Y`, and `Z` with equalities `p: X = Y` and `q: Y = Z`, the composition of morphisms `CategoryTheory.eqToHom p` and `CategoryTheory.eqToHom q` is equal to `CategoryTheory.eqToHom (p &&& q)`, where `&&&` represents the function composition in Lean.


theorem Mathlib.Logic.Basic._auxLemma.2 : ∀ {a : Prop}, (a → False) = ¬a := by sorry

The theorem `Mathlib.Logic.Basic._auxLemma.2` states that, for any proposition `a`, the proposition `a → False` is equivalent to `¬a`. In natural language, it says that asserting "if `a` then false" is the same as saying "`a` is not true" or "not `a`". This sets up a logical equivalence between implication towards falsehood and negation, which are fundamental constructs in propositional logic.

The theorem `Mathlib.Logic.Basic._auxLemma.2` asserts that for any proposition `a`, the implications `a → False` and `¬a` are logically equivalent.


theorem exists_between :
    ∀ {α : Type u} [inst : LT α] [inst_1 : DenselyOrdered α] {a₁ a₂ : α}, a₁ < a₂ → ∃ a, a₁ < a ∧ a < a₂ := by sorry

This theorem, named `exists_between`, states that for any type `α` that has a less-than relation and is densely ordered, given two elements `a₁` and `a₂` of type `α`, if `a₁` is less than `a₂`, then there exists another element `a` in type `α` which lies between `a₁` and `a₂`. In other words, in any densely ordered set, between any two distinct elements, there always exists another element.

In any densely ordered type, for all distinct elements `a₁` and `a₂`, there exists an element `a` such that `a₁` < `a` < `a₂`.


theorem inv_pow : ∀ {α : Type u_1} [inst : DivisionMonoid α] (a : α) (n : ℕ), a⁻¹ ^ n = (a ^ n)⁻¹ := by sorry

This theorem states that for any given type `α` which forms a division monoid, for any element `a` of type `α` and any natural number `n`, the inverse of `a` raised to the power of `n` is equal to the inverse of `a` raised to the power of `n`. In mathematical terms, it can be expressed as `(a⁻¹) ^ n = (a ^ n)⁻¹`. This theorem holds for all division monoids, a kind of algebraic structure that includes operations of multiplication and inverse.

For any division monoid type `α` and its element `a`, the inverse of `a` raised to the power of a natural number `n` equals the inverse of `a` raised to the power of `n`, i.e., `(a⁻¹) ^ n = (a ^ n)⁻¹`.


theorem Ne.lt_or_lt : ∀ {α : Type u} [inst : LinearOrder α] {x y : α}, x ≠ y → x < y ∨ y < x := by sorry

This theorem states that for any type `α` that has a linear order, given two elements `x` and `y` of type `α`, if `x` is not equal to `y`, then either `x` is less than `y` or `y` is less than `x`. It's essentially enforcing the trichotomy law for linearly ordered sets, which says that for any two elements in the set, one of them is either less than, equal to, or greater than the other.

For any linearly ordered type `α`, if `x` and `y` are distinct elements of `α`, then either `x` is less than `y` or `y` is less than `x`.


/-- Subtracting two points in the reverse order produces the negation
of subtracting them.  -/
theorem neg_vsub_eq_vsub_rev :
    ∀ {G : Type u_1} {P : Type u_2} [inst : AddGroup G] [T : AddTorsor G P] (p₁ p₂ : P), -(p₁ -ᵥ p₂) = p₂ -ᵥ p₁ := by
  sorry

This theorem, `neg_vsub_eq_vsub_rev`, states that for any two points `p₁` and `p₂` in any `AddTorsor` space `P` over an `AddGroup` `G`, the negation of the subtraction of `p₁` from `p₂`, denoted as `-(p₁ -ᵥ p₂)`, is equal to the subtraction of `p₂` from `p₁`, denoted as `p₂ -ᵥ p₁`. This theorem is essentially a mathematical equivalent of the idea that reversing the order of subtraction is the same as taking the negative of the original subtraction.

For any points `p₁` and `p₂` in an `AddTorsor` space `P` over an `AddGroup` `G`, `-(p₁ -ᵥ p₂) = p₂ -ᵥ p₁`.


theorem disjoint_iff_inf_le :
    ∀ {α : Type u_1} [inst : SemilatticeInf α] [inst_1 : OrderBot α] {a b : α}, Disjoint a b ↔ a ⊓ b ≤ ⊥ := by sorry

This theorem states that for any type `α` equipped with a semilattice structure and a least element, and for any two elements `a` and `b` from `α`, the two elements `a` and `b` are disjoint if and only if the infimum (greatest lower bound) of `a` and `b` is less than or equal to the least element (denoted as `⊥`). This is a characterization of disjointness in terms of infimum and the bottom element of the lattice. This result connects the concept of disjointness with the order-theoretic operations in the lattice.

For any semilattice with least element, elements `a` and `b` are disjoint if and only if their infimum is less than or equal to the least element.


theorem mul_le_mul' :
    ∀ {α : Type u_1} [inst : Mul α] [inst_1 : Preorder α]
      [inst_2 : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1]
      [inst_3 : CovariantClass α α (Function.swap fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1] {a b c d : α},
      a ≤ b → c ≤ d → a * c ≤ b * d :=
  by sorry

The theorem `mul_le_mul'` states that for any type `α` that has a `Mul` (multiplication) operation and is a `Preorder` (a type of order relation), if the multiplication operation is covariant in both arguments ("CovariantClass") and for any four elements `a`, `b`, `c`, and `d` of this type `α`, if `a` is less than or equal to `b` and `c` is less than or equal to `d`, then the product of `a` and `c` is less than or equal to the product of `b` and `d`. In mathematical terms, this is the standard property of ordered fields stating that the product of two numbers preserves the order when multiplying two inequalities.

If `α` is a Preorder type with covariant Multiplication operation, then for all `a ≤ b` and `c ≤ d` in `α`, `a * c ≤ b * d`.


/-- Note that the `IsScalarTower α β β` typeclass argument is usually satisfied by `Algebra α β`.
 -/
theorem smul_mul_assoc :
    ∀ {α : Type u_6} {β : Type u_7} [inst : Mul β] [inst_1 : SMul α β] [inst_2 : IsScalarTower α β β] (r : α) (x y : β),
      r • x * y = r • (x * y) :=
  by sorry

This theorem, `smul_mul_assoc`, states that for any scalars `r` and any elements `x`, `y` of a multiplication structure `β` (over which `α` is a scalar multiplication), the operation of scalar multiplication `r • x` followed by multiplication with `y` (`r • x * y`) is the same as scalar multiplication of `r` with the product of `x` and `y` (`r • (x * y)`). This is an important property related to the associativity of multiplication and scalar multiplication in algebraic structures where `α` acts as a scalar on `β` (usually satisfied by `Algebra α β`).

For any multiplication structure β and scalars r of α, the association holds between scalar multiplication and multiplication: r • (x * y) = r • x * y.


theorem Filter.map_mono : ∀ {α : Type u} {β : Type v} {m : α → β}, Monotone (Filter.map m) := by sorry

The theorem `Filter.map_mono` states that for all types `α` and `β`, and for any function `m` from `α` to `β`, the map of a filter under the function `m` is monotone. This means that if `f` and `g` are filters on `α` and `f ≤ g`, then the filter resulting from mapping `f` through `m` is less than or equal to the filter resulting from mapping `g` through `m`, where the order on filters is defined by inclusion of their sets.

For all types `α` and `β` and functions `m` from `α` to `β`, if `f` and `g` are filters on `α` with `f ⊆ g`, then `m(f) ⊆ m(g)`.


DifferentiableWithinAt.hasDerivWithinAt

theorem DifferentiableWithinAt.hasDerivWithinAt :
    ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {F : Type v} [inst_1 : NormedAddCommGroup F]
      [inst_2 : NormedSpace 𝕜 F] {f : 𝕜 → F} {x : 𝕜} {s : Set 𝕜},
      DifferentiableWithinAt 𝕜 f s x → HasDerivWithinAt f (derivWithin f s x) s x :=
  by sorry

The theorem `DifferentiableWithinAt.hasDerivWithinAt` states that for any type `𝕜` that forms a non-trivial normed field, any type `F` that forms a normed addition commutative group and a normed space over `𝕜`, any function `f` mapping from `𝕜` to `F`, any point `x` of type `𝕜`, and any set `s` made up of elements of type `𝕜`, if the function `f` is differentiable at the point `x` within the set `s`, then `f` has the derivative `derivWithin f s x` at the point `x` within the subset `s`. In mathematical terms, it means if there exists a derivative of `f` at `x` within `s`, then the function `f` follows the differential relationship `f x' = f x + (x' - x) • derivWithin f s x + o(x' - x)` where `x'` converges to `x` within `s`.

If a function between a normed field and a normed additive commutative group is differentiable at a point within a set, then it has the derivative at that point within the set.


theorem Polynomial.degree_eq_natDegree :
    ∀ {R : Type u} [inst : Semiring R] {p : Polynomial R}, p ≠ 0 → Polynomial.degree p = ↑(Polynomial.natDegree p) := by
  sorry

This theorem states that for any given non-zero polynomial `p` over a semiring `R`, the degree of `p` is equal to the natural number degree of `p`. In mathematical terms, if 'p' is not equal to zero, then the degree of 'p', which is the highest power of 'X' that appears in 'p' (possibly with a bottom element for the zero polynomial), is equal to the natural number degree of 'p', which forces the degree into the set of natural numbers, defining the degree of the zero polynomial as 0.

For any non-zero polynomial `p` over a semiring `R`, the degree of `p` equals the natural number degree of `p`.


theorem Equiv.image_eq_preimage : ∀ {α : Type u_1} {β : Type u_2} (e : α ≃ β) (s : Set α), ⇑e '' s = ⇑e.symm ⁻¹' s := by
  sorry

This theorem, named `Equiv.image_eq_preimage`, states that for any two types `α` and `β`, and an equivalence `e` between `α` and `β`, the image under `e` of a set `s` of type `α` is equal to the preimage under the inverse of `e` of the set `s`. In other words, applying the equivalence `e` to the elements of the set `s` results in the same set as one would obtain by finding all elements in type `β` that, under the inverse of the equivalence `e`, would be mapped to `s`.

For any equivalence `e` between types `α` and `β` and set `s` of type `α`, the image of `s` under `e` equals the preimage of `s` under the inverse of `e`.


theorem Nat.Prime.ne_zero : ∀ {n : ℕ}, Nat.Prime n → n ≠ 0 := by sorry

The theorem `Nat.Prime.ne_zero` states that for all natural numbers `n`, if `n` is prime, then `n` is not equal to zero. In mathematical terms, for any prime number `n`, it holds that `n ≠ 0`. This is consistent with the definition of a prime number, as a prime number is a natural number greater than 1 that has no positive divisors other than 1 and itself.

A prime natural number is not equal to zero.


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

The theorem `Nat.find_spec` states that for any predicate `p` on natural numbers (`ℕ`) that is decidable (`DecidablePred`), given the existence of at least one natural number `n` for which the predicate `p` holds true (`∃ n, p n`), the natural number returned by the `Nat.find` function with respect to `H` is also a number for which the predicate `p` holds true (`p (Nat.find H)`). In other words, `Nat.find` returns a natural number that satisfies the predicate `p`, if such a number exists.

If `p` is a decidable predicate on natural numbers and there exists a natural number `n` such that `p(n)` holds, then `Nat.find` returns such an `n`.


Filter.Eventually.exists

theorem Filter.Eventually.exists :
    ∀ {α : Type u} {p : α → Prop} {f : Filter α} [inst : Filter.NeBot f], (∀ᶠ (x : α) in f, p x) → ∃ x, p x := by sorry

This theorem states that for any type `α`, any predicate `p` that applies to elements of `α`, and any filter `f` of `α` which is not a bottom filter (i.e., it is not the filter that includes all sets), if `p` holds eventually (i.e., in all sufficiently large elements) for `f`, then there exists an element `x` for which `p` holds. In terms of mathematical terminology, if we have `∀ᶠ (x : α) in f, p x`, which means `p` is true for all `x` outside of a set in the filter `f` of negligibly small measure, then there exists an `x` such that `p(x)` is true.

If a predicate `p` holds eventually in a filter `f` of a type `α` that is not the bottom filter, then there exists an element `x` in `α` belonging to `f` such that `p(x)` is true.


theorem CategoryTheory.Functor.map_injective :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂}
      [inst_1 : CategoryTheory.Category.{v₂, u₂} D] {X Y : C} (F : CategoryTheory.Functor C D)
      [inst_2 : CategoryTheory.Faithful F], Function.Injective F.map :=
  by sorry

The theorem `CategoryTheory.Functor.map_injective` states that for any types `C` and `D` with `C` being of the category instance and `D` being of another category instance, and any two objects `X` and `Y` from `C` and a functor `F` from `C` to `D` that is faithful, the `map` function of the functor `F` is injective. In other words, if two objects of `C` are mapped to the same object in `D` by the functor `F`, then these two objects must be the same in `C`. This is a property of faithful functors in category theory.

Given faithful functors F from category C to category D, if F(X) = F(Y) for objects X and Y in C, then X = Y in C.


theorem tendsto_nhds_unique :
    ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : T2Space X] {f : Y → X} {l : Filter Y}
      {a b : X} [inst_2 : Filter.NeBot l], Filter.Tendsto f l (nhds a) → Filter.Tendsto f l (nhds b) → a = b :=
  by sorry

The theorem `tendsto_nhds_unique` states that for any two types `X` and `Y`, where `X` is a topological space and also a T2 space (also known as a Hausdorff space), and given a function `f` from `Y` to `X` and a filter `l` on `Y` that is not a bottom filter, if `f` tends to the neighborhood filter of `a` along `l` and also tends to the neighborhood filter of `b` along `l`, then `a` must be equal to `b`. In other words, in a Hausdorff space, a function cannot converge to two different limits.

In a Hausdorff space, if a function converges to two different limits along the same filter, then those limits are equal.


theorem Set.mem_insert : ∀ {α : Type u} (x : α) (s : Set α), x ∈ insert x s := by sorry

This theorem states that for any type `α`, any element `x` of that type, and any set `s` of elements of type `α`, the element `x` belongs to the set that is the result of inserting `x` into `s`. In short, it's confirming the intuitive property that an element is a member of the set that it has been added to.

For any type `α`, any set `s` of elements from `α`, and any `x` in `α`, `x` belongs to the set `s.insert x`.


Quotient.sound'

theorem Quotient.sound' :
    ∀ {α : Sort u_1} {s₁ : Setoid α} {a b : α}, Setoid.r a b → Quotient.mk'' a = Quotient.mk'' b := by sorry

The theorem `Quotient.sound'` states that for any type `α` equipped with a `Setoid` structure `s₁` and for any two elements `a` and `b` of type `α`, if `a` and `b` are related by the equivalence relation defined by `Setoid.r`, then their quotient images under the function `Quotient.mk''` are equal. In other words, if two elements are equivalent in the setoid, their images in the quotient set are the same.

For any Setoid `s₁` on type `α`, `Quotient.mk '' a = Quotient.mk '' b` holds if and only if `a` is related to `b` by the equivalence relation defined by `s₁`.


theorem mul_le_mul :
    ∀ {α : Type u_1} {a b c d : α} [inst : MulZeroClass α] [inst_1 : Preorder α] [inst_2 : PosMulMono α]
      [inst_3 : MulPosMono α], a ≤ b → c ≤ d → 0 ≤ c → 0 ≤ b → a * c ≤ b * d :=
  by sorry

The theorem `mul_le_mul` states that for any type `α` that has a multiplication operation, a zero element, and a preorder relation, and also satisfies the properties of monotonicity of multiplication by non-negative elements on both the left (PosMulMono) and the right (MulPosMono), if `a ≤ b` and `c ≤ d` are true and both `c` and `b` are non-negative (i.e., `0 ≤ c` and `0 ≤ b`), then `a * c ≤ b * d` is also true. This theorem therefore asserts the monotonicity of multiplication under certain conditions in the context of ordered algebraic structures.

If `α` is an ordered algebraic structure with monotonic multiplication by non-negative elements (both left and right), then for all non-negative `a ≤ b` and `c ≤ d`, we have `a * c ≤ b * d`.


/-- **Alias** of `Set.forall_mem_image`. -/
theorem Set.ball_image_iff :
    ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {s : Set α} {p : β → Prop},
      (∀ y ∈ f '' s, p y) ↔ ∀ ⦃x : α⦄, x ∈ s → p (f x) :=
  by sorry

This theorem, `Set.ball_image_iff`, states that for any types `α` and `β`, any function `f` from `α` to `β`, any set `s` of type `α`, and any property `p` applicable to elements of type `β`, the following two statements are equivalent: firstly, the property `p` holds for all elements `y` in the image of `s` under `f`; and secondly, for any element `x` in `s`, the property `p` holds for `f(x)`. In other words, it asserts that checking a property on all elements of the image of a set under a function is the same as checking the property on the function's output for all elements of the original set.

For any functions $f: \alpha \to \beta$, sets $s \subseteq \alpha$, and property $p$ on $\beta$, $p$ holds for all images of $s$ under $f$ if and only if $p$ holds for $f(x)$ for all $x \in s$.


theorem Set.disjoint_left : ∀ {α : Type u} {s t : Set α}, Disjoint s t ↔ ∀ ⦃a : α⦄, a ∈ s → a ∉ t := by sorry

This theorem, `Set.disjoint_left`, states that for any type `α` and any two sets `s` and `t` of `α`, `s` and `t` are disjoint (in the sense that their greatest lower bound is the bottom element) if and only if for every element `a` of type `α`, if `a` is an element of set `s` then `a` is not an element of set `t`. In other words, two sets are disjoint if no element of the first set is an element of the second set.

Two sets of the same type have no elements in common if and only if their intersection is the empty set.


Monotone.dual

/-- **Alias** of the reverse direction of `monotone_dual_iff`. -/
theorem Monotone.dual :
    ∀ {α : Type u} {β : Type v} [inst : Preorder α] [inst_1 : Preorder β] {f : α → β},
      Monotone f → Monotone (⇑OrderDual.toDual ∘ f ∘ ⇑OrderDual.ofDual) :=
  by sorry

The theorem `Monotone.dual` states that for all types `α` and `β` that have a preorder, and any function `f` from `α` to `β`, if `f` is a monotone function then the function obtained by first applying `f`, then applying the identity function to the `OrderDual` of `α`, and finally applying the identity function from the `OrderDual` of `β`, is also a monotone function. In other words, the monotonicity of a function is preserved when the orders of the domain and codomain are reversed.

If `f` is a monotone function between preordered types `α` and `β`, then the function `x ≤ y => y ≤ f(OrderDual x)` is also monotone, where `OrderDual` denotes the dual order.


theorem Set.eq_univ_iff_forall : ∀ {α : Type u} {s : Set α}, s = Set.univ ↔ ∀ (x : α), x ∈ s := by sorry

This theorem states that for any type `α` and any set `s` of type `Set α`, `s` is equal to the universal set `Set.univ` if and only if every element `x` of type `α` belongs to `s`. In other words, a set is the universal set if it contains all possible elements of its underlying type.

A set `s` of type `α` is equal to the universal set `Set.univ` if and only if `x ∈ s` for all `x : α`.


theorem List.mem_cons_of_mem : ∀ {α : Type u_1} (y : α) {a : α} {l : List α}, a ∈ l → a ∈ y :: l := by sorry

This theorem states that for any type `α`, and any element `a` of that type in a list `l` of elements of type `α`, if `a` is an element in `l`, then `a` is also an element in the list formed by prepending any element `y` of type `α` to `l`. In other words, if an element exists in a list, it will also exist in any list that is a superset of the original list.

If `l` is a list and `a` is an element of `l`, then `a` is also an element of the list `[y :: l]`. (Here, `::` denotes list cons, i.e., the operation of prepending an element to a list.)


theorem dist_eq_norm_sub : ∀ {E : Type u_6} [inst : SeminormedAddGroup E] (a b : E), dist a b = ‖a - b‖ := by sorry

This theorem states that, for any seminormed add group `E` and any two elements `a` and `b` of `E`, the distance between `a` and `b` is equal to the norm of the difference between `a` and `b`. Here, `dist a b` represents the distance between `a` and `b`, and `‖a - b‖` represents the norm of the difference between `a` and `b`. This is a generalization of the familiar property from Euclidean space, where the distance between two points is the absolute value of the difference of their coordinates.

For any seminormed add group `E` and elements `a, b` in `E`, the distance between `a` and `b` equals the norm of their difference: `dist a b = ‖a - b‖`.


Equiv.Perm.ext

theorem Equiv.Perm.ext : ∀ {α : Sort u} {σ τ : Equiv.Perm α}, (∀ (x : α), σ x = τ x) → σ = τ := by sorry

The theorem `Equiv.Perm.ext` states that for any types `α`, and for any two permutations `σ` and `τ` of `α`, if for all elements `x` of `α`, the application of `σ` to `x` equals the application of `τ` to `x`, then `σ` and `τ` are identical. In other words, two permutations are considered the same if they produce the same outcome on every element of the set.

If two permutations of a set map every element to the same image, then they are equal.


Eq.subst

/-- The substitution principle for equality. If `a = b ` and `P a` holds,
then `P b` also holds. We conventionally use the name `motive` for `P` here,
so that you can specify it explicitly using e.g.
`Eq.subst (motive := fun x => x < 5)` if it is not otherwise inferred correctly.

This theorem is the underlying mechanism behind the `rw` tactic, which is
essentially a fancy algorithm for finding good `motive` arguments to usefully
apply this theorem to replace occurrences of `a` with `b` in the goal or
hypotheses.

For more information: [Equality](https://lean-lang.org/theorem_proving_in_lean4/quantifiers_and_equality.html#equality)
 -/
theorem Eq.subst : ∀ {α : Sort u} {motive : α → Prop} {a b : α}, a = b → motive a → motive b := by sorry

This theorem, known as the substitution principle for equality, states that, given any type `α`, a predicate `motive` that applies to `α`, and two objects `a` and `b` of type `α`, if `a` equals `b` and the `motive` holds true for `a`, then the `motive` also holds true for `b`. Essentially, this means that if `a` and `b` are equal, anything that is true about `a` is also true about `b`. This principle is fundamental to the `rw` (rewrite) tactic in Lean, which uses this theorem to replace occurrences of `a` with `b` in a mathematical expression or proof goal.

If `a = b` and `P(a)` holds, then `P(b)` holds. (The statement `P(a)` is a predicate `motive` that applies to type `α` in Lean.)


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

This theorem states that for any two elements 'a' and 'b' in a type 'α' with a partial order, if 'a' is less than or equal to 'b', then 'a' is either equal to 'b' or 'a' is strictly less than 'b'. Here, 'α' is a placeholder for any type that has a partial order defined on it. The PartialOrder typeclass in Lean encapsulates the properties of being reflexive, antisymmetric and transitive, which are the necessary and sufficient conditions for a relation to be a partial order.

Every relation on type 'α' with the PartialOrder typeclass is total and antisymmetric, meaning that for all 'a' and 'b' in 'α', if 'a' is less than or equal to 'b', then 'a' is equal to 'b' or strictly less than 'b'.


HasDerivWithinAt.derivWithin

theorem HasDerivWithinAt.derivWithin :
    ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {F : Type v} [inst_1 : NormedAddCommGroup F]
      [inst_2 : NormedSpace 𝕜 F] {f : 𝕜 → F} {f' : F} {x : 𝕜} {s : Set 𝕜},
      HasDerivWithinAt f f' s x → UniqueDiffWithinAt 𝕜 s x → derivWithin f s x = f' :=
  by sorry

The theorem states that for a function `f` from a nontrivially normed field to a normed additive commutative group, if `f` has a derivative `f'` at a point `x` within a set `s` and `s` is uniquely differentiable at `x`, then the derivative of `f` at the point `x` within the set `s` is equal to `f'`. In mathematical terms, given a function $f: 𝕜 → F$, a point $x ∈ 𝕜$, and a subset $s ⊆ 𝕜$, if $f$ has a derivative $f'$ at $x$ within $s$ and the differentiability of $s$ at $x$ is unique, then the derivative of $f$ at $x$ within $s$ is $f'$.

If a function between a nontrivially normed field and a normed additive commutative group has a unique derivative at a point in a subset, then the derivative equals the function's value at that point within the subset.


theorem le_antisymm_iff : ∀ {α : Type u} [inst : PartialOrder α] {a b : α}, a = b ↔ a ≤ b ∧ b ≤ a := by sorry

This theorem, `le_antisymm_iff`, states that for any partially ordered type `α` and any two elements `a` and `b` of that type, `a` is equal to `b` if and only if `a` is less than or equal to `b` and `b` is less than or equal to `a`. This is a formalization of the antisymmetry property of partial orders.

In a partially ordered type, two elements are equal if and only if they are both less than or equal to each other.


/-- In an ordered additive commutative monoid, if each summand `f i` of one finite sum is less than
or equal to the corresponding summand `g i` of another finite sum, then
`∑ i in s, f i ≤ ∑ i in s, g i`.  -/
theorem Finset.sum_le_sum :
    ∀ {ι : Type u_1} {N : Type u_5} [inst : OrderedAddCommMonoid N] {f g : ι → N} {s : Finset ι},
      (∀ i ∈ s, f i ≤ g i) → (Finset.sum s fun i => f i) ≤ Finset.sum s fun i => g i :=
  by sorry

This theorem states that in an ordered additive commutative monoid, if for every element `i` in a finite set `s`, the function `f(i)` is less than or equal to the function `g(i)`, then the sum of the values of `f(i)` (where `i` ranges over all elements in `s`) is less than or equal to the sum of the values of `g(i)`. That is, if each of the individual terms of two finite sums are in a non-decreasing order, then the total sums are also in the same non-decreasing order.

In an ordered additive commutative monoid, if for all elements `i` in a finite set `s`, `f(i) ≤ g(i)`, then `∑ i in s, f(i) ≤ ∑ i in s, g(i)`.


theorem Primrec.of_eq :
    ∀ {α : Type u_1} {σ : Type u_3} [inst : Primcodable α] [inst_1 : Primcodable σ] {f g : α → σ},
      Primrec f → (∀ (n : α), f n = g n) → Primrec g :=
  by sorry

The theorem `Primrec.of_eq` states that for any two functions `f` and `g` from a type `α` to a type `σ` (both of these types being primcodable), if `f` is primitive recursive and `g` equals `f` for every natural number `n` in the domain `α`, then `g` is also primitive recursive. This theorem allows one to reason about the preservation of the primitive recursive property under the condition of pointwise equality.

If `f` is a primitive recursive function from type `α` to `σ`, and `f` equals `g` for all natural numbers `n` in the domain `α` of `f`, then `g` is also a primitive recursive function.


theorem Mathlib.Data.Set.Basic._auxLemma.49 : ∀ {α : Type u} (a : α), Set.Nonempty {a} = True := by sorry

This theorem states that for any type `α` and any element `a` of type `α`, the singleton set containing just `a` is indeed non-empty. This means that there exists an element in the set that contains only `a`, which is unsurprising as `a` itself is the element in it.

For any type `α` and any of its element `a`, the singleton set `{a : α}` is a non-empty set.


theorem Mathlib.Data.Set.Basic._auxLemma.17 : ∀ {α : Type u} (x : α) (a b : Set α), (x ∈ a ∪ b) = (x ∈ a ∨ x ∈ b) := by
  sorry

This theorem is about the union of two sets in set theory. Given a type `α`, and three elements: `x`, which is of type `α`, and `a` and `b` which are sets of type `α`, it states that the membership of `x` in the union of sets `a` and `b` is equivalent to saying that `x` is a member of set `a` or `x` is a member of set `b`. This is a fundamental property of set unions in mathematics, often denoted as `x ∈ a ∪ b` is equivalent to `x ∈ a ∨ x ∈ b`.

For any type `α` and sets `a` and `b` of type `α`, the element `x` belongs to the union `a ∪ b` if and only if `x` belongs to `a` or `x` belongs to `b`.


theorem ContinuousLinearMap.addCommGroup.proof_1 :
    ∀ {M₂ : Type u_1} [inst : TopologicalSpace M₂] [inst_1 : AddCommGroup M₂] [inst_2 : TopologicalAddGroup M₂],
      ContinuousAdd M₂ :=
  by sorry

This theorem states that for any type `M₂`, given that `M₂` has a topological space structure, an additive commutative group structure, and a topological additive group structure, it follows that `M₂` has a continuous addition structure. This essentially means that the operation of addition is continuous in the topological sense, i.e., the pre-image of any open set under the addition function is also open.

Given a type `M₂` equipped with a topological space, an additive commutative group, and a topological additive group structure, the addition operation on `M₂` is continuous.


theorem Mathlib.Algebra.Order.Monoid.Canonical.Defs._auxLemma.11 :
    ∀ {α : Type u} [inst : CanonicallyOrderedAddCommMonoid α] {a : α}, (a ≤ 0) = (a = 0) := by sorry

This theorem, from the `Mathlib.Algebra.Order.Monoid.Canonical.Defs` namespace, asserts that for any type `α` that is a canonically ordered additive commutative monoid, any element `a` of this type is less than or equal to 0 if, and only if, `a` is equal to 0.

For any additive commutative monoid with a canonical order, an element is less than or equal to 0 if and only if it is equal to 0.


theorem Filter.comap_comap :
    ∀ {α : Type u} {β : Type v} {γ : Type w} {f : Filter α} {m : γ → β} {n : β → α},
      Filter.comap m (Filter.comap n f) = Filter.comap (n ∘ m) f :=
  by sorry

This theorem states that for any types `α`, `β`, and `γ`, for any filter `f` of type `α`, and for any functions `m` from `γ` to `β` and `n` from `β` to `α`, the composition of the filter `comap` function applied to `m` and then to `n` on filter `f`, is equal to the application of `comap` to the composition of `n` and `m` on filter `f`. In other words, it states that filter `comap` function is associative with function composition. This can be described in mathematical terms as `Filter.comap m (Filter.comap n f) = Filter.comap (n ∘ m) f`.

For any filters `f` on types `α`, and functions `m: γ → β` and `n: β → α`, the composition of `Filter.comap m` and `Filter.comap n` on filter `f` equals `Filter.comap (n ∘ m) f`.


theorem top_le_iff : ∀ {α : Type u} [inst : PartialOrder α] [inst_1 : OrderTop α] {a : α}, ⊤ ≤ a ↔ a = ⊤ := by sorry

This theorem states that for any type `α` that has a partial order and a greatest element (`⊤`), a given element `a` of type `α` satisfies `⊤ ≤ a` if and only if `a` is equal to `⊤`. In other words, in such a partially ordered set, the only element that the greatest element (`⊤`) is less than or equal to, is the greatest element itself.

In a partially ordered set with a greatest element, the greatest element is the unique element that is less than or equal to itself.


theorem dist_eq_norm_div : ∀ {E : Type u_6} [inst : SeminormedGroup E] (a b : E), dist a b = ‖a / b‖ := by sorry

This theorem states that in any semi-normed group `E`, the distance between two elements `a` and `b` of `E` is equal to the norm of their division (`a / b`). Here, `dist` represents the metric or distance function, and `‖a / b‖` represents the norm (or length) of the element resulting from the division of `a` and `b`.

In a semi-normed group, the distance between two elements is equal to the norm of their quotient.


theorem tsub_le_iff_right :
    ∀ {α : Type u_1} [inst : LE α] [inst_1 : Add α] [inst_2 : Sub α] [inst_3 : OrderedSub α] {a b c : α},
      a - b ≤ c ↔ a ≤ c + b :=
  by sorry

This theorem, `tsub_le_iff_right`, states that for any type `α` with the characteristics of being orderable, subtractable, addable, and less-than-or-equal-to comparable, for any three elements of type `α` named `a`, `b`, and `c`, it holds that `a` minus `b` is less than or equal to `c` if and only if `a` is less than or equal to the sum of `c` and `b`.

For any orderable, subtractable, addable type `α` and elements `a`, `b`, and `c` of `α`, `a - b ≤ c` if and only if `a ≤ c + b`.


theorem Nat.succ_eq_add_one : ∀ (n : ℕ), Nat.succ n = n + 1 := by sorry

This theorem states that for every natural number `n`, the successor of `n` is equal to `n` plus one. In other words, it enforces the standard mathematical principle that adding one to a natural number gives you the next consecutive natural number.

For every natural number `n`, `(Suc n) = n + 1`.


theorem List.length_append :
    ∀ {α : Type u} (as bs : List α), List.length (as ++ bs) = List.length as + List.length bs := by sorry

This theorem states that for any type `α` and any two lists `as` and `bs` of that type, the length of the concatenated list `as ++ bs` is equal to the sum of the lengths of `as` and `bs`. In other words, it expresses the property that the length of the concatenation of two lists is the sum of the lengths of the individual lists.

For any type `α` and lists `as : list α` and `bs : list α`, the length of their concatenation `as ++ bs` equals the sum of the lengths of `as` and `bs`. (In mathematical notation: `#as + #bs = #(as ++ bs)`, where `#` denotes list length.)


theorem dist_zero_right : ∀ {E : Type u_6} [inst : SeminormedAddGroup E] (a : E), dist a 0 = ‖a‖ := by sorry

This theorem states that for any type `E` that forms a seminormed add group, the distance of any element `a` from zero is equal to the norm of `a`. In mathematical terms, we can say that for any element `a` in a seminormed add group `E`, the distance from `a` to the zero element (`0`) is identical to the seminorm of `a` (denoted as `‖a‖`).

In a seminormed add group, the seminorm of an element equals its distance to the zero element.


theorem MeasureTheory.withDensity_apply :
    ∀ {α : Type u_1} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} (f : α → ENNReal) {s : Set α},
      MeasurableSet s → ↑↑(μ.withDensity f) s = ∫⁻ (a : α) in s, f a ∂μ :=
  by sorry

The theorem `MeasureTheory.withDensity_apply` states that for any type `α`, any measurable space `m0` on `α`, any measure `μ` on `α`, any function `f` from `α` to the extended nonnegative real numbers, and any set `s` of type `α`, if `s` is a measurable set, then the double coercion of the measure of `s` with density `f` is equal to the integral over `s` with respect to `μ` of the function `f`. In other words, this theorem relates the concept of a measure with density to the concept of an integral over a measurable set.

For any measurable space `(α, m0)`, measure `μ`, function `f` to extended nonnegative real numbers, and measurable set `s`, the double coercion of `μ s` with density `f` equals the integral of `f` over `s` with respect to `μ`.


Primrec.snd

theorem Primrec.snd :
    ∀ {α : Type u_3} {β : Type u_4} [inst : Primcodable α] [inst_1 : Primcodable β], Primrec Prod.snd := by sorry

The theorem `Primrec.snd` asserts that for any pair of types `α` and `β` which are Primcodable (i.e., they can be encoded as natural numbers), the function that retrieves the second component from a pair (denoted as `Prod.snd`) is considered primitive recursive. In other words, if we represent the input/output of `Prod.snd` as natural numbers, then the function corresponds to a primitive recursive function in number theory.

The function `Prod.snd` on pairs of Primcodable types is a primitive recursive function in number theory.


theorem Cardinal.mk_fintype : ∀ (α : Type u) [h : Fintype α], Cardinal.mk α = ↑(Fintype.card α) := by sorry

The theorem `Cardinal.mk_fintype` states that for any type `α` that is a finite type (i.e., it has a `Fintype α` instance), the cardinality of `α` (denoted by `Cardinal.mk α`) is equal to the natural number representation (indicated by `↑`) of the cardinality of `α` when `α` is considered as a finite type (given by `Fintype.card α`). In other words, this theorem is asserting that the cardinality of a finite type as a type is the same as its cardinality as a finite type.

For any finite type α, the cardinality of α as a type (`Cardinal.mk α`) equals the cardinality of α as a finite type (`Fintype.card α`).


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

The theorem `CategoryTheory.Preadditive.comp_neg` states that for any three objects `P`, `Q`, and `R` in a preadditive category `C`, and any two morphisms `f` from `P` to `Q`, and `g` from `Q` to `R`, the composition of `f` with the negation of `g` is equal to the negation of the composition of `f` and `g`. Here, a preadditive category is a category that has a zero object, and every hom-set has the structure of an abelian group. This theorem captures a key property of negative morphisms in preadditive categories.

In a preadditive category, for any objects P, Q, and R, and morphisms f : P -> Q and g : Q -> R, the negation of (f \* g) is equal to g^(-1) \* f^(-1). (Here, \* denotes composition, and ^(-1) denotes the inverse in the abelian group structure of hom-sets.)


/-- If `α` has no zero divisors, then the product of two elements equals zero iff one of them
equals zero.  -/
theorem mul_eq_zero :
    ∀ {M₀ : Type u_1} [inst : MulZeroClass M₀] [inst_1 : NoZeroDivisors M₀] {a b : M₀}, a * b = 0 ↔ a = 0 ∨ b = 0 := by
  sorry

This theorem states that for any type `M₀`, which is a `MulZeroClass` (a structure that has a multiplication operation and a zero element) and has no zero divisors, the product of any two elements `a` and `b` of `M₀` equals zero if and only if either `a` equals zero, or `b` equals zero. In mathematical terms, we can say that in a ring without zero divisors, the product of two elements is zero if and only if at least one of the elements is zero.

In a ring without zero divisors, the product of two non-zero elements is equal to zero if and only if one of them is zero.


theorem sub_sub_cancel : ∀ {G : Type u_3} [inst : AddCommGroup G] (a b : G), a - (a - b) = b := by sorry

This theorem, `sub_sub_cancel`, states that for any type `G` that is an additive commutative group (denoted by `[inst : AddCommGroup G]`), for any two elements `a` and `b` of type `G`, if you subtract `b` from `a` and then subtract the result from `a` again, you end up with `b`. In mathematical notation, this can be written as `a - (a - b) = b` for all `a, b ∈ G`.

For any additive commutative group `G` and elements `a, b` in `G`, `a - (a - b) = b`.


theorem div_mul_cancel : ∀ {G : Type u_3} [inst : Group G] (a b : G), a / b * b = a := by sorry

This theorem, `div_mul_cancel`, states that for all elements `a` and `b` of a group `G`, the result of dividing `a` by `b` (written as `a / b`) and then multiplying by `b` is equal to `a`. This mirrors the similar property in the division of numbers where `(a / b) * b = a`, which holds true for any group structure.

For all groups G and elements a, b in G, a / b * b = a.


theorem HasFDerivWithinAt.differentiableWithinAt :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {f : E → F}
      {f' : E →L[𝕜] F} {x : E} {s : Set E}, HasFDerivWithinAt f f' s x → DifferentiableWithinAt 𝕜 f s x :=
  by sorry

The theorem `HasFDerivWithinAt.differentiableWithinAt` states that for any non-trivially normed field `𝕜` and normed additive commutative groups `E` and `F` that are also normed spaces over `𝕜`, if a function `f` from `E` to `F` has a Frechet derivative `f'` at a point `x` within a set `s` of `E` (denoted by `HasFDerivWithinAt f f' s x`), then `f` is differentiable at the point `x` within the set `s` (denoted by `DifferentiableWithinAt 𝕜 f s x`). This theorem is a fundamental result in differential calculus that connects the existence of a derivative to the property of differentiability.

If a function between normed spaces has a Frechet derivative at a point within a set, then the function is differentiable at that point within the set.


/-- **Alias** of `mul_sub_right_distrib`. -/
theorem sub_mul : ∀ {α : Type u} [inst : NonUnitalNonAssocRing α] (a b c : α), (a - b) * c = a * c - b * c := by sorry

This theorem, named `sub_mul`, asserts that for any non-unital, non-associative ring α, and any elements a, b, and c of α, the operation of subtracting b from a and then multiplying by c is the same as subtracting the product of b and c from the product of a and c. In mathematical notation, this would be written as $(a - b) * c = a * c - b * c$. This theorem is an alias of the `mul_sub_right_distrib` theorem.

For any non-unital, non-associative ring α and elements a, b, and c in α, the distributive property holds: a * (c - b) = a * c - a * b.


theorem WithBot.coe_le_coe : ∀ {α : Type u_1} {a b : α} [inst : LE α], ↑a ≤ ↑b ↔ a ≤ b := by sorry

This theorem, `WithBot.coe_le_coe`, states that for any type `α` and any two elements `a` and `b` of this type that have a less-than-or-equal-to (`≤`) relation defined on them, the less-than-or-equal-to relation between their coe (or coercion) holds if and only if the less-than-or-equal-to relation between `a` and `b` holds. In other words, the order is preserved when we move from the original elements to their coerced versions.

For any type `α` with a `≤` relation and elements `a` and `b` of `α`, if `a ≤ b`, then their coerced versions have the same relationship: `coe a ≤ coe b` (or `coe b ≥ coe a`).


theorem Polynomial.eval_C :
    ∀ {R : Type u} {a : R} [inst : Semiring R] {x : R}, Polynomial.eval x (Polynomial.C a) = a := by sorry

The theorem `Polynomial.eval_C` states that, for any semiring `R`, any element `a` of `R`, and any element `x` of `R`, the evaluation of the constant polynomial `a` (represented by `Polynomial.C a`) at `x` is always equal to `a`. In other words, the value of a constant polynomial doesn't change under evaluation at any point in the semiring.

For any semiring R and its elements a and x, the constant polynomial C(a) of R evaluates to a at x.


theorem Set.union_comm : ∀ {α : Type u} (a b : Set α), a ∪ b = b ∪ a := by sorry

The theorem `Set.union_comm` states that for any type `α` and any two sets `a` and `b` of type `α`, the union of `a` and `b` is equal to the union of `b` and `a`. This is the commutative property of set union, which essentially means that the order in which sets are united does not affect the resulting set.

For any type `α` and sets `a` and `b` of type `α`, `a ∪ b = b ∪ a`.


theorem and_congr_right : ∀ {a b c : Prop}, (a → (b ↔ c)) → (a ∧ b ↔ a ∧ c) := by sorry

This theorem, `and_congr_right`, states that for any three propositions `a`, `b`, and `c`, if it is true that `a` implies an equivalence between `b` and `c`, then there's an equivalence between `a ∧ b` and `a ∧ c`. In other words, if `a` being true allows us to say `b` if and only if `c`, then the conjunction of `a` and `b` is equivalent to the conjunction of `a` and `c`.

If `a` implies `b ↔ c`, then `a ∧ b ≡ a ∧ c`.


theorem neg_pos :
    ∀ {α : Type u} [inst : AddGroup α] [inst_1 : LT α]
      [inst_2 : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x < x_1] {a : α}, 0 < -a ↔ a < 0 :=
  by sorry

This theorem, `neg_pos`, states that for any type `α` which is an additive group and has a less-than (`<`) operation satisfying the covariant property with respect to addition, the statement 'zero is less than negative `a`' is equivalent to 'a is less than zero'. In other words, for any element `a` in such a type `α`, `0 < -a` if and only if `a < 0`.

For any additive group `α` with a covariant `<` relation on it, `0 < -a` if and only if `a < 0`.


theorem add_lt_add_left :
    ∀ {α : Type u_1} [inst : Add α] [inst_1 : LT α]
      [inst_2 : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x < x_1] {b c : α},
      b < c → ∀ (a : α), a + b < a + c :=
  by sorry

This theorem, `add_lt_add_left`, states that for any type `α` with an addition operation and a less-than relation, if the type has the covariant property for addition and less-than (where adding a value to two items maintains their original order), then for any two elements `b` and `c` of this type, if `b` is less than `c`, adding another element `a` to both `b` and `c` results in `a + b` still being less than `a + c`. This theorem essentially formalizes the intuitive property that adding the same value to two different numbers maintains their relative ordering.

If `α` is a type with covariant addition and less-than relations, then for all `a`, `b`, and `c` in `α` with `b < c`, we have `a + b < a + c`.


theorem Nat.succ_add : ∀ (n m : ℕ), Nat.succ n + m = Nat.succ (n + m) := by sorry

This theorem states that for any two natural numbers `n` and `m`, the successor of `n` added to `m` is equal to the successor of the sum of `n` and `m`. In mathematical terms, if `n` and `m` are elements of the natural numbers, then `succ(n) + m = succ(n + m)`. This theorem illustrates a property of the addition operation in natural numbers.

For any natural numbers `n` and `m`, `succ(n + m)` equals `succ(n)` plus `m`.


DifferentiableAt.differentiableWithinAt

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

The theorem `DifferentiableAt.differentiableWithinAt` states that for any nontrivially normed field `𝕜`, normed add commutative group `E`, and normed add commutative group `F`, with a normed space structure over `𝕜` for `E` and `F`, if a function `f` mapping from `E` to `F` is differentiable at a point `x` in `E`, then `f` is also differentiable at the same point `x` within any set `s` of `E`. In mathematical terms, this theorem asserts that if a function is differentiable at a point, then it remains differentiable at that point when restricted to any subset of its domain.

If a function is differentiable at a point in a normed add commutative group, then it is differentiable at that point in any subset of its domain in the same normed add commutative groups.


theorem Finset.mem_coe : ∀ {α : Type u_1} {a : α} {s : Finset α}, a ∈ ↑s ↔ a ∈ s := by sorry

This theorem states that for any type `α`, any element `a` of type `α`, and any finite set `s` of type `α`, `a` is an element of the coercion of `s` to a set if and only if `a` is an element of `s`. In other words, an element is in the finite set `s` if it is also in the set obtained by treating `s` as a set (not specifically a finite set), and vice versa.

For any type `α`, any element `a` of type `α`, and any finite set `s` of type `α`, `a` is in the set `s` if and only if `a` is in the coercion of `s` to a set.


theorem Fin.is_lt : ∀ {n : ℕ} (a : Fin n), ↑a < n := by sorry

This theorem, `Fin.is_lt`, states that for any natural number `n` and a finite ordinal `a` of size `n` (represented as `Fin n`), the natural number representation of `a` (obtained by coercing `a` into `ℕ` using `↑a`) is strictly less than `n`. Essentially, it guarantees that any element of a `Fin n` set is less than `n` when viewed as a natural number.

For any natural number `n` and finite ordinal `a` of size `n`, the natural number representation of `a` is strictly less than `n`. In Lean notation, `↑a < n`.


theorem AddOpposite.unop_injective : ∀ {α : Type u_1}, Function.Injective AddOpposite.unop := by sorry

The theorem `AddOpposite.unop_injective` states that for every type `α`, the function `AddOpposite.unop` is injective. In other words, it asserts that for any type `α`, if `AddOpposite.unop x` equals `AddOpposite.unop y`, then `x` must be equal to `y`. This is essentially saying that the function `AddOpposite.unop` does not map different elements of the type `αᵃᵒᵖ` (the additive opposite of α) to the same element of `α`, ensuring the uniqueness of the pre-image for each element in the co-domain.

For every type `α`, the function `AddOpposite.unop` from the additive opposite `αᵃᵒᵖ` to `α` is a injection.


theorem Polynomial.leadingCoeff_eq_zero :
    ∀ {R : Type u} [inst : Semiring R] {p : Polynomial R}, Polynomial.leadingCoeff p = 0 ↔ p = 0 := by sorry

The theorem `Polynomial.leadingCoeff_eq_zero` states that for all `R` of type `u` with a semiring structure, and for any polynomial `p` over `R`, the leading coefficient of `p` is zero if and only if `p` is the zero polynomial. The leading coefficient of a polynomial is defined as the coefficient of the highest power of `X` in the polynomial. Therefore, this theorem is essentially stating that a polynomial is zero if and only if its highest power term's coefficient is zero.

A polynomial over a semiring is the zero polynomial if and only if its leading coefficient is zero.


theorem heq_eq_eq : ∀ {α : Sort u} (a b : α), HEq a b = (a = b) := by sorry

This theorem, `heq_eq_eq`, asserts that for any type, denoted by `α`, and any two elements `a` and `b` of that type, the heterogeneous equality (`HEq`) of `a` and `b` is the same as the standard equality (`=`) of `a` and `b`. In other words, `HEq a b` and `a = b` are interchangeable for any given `a` and `b` of the same type `α`.

For any type `α` and elements `a` and `b` of type `α`, the heterogeneous equality `HEq a b` is equivalent to the standard equality `a = b`.


theorem le_add_self : ∀ {α : Type u} [inst : CanonicallyOrderedAddCommMonoid α] {a b : α}, a ≤ b + a := by sorry

This theorem states that for any type `α` that forms a canonically ordered additive commutative monoid, and for any two elements `a` and `b` of that type, `a` is less than or equal to the sum of `b` and `a`. Here, the `CanonicallyOrderedAddCommMonoid` is a specific structure in mathematics that combines the properties of an additive commutative monoid (where addition is associative and commutative, and there's a "zero" element that doesn't change other elements when added) with a canonical order (a way of comparing elements).

For any type `α` with a canonical order and the structure of an additive commutative monoid, `a ≤ a + b` for all `a, b : α`.


theorem GaloisConnection.le_u_l :
    ∀ {α : Type u} {β : Type v} [inst : Preorder α] [inst_1 : Preorder β] {l : α → β} {u : β → α},
      GaloisConnection l u → ∀ (a : α), a ≤ u (l a) :=
  by sorry

This theorem states that for any types `α` and `β` equipped with preorders, and for any pair of functions `l : α → β` and `u : β → α` forming a Galois connection, it is always the case that `a` is less than or equal to `u (l a)` for all `a` in `α`. In other words, for a Galois connection between two preordered sets, any element `a` from the domain is always less than or equal to the result of applying `u` to the image of `a` under `l`. This property is a fundamental characteristic of a Galois connection in order theory.

For any Galois connection between preordered types `α` and `β` via functions `l : α → β` and `u : β → α`, `a ≤ u (l a)` for all `a ∈ α`.


Nat.Prime.pos

theorem Nat.Prime.pos : ∀ {p : ℕ}, Nat.Prime p → 0 < p := by sorry

The theorem `Nat.Prime.pos` states that for every natural number `p`, if `p` is prime, then `p` is greater than 0. In other words, any prime number is positive.


theorem Set.Ioc_subset_Icc_self : ∀ {α : Type u_1} [inst : Preorder α] {a b : α}, Set.Ioc a b ⊆ Set.Icc a b := by sorry

The theorem `Set.Ioc_subset_Icc_self` states that for any type `α` that has a preorder (a relation that is reflexive and transitive), and for any two elements `a` and `b` of that type, the left-open right-closed interval from `a` to `b` (denoted `Set.Ioc a b`), is a subset of the left-closed right-closed interval from `a` to `b` (denoted `Set.Icc a b`). In other words, all elements `x` that satisfy `a < x ≤ b` also satisfy `a ≤ x ≤ b`.

For any type `α` with a preorder and any `a ≤ b` in `α`, `Set.Ioc a b` (the left-open right-closed interval from `a` to `b`) is a subset of `Set.Icc a b` (the left-closed right-closed interval from `a` to `b`). In other words, `Set.Ioc a b ⊆ Set.Icc a b`.


theorem Real.rpow_pos_of_pos : ∀ {x : ℝ}, 0 < x → ∀ (y : ℝ), 0 < x ^ y := by sorry

This theorem states that for all real numbers `x`, if `x` is greater than 0, then for any real number `y`, `x` raised to the power of `y` (represented as `x ^ y`) is also greater than 0. In other words, the result of raising a positive real number to any power is always a positive real number.

For all real numbers `x` and `y`, if `x > 0`, then `x ^ y > 0`.


theorem CategoryTheory.Limits.cokernel.condition :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
      {X Y : C} (f : X ⟶ Y) [inst_2 : CategoryTheory.Limits.HasCokernel f],
      CategoryTheory.CategoryStruct.comp f (CategoryTheory.Limits.cokernel.π f) = 0 :=
  by sorry

The theorem `CategoryTheory.Limits.cokernel.condition` states that for any type `C` that has a category structure and zero morphisms, given any objects `X` and `Y` in `C` and a morphism `f` from `X` to `Y` that has a cokernel, the composition of `f` and the map from `Y` to the cokernel of `f` is a zero morphism. This is a generalisation of the algebraic concept of a cokernel, where the composition of the map and the cokernel map is the zero map.

For any object `X`, `Y` in a category `C` with zero morphisms and any morphism `f` from `X` to `Y` having a cokernel, the composition `f` ∘ cokernel(`f`) is a zero morphism.


/-- **Alias** of the reverse direction of `sup_eq_left`. -/
theorem sup_of_le_left : ∀ {α : Type u} [inst : SemilatticeSup α] {a b : α}, b ≤ a → a ⊔ b = a := by sorry

This theorem, `sup_of_le_left`, is an alias of the reverse direction of the theorem `sup_eq_left` in Lean 4. It states that for any type `α` that is a semilattice with a supremum operation (`SemilatticeSup α`), and any two elements `a` and `b` of type `α`, if `b` is less than or equal to `a` (`b ≤ a`), then the supremum of `a` and `b` (`a ⊔ b`) is equals to `a`. In mathematical terms, if `b` is less than or equal to `a`, the "greatest" element between `a` and `b` is `a`.

If `α` is a semilattice with supremum, and `a` and `b` are elements of `α` with `b ≤ a`, then `a ⊔ b = a`.


theorem mul_pow : ∀ {M : Type u} [inst : CommMonoid M] (a b : M) (n : ℕ), (a * b) ^ n = a ^ n * b ^ n := by sorry

This theorem, `mul_pow`, states that for any type `M` that forms a commutative monoid (denoted by `CommMonoid M`), for any elements `a` and `b` of that type `M`, and for any natural number `n`, the nth power of the product of `a` and `b` is equal to the product of the nth power of `a` and the nth power of `b`. In mathematical terms, it could be represented as $(a * b)^n = a^n * b^n$ for all `a`, `b` in `M` and `n` in ℕ.

For any commutative monoid `M`, and elements `a` and `b` in `M`, the nth powers of their product equal the product of their nth powers, i.e., $(a * b)^n = a^n * b^n$ for all `n` in ℕ.


theorem ne_of_apply_ne : ∀ {α : Sort u_1} {β : Sort u_2} (f : α → β) {x y : α}, f x ≠ f y → x ≠ y := by sorry

This theorem, `ne_of_apply_ne`, states that for any two types `α` and `β`, and a function `f` from `α` to `β`, if the function `f` applied to two values `x` and `y` of type `α` gives different results (i.e., `f x` is not equal to `f y`), then `x` is not equal to `y`. In other words, if the function outputs are different for two inputs, then the inputs themselves must also be different.

If `f : α → β` is a function and `x` and `y` are in `α` with `f x ≠ f y`, then `x ≠ y`.


theorem decide_eq_true_eq : ∀ {p : Prop} {x : Decidable p}, (decide p = true) = p := by sorry

This theorem states that for any proposition `p` and `x`, which is a decidable instance of `p`, the result of applying the `decide` function to `p` being `true` is equivalent to the proposition `p` itself being true. In other words, it formalizes the intuitive idea that if a proposition is decidable, deciding it and getting `true` means that the proposition is itself true.

For any decidable proposition `p` and instance `x`, `decide p x = some true` if and only if `p x` holds.


theorem disjoint_iff :
    ∀ {α : Type u_1} [inst : SemilatticeInf α] [inst_1 : OrderBot α] {a b : α}, Disjoint a b ↔ a ⊓ b = ⊥ := by sorry

This theorem states that for any type `α` that is a semilattice (an algebraic structure with a binary operation that is associative, commutative, and idempotent, and also has a partial order relation that is compatible with the binary operation) with the infimum operation and a least element (denoted as ⊥), and for any two elements `a` and `b` of this type, `a` and `b` are disjoint if and only if their infimum (the greatest lower bound) is the least element (⊥). In simple terms, two elements are disjoint if their greatest common lower bound is the smallest possible element in the set.

For any semilattice with infimum and least element, two elements are disjoint if and only if their infimum equals the least element.


theorem MeasureTheory.lintegral_const :
    ∀ {α : Type u_1} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} (c : ENNReal),
      ∫⁻ (x : α), c ∂μ = c * ↑↑μ Set.univ :=
  by sorry

The theorem `MeasureTheory.lintegral_const` states that for any measure space `α` with a measurable space structure `m` and a measure `μ`, and any nonnegative extended real number `c`, the Lebesgue integral of the constant function with value `c` with respect to the measure `μ` equals `c` times the measure of the universal set. In other words, it provides a formula for calculating the Lebesgue integral of a constant function over the entire space, which is simply the product of the constant and the measure of the whole space.

For any measure space `(α, Σ, m, μ)` and constant function `c : ℝ↑`, the Lebesgue integral of `c` with respect to `μ` equals `c * μ(α)`.


theorem Finset.mem_insert_of_mem :
    ∀ {α : Type u_1} [inst : DecidableEq α] {s : Finset α} {a b : α}, a ∈ s → a ∈ insert b s := by sorry

The theorem `Finset.mem_insert_of_mem` states that for any given type `α` that has decidable equality, and any `s` which is a finite set of `α`, if an element `a` belongs to `s`, then `a` also belongs to the set obtained by inserting any other element `b` into `s`. In mathematical terms, this is equivalent to saying that if `a` is an element of a set `S`, then `a` is also an element of `S ∪ {b}`, for any `b`.

If `α` has decidable equality and `a` is an element of a finite set `s` of `α`, then `a` is also an element of the set obtained by inserting any other element `b` into `s`. In mathematical notation, `a ∈ s` implies `a ∈ s ∪ {b}`.


theorem Nat.div_zero : ∀ (n : ℕ), n / 0 = 0 := by sorry

This theorem states that for any natural number `n`, the result of dividing `n` by zero is zero. This is a universal property that applies to all natural numbers. Please note that this is a convention in the Lean 4 theorem prover and might differ from other mathematical contexts where division by zero is usually undefined.

For all natural numbers n, n divided by zero equals zero.


MeasureTheory.Filtration.le

theorem MeasureTheory.Filtration.le :
    ∀ {Ω : Type u_1} {ι : Type u_3} {m : MeasurableSpace Ω} [inst : Preorder ι] (f : MeasureTheory.Filtration ι m)
      (i : ι), ↑f i ≤ m :=
  by sorry

This theorem states that for any type `Ω`, any type `ι` with a preorder, a measurable space `m` on `Ω`, and a filtration `f` on `m` indexed by `ι`, the measure theory defined by the filtration at any index `i` is less than or equal to `m`. In mathematical terms, if `f` represents a filtration of sigma algebras or measurable subsets of a set `Ω` indexed by a preordered set `ι`, then the sigma algebra at any index `i` is a sub sigma algebra of `m`.

For any preordered type `ι`, type `Ω` with a measurable structure `m`, and filtration `f` on `m` indexed by `ι`, the sigma algebra in `f` at any index `i` is a sub-σ-algebra of `m`.


theorem Nat.add_assoc : ∀ (n m k : ℕ), n + m + k = n + (m + k) := by sorry

This theorem, `Nat.add_assoc`, states that for all natural numbers `n`, `m`, and `k`, the operation of addition is associative. In mathematical terms, it states that `(n + m) + k` is equal to `n + (m + k)`. This means that the grouping of addends does not affect the sum.

For all natural numbers `n`, `m`, and `k`, `(n + m) + k = n + (m + k)`.


theorem Mathlib.Data.Subtype._auxLemma.2 :
    ∀ {α : Sort u_1} {p : α → Prop} {q : { a // p a } → Prop},
      (∃ x, q x) = ∃ a, ∃ (b : p a), q { val := a, property := b } :=
  by sorry

This theorem is stating that for any type `α`, and any predicates `p` over `α` and `q` over the subtype `{ a // p a }`, the statement "there exists an element in the subtype such that `q` holds" is equivalent to "there exists an element `a` in the type `α` such that `p` holds for `a`, and `q` holds for the subtype element composed of `a` and the proof `b` that `p a` is true". In other words, it shows the equivalence between existential quantification over subtypes and existential quantification over the original types with corresponding predicates.

For any type `α`, predicate `p` over `α`, and predicate `q` over the subtype `{ a // p a },` the existence of an element in the subtype satisfying `q` is equivalent to the existence of an element in `α` satisfying `p` and the corresponding subtype element with proof `p a` satisfying `q`.


Primrec.const

theorem Primrec.const :
    ∀ {α : Type u_1} {σ : Type u_3} [inst : Primcodable α] [inst_1 : Primcodable σ] (x : σ), Primrec fun x_1 => x := by
  sorry

The theorem `Primrec.const` states that for any types `α` and `σ` that are encodable (as indicated by `Primcodable α` and `Primcodable σ`), and any constant `x` of type `σ`, the function that maps every element of type `α` to the constant `x` is primitive recursive. In other words, if we can encode the types `α` and `σ` as natural numbers, then a function that always returns a fixed value regardless of its input is considered primitive recursive.

For types `α` and `σ` that are encodable as natural numbers and any constant `x` of type `σ`, the function that maps every `α` to `x` is primitive recursive.


Polynomial.Monic.leadingCoeff

theorem Polynomial.Monic.leadingCoeff :
    ∀ {R : Type u} [inst : Semiring R] {p : Polynomial R}, Polynomial.Monic p → Polynomial.leadingCoeff p = 1 := by
  sorry

The theorem `Polynomial.Monic.leadingCoeff` states that for any semiring `R` and any polynomial `p` over `R`, if `p` is monic (that is, its leading coefficient is 1), then the leading coefficient of `p` equals 1. In other words, for a monic polynomial, the coefficient of the term of the polynomial with the highest power of `X` is always 1.

If `p` is a monic polynomial over semiring `R`, then the leading coefficient of `p` is equal to 1.


theorem max_le : ∀ {α : Type u} [inst : LinearOrder α] {a b c : α}, a ≤ c → b ≤ c → max a b ≤ c := by sorry

This is a theorem about the maximum operation in a Linear Ordered set. It states that for any type `α` equipped with a linear order, given any three elements `a`, `b`, and `c` of type `α`, if `a` is less than or equal to `c` and `b` is less than or equal to `c`, then the maximum of `a` and `b` is less than or equal to `c`. In the language of mathematics, this would be expressed as $\forall a, b, c \in \alpha . (a \leq c \land b \leq c) \Rightarrow max(a, b) \leq c$.

For any linear order `α`, if `a` and `b` are both less than or equal to `c` in `α`, then `max(a, b)` is less than or equal to `c`.


theorem Nat.le_add_left : ∀ (n m : ℕ), n ≤ m + n := by sorry

This theorem states that for any two natural numbers `n` and `m`, `n` is less than or equal to the sum of `m` and `n`. In other words, if you have any natural number `n`, adding any other natural number `m` to it either retains the value if `m` is zero or increases the value if `m` is positive.

For all natural numbers n and m, n ≤ m + n.


Algebra.commutes

/-- `mul_comm` for `Algebra`s when one element is from the base ring.  -/
theorem Algebra.commutes :
    ∀ {R : Type u} {A : Type w} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A] (r : R) (x : A),
      (algebraMap R A) r * x = x * (algebraMap R A) r :=
  by sorry

This theorem, called `Algebra.commutes`, states that for any commutative semiring `R`, semiring `A`, and `Algebra` structure between them, multiplication is commutative when one of the elements is from the base ring `R`. More specifically, for any element `r` from `R` and `x` from `A`, the product of the algebra map of `r` and `x` is the same as the product of `x` and the algebra map of `r`. In mathematical terms, this can be written as `(algebraMap R A) r * x = x * (algebraMap R A) r`.

For any commutative semiring `R`, semiring `A` with an algebra structure over `R`, and elements `r in R` and `x in A`, the algebra product `(algebraMap R A) r * x` equals the algebra product `x * (algebraMap R A) r`.


theorem Mathlib.Data.Finset.Image._auxLemma.1 :
    ∀ {α : Type u_1} {β : Type u_2} {f : α ↪ β} {s : Finset α} {b : β}, (b ∈ Finset.map f s) = ∃ a ∈ s, f a = b := by
  sorry

This theorem states that for all types α and β, for any embedding `f` from α to β, for any finite set `s` of type α, and for any element `b` of type β, `b` is in the image of `s` under `f` if and only if there exists an element `a` in `s` such that `f a` equals `b`. In other words, an element is in the image of a set under a function if and only if it is the image of some element from the original set under the function.

For any functions between types and any sets and elements, an element is in the image of the set under the function if and only if there exists an element from the set whose image under the function is that element.


List.Perm.symm

theorem List.Perm.symm : ∀ {α : Type u_1} {l₁ l₂ : List α}, List.Perm l₁ l₂ → List.Perm l₂ l₁ := by sorry

This theorem states that, for any type `α` and any two lists `l₁` and `l₂` of type `α`, if `l₁` is a permutation of `l₂`, then `l₂` is also a permutation of `l₁`. In other words, the permutation relation between two lists is symmetric.

For any type `α` and lists `l₁` and `l₂` of type `α`, if `l₁` is a permutation of `l₂`, then `l₂` is a permutation of `l₁`.


/-- **Alias** of `zero_lt_one`.

---

See `zero_lt_one'` for a version with the type explicit.  -/
theorem one_pos :
    ∀ {α : Type u_1} [inst : Zero α] [inst_1 : One α] [inst_2 : PartialOrder α] [inst_3 : ZeroLEOneClass α]
      [inst_4 : NeZero 1], 0 < 1 :=
  by sorry

The theorem `one_pos` states that, for any type `α` that has zero and one elements, and is a partial order where zero is less than or equal to one, and one is not zero, then zero is strictly less than one. This is an alias of the theorem `zero_lt_one`. See `zero_lt_one'` for a version with the type explicit.

If `α` is a type with zero and one, is a partial order where zero is less than or equal to one, and one is not zero, then zero is strictly less than one.


/-- **Alias** of the forward direction of `Set.nonempty_iff_ne_empty`.

---

See also `Set.not_nonempty_iff_eq_empty`.  -/
theorem Set.Nonempty.ne_empty : ∀ {α : Type u} {s : Set α}, Set.Nonempty s → s ≠ ∅ := by sorry

This theorem, referred to as `Set.Nonempty.ne_empty`, states that for any type `α` and any set `s` of that type, if the set `s` is nonempty, then it must be unequal to the empty set. In other words, it establishes the forward direction of the equivalence between a set being nonempty and it not being the empty set. This theorem is particularly useful in proofs where the non-emptiness of a set directly implies certain properties or outcomes.

If a set is nonempty, then it is not equal to the empty set.


theorem smul_sub :
    ∀ {M : Type u_1} {A : Type u_4} [inst : Monoid M] [inst_1 : AddGroup A] [inst_2 : DistribMulAction M A] (r : M)
      (x y : A), r • (x - y) = r • x - r • y :=
  by sorry

This theorem, `smul_sub`, states that for any types `M` and `A`, where `M` is a monoid, `A` is an add group, and there exists a distributive multiplication action of `M` on `A`, for any element `r` of `M` and any elements `x` and `y` of `A`, the scalar multiplication of `r` with the difference of `x` and `y` is equal to the difference of the scalar multiplication of `r` with `x` and the scalar multiplication of `r` with `y`. In mathematical terms, we can say $r * (x - y) = r * x - r * y$.

For any monoid `M`, add group `A`, and distributive `M`-action on `A`, for all `r` in `M` and `x`, `y` in `A`, we have `r * (x - y) = r * x - r * y`.


theorem inv_eq_one_div : ∀ {G : Type u_3} [inst : DivInvMonoid G] (x : G), x⁻¹ = 1 / x := by sorry

This theorem states that for any given type `G` that is a division and inversion monoid, the inverse of any element `x` of this type is equal to the value obtained when `1` is divided by `x`. In other words, in the context of this specific type, the operation of finding an inverse and the operation of dividing `1` by an element are equivalent.

For any type `G` being a division and inversion monoid, the inverse of an element `x` is equal to `1 / x`.


theorem Finset.prod_const :
    ∀ {α : Type u_3} {β : Type u_4} {s : Finset α} [inst : CommMonoid β] (b : β),
      (Finset.prod s fun _x => b) = b ^ s.card :=
  by sorry

The theorem `Finset.prod_const` states that for any finite set `s` of a certain type `α`, and for any element `b` of a type `β` that forms a commutative monoid, the product of the constant function `b` as `x` ranges over all the elements of the set `s` equals `b` to the power of the size of the set `s`. In mathematical terms, this is expressing that the product over a set of a constant equals that constant raised to the size of the set:  $\prod_{x \in s} b = b^{|s|}$ where |s| denotes the size or cardinality of the set `s`.

For any finite set `s` and commutative monoid element `b`, the product of `b` over `s` equals `b` raised to the power of `s`'s size: `∏(x : s) b = b^( card s)`.


theorem Int.add_one_le_iff : ∀ {a b : ℤ}, a + 1 ≤ b ↔ a < b := by sorry

This theorem, `Int.add_one_le_iff`, is a law about integers in Lean 4. It states that for any two integers `a` and `b`, the statement "`a + 1` is less than or equal to `b`" is equivalent to the statement "`a` is less than `b`". In other words, adding one to `a` and checking if the result is less than or equal to `b` is the same as directly comparing `a` with `b` in terms of less than relation.

For integers `a` and `b`, `a + 1 ≤ b` if and only if `a < b`.


theorem if_true : ∀ {α : Sort u_1} {h : Decidable True} (t e : α), (if True then t else e) = t := by sorry

This theorem, `if_true`, states that for any type `α` and any two elements `t` and `e` of that type, the result of an `if` expression that is always `True` is equal to `t`. In other words, given a decision on the truth value (`True` in this case), the ternary `if` expression will always yield the `then` branch, regardless of what the `else` branch contains.

For any type `α` and elements `t, e : α`, if `if h : True then t else e` is well-defined, then `if h then t else e = t`.


theorem div_mul_eq_mul_div : ∀ {α : Type u_1} [inst : DivisionCommMonoid α] (a b c : α), a / b * c = a * c / b := by
  sorry

This theorem states that for any type `α` that forms a commutative division monoid (which is a mathematical structure with operations of multiplication and division where multiplication is commutative), for any three elements `a`, `b`, and `c` of this type, the value obtained by dividing `a` by `b` and then multiplying the result by `c` is the same as the value obtained by multiplying `a` by `c` and then dividing the result by `b`. This property corresponds to the algebraic rule (a/b) * c = a * c / b.

For any commutative division monoid type `α` and elements `a, b, c` of `α`, the expression `(a / b) * c` equals `(a * c) / b`.


theorem Finset.card_singleton : ∀ {α : Type u_1} (a : α), {a}.card = 1 := by sorry

This theorem states that for any given type `α` and any element `a` of type `α`, the cardinality of the set or "finset" containing only `a` is equal to 1. In other words, the number of elements in a singleton set (a set containing just one element) is always one, regardless of what that element is.

For any type `α` and any element `a` of type `α`, the cardinality of the singleton set `{a}` is equal to 1.


theorem AEMeasurable.ae_eq_mk :
    ∀ {α : Type u_1} {β : Type u_2} {m : MeasurableSpace α} [inst : MeasurableSpace β] {f : α → β}
      {μ : MeasureTheory.Measure α} (h : AEMeasurable f μ), f =ᶠ[MeasureTheory.Measure.ae μ] AEMeasurable.mk f h :=
  by sorry

The theorem `AEMeasurable.ae_eq_mk` states that for any types `α` and `β`, given a measurable space `α`, and `β` with a measurable space instance, and any function `f` from `α` to `β`, and a measure `μ` on `α`, if `f` is an almost everywhere measurable function, then `f` is equal almost everywhere (according to the measure `μ`) to a corresponding measurable function obtained from `AEMeasurable.mk f h`, where `h` is the proof that `f` is almost everywhere measurable. In other words, a function that is almost everywhere measurable is equivalent to a measurable function on almost all of the domain.

If `f` is an almost everywhere measurable function from the measurable space `(α, Σ, μ)` to `(β, Σ', ν)`, then there exists a measurable function `g : α → β` such that `μ({x : α | f x ≠ g x}) = 0`.


Dvd.intro

theorem Dvd.intro : ∀ {α : Type u_1} [inst : Semigroup α] {a b : α} (c : α), a * c = b → a ∣ b := by sorry

This theorem, `Dvd.intro`, states that for any type `α` that forms a semigroup, given elements `a`, `b`, and `c` of type `α`, if the product of `a` and `c` equals `b` then `a` divides `b`. In mathematical terms, if $a \cdot c = b$, then $a$ is a divisor of $b$.

If `α` is a semigroup and `a`, `b`, `c` are elements of `α` such that `a * c = b`, then `a` divides `b`.


theorem List.reverse_reverse : ∀ {α : Type u} (as : List α), List.reverse (List.reverse as) = as := by sorry

This theorem states that for all types α and for any list of type α, the double reverse of the list equals the original list. In other words, if you reverse a list twice, you will get back the original list. This property is akin to the mathematical principle that the double negation of a statement is equivalent to the original statement.

For all types α and lists l of length n over α, the reversed list (reverse (reverse l)) equals the original list l.


theorem Algebra.subset_adjoin :
    ∀ {R : Type uR} {A : Type uA} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A] {s : Set A},
      s ⊆ ↑(Algebra.adjoin R s) :=
  by sorry

The theorem `Algebra.subset_adjoin` states that for any commutative semiring `R` and any semiring `A` with an algebra structure over `R`, and any set `s` of elements from `A`, the set `s` is a subset of the subalgebra `adjoin R s`. In other words, this theorem states that the subalgebra generated by adjoining the elements of `s` to `R` includes all elements of `s`.

For any commutative semiring R and an algebra structure over R on semiring A, the set of elements from A that can be expressed as polynomials in s (a subset of A) over R is equal to the subalgebra of A generated by s.


HasStrictDerivAt.hasDerivAt

theorem HasStrictDerivAt.hasDerivAt :
    ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {F : Type v} [inst_1 : NormedAddCommGroup F]
      [inst_2 : NormedSpace 𝕜 F] {f : 𝕜 → F} {f' : F} {x : 𝕜}, HasStrictDerivAt f f' x → HasDerivAt f f' x :=
  by sorry

This theorem states that for any nontrivially normed field 𝕜, normed add commutative group F, and 𝕜-valued function f, if f has a strict derivative of f' at the point x (meaning that `f y - f z = (y - z) • f' + o(y - z)` as `y, z → x`), then f also has a derivative of f' at the point x (meaning that `f x' = f x + (x' - x) • f' + o(x' - x)` where `x'` converges to `x`). In other words, the condition of having a strict derivative at a point implies the condition of having a derivative at that point.

If a nontrivially normed field functions from a normed additive group to the field with a strict derivative at a point, then the function has a derivative at that point.


Filter.Eventually.and

theorem Filter.Eventually.and :
    ∀ {α : Type u} {p q : α → Prop} {f : Filter α},
      Filter.Eventually p f → Filter.Eventually q f → ∀ᶠ (x : α) in f, p x ∧ q x :=
  by sorry

The theorem `Filter.Eventually.and` states that for any type `α`, any two properties `p` and `q` of `α`, and any filter `f` of `α`, if `p` holds eventually in `f` (meaning the set of `α` for which `p` is true belongs to `f`) and `q` also holds eventually in `f`, then there exists a point in the filter `f` beyond which both `p` and `q` hold true. In other words, it is saying that the conjunction of two properties (both `p` and `q` being true) also holds eventually in the filter `f`.

If filters `f` contain sets of elements on which properties `p` and `q` hold eventually, then there exists an element in `f` where both `p` and `q` hold true.


theorem Mathlib.Order.BoundedOrder._auxLemma.9 :
    ∀ {α : Type u} [inst : LE α] [inst_1 : OrderBot α] {a : α}, (⊥ ≤ a) = True := by sorry

This theorem, named `Mathlib.Order.BoundedOrder._auxLemma.9`, states that for any type `α` equipped with a less-than-or-equal-to (`LE`) relation and a bottom element (`OrderBot`), for any element `a` of type `α`, the statement that the bottom element is less than or equal to `a` is always true. This means that in the given order, every element is greater than or equal to the bottom element.

For any type `α` with a `LE` relation and a bottom element `OrderBot`, `OrderBot ≤ a` holds for all `a : α`.


theorem Mathlib.Data.Prod.Basic._auxLemma.2 :
    ∀ {α : Type u_1} {β : Type u_2} {p : α × β → Prop}, (∃ x, p x) = ∃ a b, p (a, b) := by sorry

This theorem states that for any types `α` and `β`, and any property `p` pertaining to an ordered pair of elements from `α` and `β`, the assertion that there exists an ordered pair satisfying property `p` is logically equivalent to the assertion that there exist elements `a` from `α` and `b` from `β` such that the ordered pair `(a, b)` satisfies property `p`. In other words, it formalizes the intuitive idea that saying "there exists a pair which has property `p`" is the same as saying "there exists an `a` and a `b` such that the pair `(a, b)` has property `p`".

For any types `α` and `β` and property `p` on ordered pairs of `α × β`, the existence of an ordered pair in `α × β` satisfying `p` is equivalent to the existence of elements `a` from `α` and `b` from `β` such that `(a, b)` satisfies `p`.


theorem Finsupp.single_eq_same :
    ∀ {α : Type u_1} {M : Type u_5} [inst : Zero M] {a : α} {b : M}, (fun₀ | a => b) a = b := by sorry

The theorem `Finsupp.single_eq_same` asserts that for any types `α` and `M`, given a zero instance for `M`, and any elements `a` of type `α` and `b` of type `M`, the function `fun₀` that maps `a` to `b` when applied to `a` gives `b`. In other words, this theorem proves that a function mapping a single element to another element will return that second element when applied to the first.

For any type `α` and type `M` with a zero instance, the function mapping a single element `a` of type `α` to an element `b` of type `M` equals `b`.


theorem Mathlib.Algebra.Group.Units._auxLemma.26 :
    ∀ {α : Type u} [inst : AddCommMonoid α] [inst_1 : Subsingleton (AddUnits α)] {a b : α},
      (a + b = 0) = (a = 0 ∧ b = 0) :=
  by sorry

This theorem, `Mathlib.Algebra.Group.Units._auxLemma.26`, states that for any type `α` that is an additive commutative monoid (i.e., it supports addition operation that is both commutative and associative, and it has a zero element that acts as an identity for addition) and where `AddUnits α` is a subsingleton (i.e., it contains at most one element), for any two elements `a` and `b` of `α`, the condition `a + b = 0` is equivalent to both `a = 0` and `b = 0`. In simpler terms, if `a` and `b` sum up to zero, then both `a` and `b` must individually be zero.

For any additive commutative monoid `α` with a subsingleton set of additive units, the equality of any two elements `a` and `b` to the additive identity implies both `a` and `b` are the additive identity.


theorem isOpen_compl_iff : ∀ {X : Type u} {s : Set X} [inst : TopologicalSpace X], IsOpen sᶜ ↔ IsClosed s := by sorry

This theorem, `isOpen_compl_iff`, establishes a relationship between open and closed sets in a given topological space `X`. Specifically, it states that for any set `s` of type `X`, the set `s` is closed if and only if the complement of `s` (denoted as `sᶜ`) is open in the topology of `X`. This is a fundamental property in topology connecting the concepts of open and closed sets.

A set in a topological space is closed if and only if its complement is open.


theorem pow_nonneg : ∀ {α : Type u} [inst : OrderedSemiring α] {a : α}, 0 ≤ a → ∀ (n : ℕ), 0 ≤ a ^ n := by sorry

This theorem states that for any ordered semiring `α`, any non-negative element `a` of `α`, and any natural number `n`, the `n`th power of `a` is also non-negative. In other words, it generalizes the familiar fact from arithmetic that the product of any number of non-negative numbers is itself non-negative. It is valid in any context where a semiring structure is assumed, which includes many structures in abstract algebra and number theory.

For any ordered semiring `α` and non-negative element `a` in `α`, the `n`th power `a^n` is also non-negative.


theorem le_sSup : ∀ {α : Type u_1} [inst : CompleteSemilatticeSup α] {s : Set α} {a : α}, a ∈ s → a ≤ sSup s := by sorry

This theorem states that for any type `α` that forms a complete semilattice with a supremum and for any set `s` of elements of type `α`, any element `a` of `s` is less than or equal to the supremum of `s`. In other words, if `a` belongs to the set `s`, then `a` is always less than or equal to the least upper bound (also known as supremum) of the set `s`.

For any complete semilattice `α` with supremum and any set `s` of elements in `α`, every element `a` in `s` satisfies `a <= sup s`.


theorem Mathlib.Data.Multiset.Basic._auxLemma.5 : ∀ {α : Type u_1} {a : α} {l : List α}, (a ∈ ↑l) = (a ∈ l) := by sorry

This theorem states that for any type `α`, any element `a` of type `α`, and any list `l` of elements of type `α`, the predicate stating that `a` is in the `l` when `l` is coerced (or "upcast") to a multiset is equivalent to the predicate stating that `a` is in the `l` as a list. In other words, an element is in a list if and only if it is in the multiset obtained from the list.

For any type `α`, any element `a` of type `α`, and any list `l` of elements of type `α`, `a` is in the multiset obtained from list `l` if and only if `a` is in list `l` as a regular list element.


/-- Note that the `SMulCommClass α β β` typeclass argument is usually satisfied by `Algebra α β`.
 -/
theorem mul_smul_comm :
    ∀ {α : Type u_6} {β : Type u_7} [inst : Mul β] [inst_1 : SMul α β] [inst_2 : SMulCommClass α β β] (s : α) (x y : β),
      x * s • y = s • (x * y) :=
  by sorry

This theorem, named `mul_smul_comm`, states that for all types `α` and `β`, where `β` has a multiplication operation, `α` can be scalar multiplied with `β`, and the scalar multiplication is commutative, then the multiplication of `β` and scalar multiplication of `α` and `β` are communicative. In mathematical terms, it asserts that for any scalar `s` and elements `x` and `y` of `β`, the equation `x * s • y = s • (x * y)` holds true. An algebra over `α` on `β` typically satisfies the scalar multiplication commutativity required in this theorem.

For all types `α` and `β` with a commutative scalar multiplication, and for all scalars `s` and elements `x` and `y` of `β`, `x * s * y = s * (x * y)`.