theorem Real.exp_pos : ∀ (x : ℝ), 0 < Real.exp x := by sorry

This theorem states that the real exponential function is always positive. In other words, for any real number `x`, the exponential of `x` (denoted as `exp(x)`) is strictly greater than zero. This is consistent with the mathematical property of the exponential function, which is always above the x-axis, never touching or crossing it.


theorem add_lt_of_neg_of_le :
    ∀ {α : Type u_1} [inst : AddZeroClass α] [inst_1 : Preorder α]
      [inst_2 : CovariantClass α α (Function.swap fun x x_1 => x + x_1) fun x x_1 => x < x_1] {a b c : α},
      a < 0 → b ≤ c → a + b < c :=
  by sorry

The theorem `add_lt_of_neg_of_le` states that for all types `α` that are an instance of the `AddZeroClass`, `Preorder`, and have a `CovariantClass` with the specified properties, if a number `a` is less than zero and another number `b` is less than or equal to `c`, then the sum of `a` and `b` is less than `c`. The `CovariantClass` condition ensures that the addition operation respects the ordering `<` on the type `α`.

For all types `α` with `AddZeroClass`, `Preorder`, and covariant additions, if `a < 0` and `b <= c`, then `a + b < c`.


theorem measurable_fst :
    ∀ {α : Type u_1} {β : Type u_2} {x : MeasurableSpace α} {x_1 : MeasurableSpace β}, Measurable Prod.fst := by sorry

The theorem `measurable_fst` states that for any types `α` and `β` and any measurable spaces over `α` and `β`, the first projection function, `Prod.fst`, is measurable. In mathematical terms, this means that for any measurable set in `α`, its preimage under the `Prod.fst` function (which projects an element of the product space `α × β` to `α`) is also a measurable set.

The first projection function `Prod.fst` of a product space is measurable, that is, for any measurable set in the first factor space, its preimage under `Prod.fst` is also measurable.


theorem measurable_id : ∀ {α : Type u_1} {x : MeasurableSpace α}, Measurable id := by sorry

The theorem `measurable_id` states that the identity function is measurable for all measurable spaces. In more formal terms, given any type `α` and a measurable space `x` over that type, the identity function (which maps each element of the space to itself) is a measurable function. This is defined as: for any measurable set in the codomain, its preimage under the identity function is also a measurable set.

The identity function is measurable with respect to any measurable space.


theorem Filter.univ_mem : ∀ {α : Type u} {f : Filter α}, Set.univ ∈ f := by sorry

The theorem `Filter.univ_mem` asserts that for any type `α` and any filter `f` on `α`, the universal set of `α` is an element of `f`. In other words, it states that the universal set, which contains all elements of a given type, is part of any filter defined on that type. In set theoretic terms, if we consider `f` as a collection of subsets of `α`, this theorem is equivalent to stating that the whole set `α` is one of those subsets.

For any type `α` and filter `f` on `α`, the universal set of `α` belongs to `f`.


theorem forall₂_congr :
    ∀ {α : Sort u_1} {β : α → Sort u_2} {p q : (a : α) → β a → Prop},
      (∀ (a : α) (b : β a), p a b ↔ q a b) → ((∀ (a : α) (b : β a), p a b) ↔ ∀ (a : α) (b : β a), q a b) :=
  by sorry

The theorem `forall₂_congr` states that for any two types `α` and `β` (where `β` is a function of `α`), given any two properties `p` and `q` that are related to `α` and `β`, if for all `a` in `α` and `b` in `β`, `p a b` is equivalent to `q a b`, then the proposition that `p a b` holds for all `a` and `b` is equivalent to the proposition that `q a b` holds for all `a` and `b`. In essence, this theorem establishes the equivalence of two universal quantifications given the equivalence of their predicates.

If for all `a` in `α` and `b` in `β`, `p(a, b)` is equivalent to `q(a, b)`, then `∀(a : α) ∀(b : β), p(a, b)` is equivalent to `∀(a : α) ∀(b : β), q(a, b)`.


theorem lt_trichotomy : ∀ {α : Type u} [inst : LinearOrder α] (a b : α), a < b ∨ a = b ∨ b < a := by sorry

This theorem, named `lt_trichotomy`, describes a basic property of linearly ordered types in Lean 4. Given any two elements `a` and `b` of a type `α` that is linearly ordered (as specified by the `LinearOrder α` typeclass), one and only one of the following holds: `a` is less than `b`, `a` is equal to `b`, or `b` is less than `a`. This property is a key part of the definition of a linear (or total) order, and is a form of the law of trichotomy for ordered sets.

For all linearly ordered types `α` and elements `a` and `b` in `α`, exactly one of `a < b`, `a = b`, or `b < a` holds.


theorem le_of_not_gt : ∀ {α : Type u} [inst : LinearOrder α] {a b : α}, ¬a > b → a ≤ b := by sorry

This theorem states that for all types `α` that have a `LinearOrder` instance, if a specific condition holds true where a given element `a` of type `α` is not greater than another element `b` of type `α`, it follows that `a` is less than or equal to `b`. In mathematical terms, this can be expressed as "for all `a` and `b` in a set with a linear order, if `a` is not greater than `b`, then `a` must be less than or equal to `b`".

For all types `α` with a `LinearOrder` instance, if `a ≤ b` then `a ≤ b` holds. (In other words, the reflexive transitivity of the linear order relation holds.)


Continuous.mul

theorem Continuous.mul :
    ∀ {M : Type u_3} {X : Type u_5} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace M] [inst_2 : Mul M]
      [inst_3 : ContinuousMul M] {f g : X → M}, Continuous f → Continuous g → Continuous fun x => f x * g x :=
  by sorry

This theorem states that for any types `M` and `X`, given that `M` has multiplication defined and is equipped with a topology that makes the multiplication operation continuous, and `X` is also a topological space, if `f` and `g` are both continuous functions from `X` to `M`, then the function that takes an element of `X` and returns the product of `f` and `g` evaluated at that element is also continuous. In other words, the multiplication of two continuous functions is again a continuous function.

If `M` is a topological space with continuous multiplication and `X` is also a topological space, then the product of two continuous functions from `X` to `M` is a continuous function.


theorem Nat.eq_zero_or_pos : ∀ (n : ℕ), n = 0 ∨ n > 0 := by sorry

This theorem states that for every natural number `n`, `n` is either equal to zero or greater than zero. In other words, it asserts that any natural number is either zero or a positive integer. This is a fundamental property of natural numbers in the standard mathematical system.

Every natural number is non-negative. (Or, every natural number is greater than or equal to zero.)


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

This theorem, `min_eq_left`, states that for any type `α` which has a linear order, and for any two instances `a` and `b` of this type, if `a` is less than or equal to `b`, then the minimum of `a` and `b` is `a`. In other words, if `a` is not greater than `b`, it is the minimum of the two.

For any type with a linear order, the minimum of two elements is the first if they are comparable and equal.


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

The theorem `Finset.sum_insert` states that for any type `α` and `β`, a finite set `s` of type `α`, an element `a` of type `α`, and a function `f` mapping `α` to `β`, given an additive commutative monoid structure on `β` and a decidable equality on `α`, if `a` is not an element of `s`, then the sum of the function `f` over the elements of the set obtained by inserting `a` into `s` is equal to `f(a)` plus the sum of `f` over the elements of `s`. In other words, inserting an element into a finite set and then summing a function over the elements of the set is the same as summing the function over the original set and then adding the function applied to the inserted element.

For any additive commutative monoid `β` with decidable equality, and given a finite set `s` of type `α`, an element `a` not in `s`, and a function `f` from `α` to `β`, we have `Sum(f, s ++ {a}) = Sum(f, s) + f a`.


theorem lt_trans : ∀ {α : Type u} [inst : Preorder α] {a b c : α}, a < b → b < c → a < c := by sorry

This theorem, `lt_trans`, is a statement about transitivity in the setting of preorders. Given any type `α` that has a preorder structure, for any three elements `a`, `b`, and `c` of that type, if `a` is less than `b` and `b` is less than `c`, then it follows that `a` is less than `c`. This is essentially a formalization of the transitivity property of inequalities in mathematics.

If `α` is a preordered type and `a ≤ b` and `b ≤ c`, then `a ≤ c`.


theorem Nat.le_add_right : ∀ (n k : ℕ), n ≤ n + k := by sorry

This theorem states that for all natural numbers `n` and `k`, `n` is less than or equal to `n + k`. In mathematical terms, this theorem confirms that adding any natural number to another natural number results in a number that is either greater than or equal to the original number. It's an important foundational aspect of number theory and arithmetic.

For all natural numbers `n` and `k`, `n ≤ n + k`.


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

This theorem, named `sub_nonneg`, states that for any type `α` that forms an additive group and has a less than or equal to (`≤`) operation, with a specific covariance property, the difference `a - b` (where `a` and `b` are elements of `α`) is nonnegative (i.e., `0 ≤ a - b`) if and only if `b` is less than or equal to `a` (i.e., `b ≤ a`). This covariance property is expressed by the `Function.swap fun x x_1 => x + x_1` and `fun x x_1 => x ≤ x_1` terms: it requires that swapping the order of the inputs to the addition and the `≤` operator produces the same result. In essence, this theorem formalizes a familiar property from elementary arithmetic: subtracting a smaller number from a larger one yields a nonnegative result.

For any additive group type `α` with covariant `≤` operation, `a - b ≥ 0` if and only if `b ≤ a`.


CategoryTheory.Iso.ext

theorem CategoryTheory.Iso.ext :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} ⦃α β : X ≅ Y⦄, α.hom = β.hom → α = β := by sorry

This theorem states that in any category `C`, for any two objects `X` and `Y` in `C`, if `α` and `β` are two isomorphisms from `X` to `Y`, then if the `hom` (the morphism part of the isomorphism) of `α` is equal to the `hom` of `β`, then the isomorphisms `α` and `β` are equal. In other words, in a category theory context, two isomorphisms are considered the same if they have the same morphism component.

In any category, two isomorphisms between objects have equal morphism components if and only if they are equal as isomorphisms.


theorem List.sum_cons :
    ∀ {M : Type u_5} [inst : AddMonoid M] {l : List M} {a : M}, List.sum (a :: l) = a + List.sum l := by sorry

This theorem states that for any type `M` that is equipped with an additive monoid structure, any list of elements `l` of type `M`, and any element `a` of type `M`, the sum of the list obtained by prepending `a` to `l` is equal to `a` plus the sum of the list `l`. In other words, for a given list and an element, the sum of the new list starting with this element is the same as adding the element to the sum of the original list. This is analogous to the mathematical property of summation that the sum of a list with an additional term at the start is the additional term plus the sum of the original list.

For any additive monoid `M`, any list `l` of elements in `M`, and any element `a` in `M`, the sum of the list `[a] ++ l` equals `a + sum l`, where `++` denotes list concatenation.


Function.Injective.comp

theorem Function.Injective.comp :
    ∀ {α : Sort u₁} {β : Sort u₂} {φ : Sort u₃} {g : β → φ} {f : α → β},
      Function.Injective g → Function.Injective f → Function.Injective (g ∘ f) :=
  by sorry

The theorem `Function.Injective.comp` states that given any three types `α`, `β`, and `φ`, and any two functions `g : β → φ` and `f : α → β`, if `g` and `f` are both injective (i.e., for any two inputs that are equal after applying the function, the inputs must have been equal), then the composition of `g` and `f` (denoted `g ∘ f`), where `f` is applied first and then `g` is applied to the result, is also injective. In other words, the injective property is preserved under function composition.

If functions `f : α → β` and `g : β → φ` are both injective, then their composition `g ∘ f : α → φ` is also injective.


theorem CategoryTheory.Limits.pullback.condition :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z : C} {f : X ⟶ Z} {g : Y ⟶ Z}
      [inst_1 : CategoryTheory.Limits.HasPullback f g],
      CategoryTheory.CategoryStruct.comp CategoryTheory.Limits.pullback.fst f =
        CategoryTheory.CategoryStruct.comp CategoryTheory.Limits.pullback.snd g :=
  by sorry

The `CategoryTheory.Limits.pullback.condition` theorem states that for any category `C` and any objects `X`, `Y`, `Z` in `C` with morphisms `f : X ⟶ Z` and `g : Y ⟶ Z` for which a pullback exists, the composition of the first projection of the pullback of `f` and `g` with `f` is equal to the composition of the second projection of the pullback of `f` and `g` with `g`. This equality encapsulates the universal property that defines the pullback, namely the existence of a unique morphism from `X` to `Y` making the resulting diagram commute.

In any category, for pullback squares of morphisms `f : X ⟶ Z` and `g : Y ⟶ Z`, the composition `p_1 ∘ f = p_2 ∘ g` holds, where `p_1` and `p_2` denote the first and second projections of the pullback respectively.


theorem Set.subset_union_left : ∀ {α : Type u} (s t : Set α), s ⊆ s ∪ t := by sorry

The theorem `Set.subset_union_left` states that for any type `α` and any two sets `s` and `t` of type `α`, the set `s` is a subset of the union of `s` and `t`. This is a fundamental theorem in set theory which asserts that a set is always a subset of the union of itself with any other set. In terms of mathematical notation, this would be written as \(s \subseteq s \cup t\) for all sets `s` and `t`.

For any sets `s` and `t`, `s` is a subset of their union, i.e., `s ⊆ s ∪ t`.


AlgHom.ext

theorem AlgHom.ext :
    ∀ {R : Type u} {A : Type v} {B : Type w} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Semiring B]
      [inst_3 : Algebra R A] [inst_4 : Algebra R B] {φ₁ φ₂ : A →ₐ[R] B}, (∀ (x : A), φ₁ x = φ₂ x) → φ₁ = φ₂ :=
  by sorry

This theorem states that for any commutative semiring `R`, for any semirings `A` and `B`, and given that `A` and `B` are `R`-algebras, if we have two algebra homomorphisms `φ₁` and `φ₂` from `A` to `B`, and for all elements `x` in `A`, `φ₁ x` equals `φ₂ x`, then the two homomorphisms `φ₁` and `φ₂` are identical. In other words, two algebra homomorphisms between the same pair of `R`-algebras are equal if they map every element of the domain to the same element in the codomain.

If `R` is a commutative semiring, `A` and `B` are `R`-algebras, and `φ₁` and `φ₂` are homomorphisms from `A` to `B` such that `φ₁ x = φ₂ x` for all `x` in `A`, then `φ₁ = φ₂`.


theorem CategoryTheory.IsIso.hom_inv_id :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} (f : X ⟶ Y) [I : CategoryTheory.IsIso f],
      CategoryTheory.CategoryStruct.comp f (CategoryTheory.inv f) = CategoryTheory.CategoryStruct.id X :=
  by sorry

This theorem states that for any category `C` and any objects `X` and `Y` in `C`, if a morphism `f` from `X` to `Y` is an isomorphism (i.e., has an inverse), then the composition of `f` and its inverse is the identity morphism on `X`. In mathematical terms, if we have an isomorphism `f: X ⟶ Y`, then `f ∘ f⁻¹ = id_X`, where `f⁻¹` is the inverse of `f` and `id_X` is the identity morphism on `X`.

For any category `C` and objects `X`, `Y` in `C`, if `f : X ⟶ Y` is an isomorphism, then `f ∘ f⁻¹ = id_X`.


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

The theorem `MulOpposite.unop_injective` states that for any type `α`, the function `MulOpposite.unop` is injective. In other words, the function which takes an element from the opposite multiplication type `αᵐᵒᵖ` and returns its underlying element in `α` will always map distinct elements to distinct elements. If two elements in `αᵐᵒᵖ` have the same image in `α` under the `MulOpposite.unop` function, those two elements must have been the same to begin with.

The function `MulOpposite.unop` from `αᵐᵒᵖ` to `α` is an injection.


Filter.Tendsto.eventually

theorem Filter.Tendsto.eventually :
    ∀ {α : Type u} {β : Type v} {f : α → β} {l₁ : Filter α} {l₂ : Filter β} {p : β → Prop},
      Filter.Tendsto f l₁ l₂ → (∀ᶠ (y : β) in l₂, p y) → ∀ᶠ (x : α) in l₁, p (f x) :=
  by sorry

The theorem `Filter.Tendsto.eventually` establishes that if a function `f` from type `α` to `β` tends to a limit and for all `y` in the limit filter `l₂`, a property `p` holds eventually, then for all `x` in the input filter `l₁`, the property `p` holds for `f(x)` eventually. In other words, this theorem asserts that if a function's output approaches a limit and in that limit a certain property is eventually true, then that property is eventually true for the function's output over its input domain.

If a function from `α` to `β` tends to a limit and the property `p` is eventually true for all elements in the limit, then `p` is eventually true for the function's output given any input in the domain.


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

This theorem, `zpow_neg`, states that for any type `α` that forms a division monoid (i.e., a set equipped with an associative binary operation that has an identity element and each element has a unique inverse), and for any element `a` of `α` and an integer `n`, the negative power of `a` to `n` (i.e., `a` raised to the power `-n`) is equal to the inverse of `a` raised to the power `n` (i.e., `(a ^ n)⁻¹`). In mathematical notation, this would be expressed as $a^{-n} = (a^n)^{-1}$.

For any element `a` in a division monoid `α` and integer `n`, `a^(-n) = (a^n)⁻¹`.


/-- If `f` is a monoid homomorphism then `f (a * b) = f a * f b`.  -/
theorem MonoidHom.map_mul :
    ∀ {M : Type u_4} {N : Type u_5} [inst : MulOneClass M] [inst_1 : MulOneClass N] (f : M →* N) (a b : M),
      f (a * b) = f a * f b :=
  by sorry

This theorem states that if `f` is a monoid homomorphism, then the multiplication operation is preserved under `f`. More specifically, for any two elements `a` and `b` from a type `M` that has a multiplication and identity element (a MulOneClass), their multiplication `a * b` mapped by `f` is equal to the multiplication of `f a` and `f b` in another type `N` that also has a multiplication and identity element. This respects one of the key properties of a monoid homomorphism.

If `f` is a monoid homomorphism from a monoid `(M, *_1, id_1)` to another monoid `(N, *_2, id_2)`, then for all `a, b` in `M`, `f(a *_1 b) = f(a) *_2 f(b)`.


/-- **Alias** of `natCast_zsmul`. -/
theorem coe_nat_zsmul : ∀ {G : Type u_1} [inst : SubNegMonoid G] (a : G) (n : ℕ), ↑n • a = n • a := by sorry

This theorem, `coe_nat_zsmul`, is an alias of `natCast_zsmul`. It states that for any given type `G` that is a member of the `SubNegMonoid` class (i.e., the type `G` supports subtraction and unary negation operations), and for any element `a` of that type and any natural number `n`, the scalar multiplication of `a` by the coercion of `n` to `G` (`↑n • a`) is the same as the scalar multiplication of `a` by `n` (`n • a`).

For any type `G` in `SubNegMonoid` and element `a` in `G`, the coercion of a natural number `n` to `G` multiplied by `a` is equal to the scalar multiplication of `a` by `n`. (i.e., `↑n • a = n • a`)


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

The theorem `min_eq_right` states that for all types `α` that have a linear order, and for any two elements `a` and `b` of type `α`, if `b` is less than or equal to `a`, then the minimum of `a` and `b` is `b`. In other words, if `b` is less than or equal to `a`, then `b` is the smaller element.

For all types with a linear order, the minimum of two elements is the smaller one.


theorem le_of_not_lt : ∀ {α : Type u} [inst : LinearOrder α] {a b : α}, ¬b < a → a ≤ b := by sorry

This theorem, `le_of_not_lt`, states that for all types `α` that have a linear order, if it is not the case that `b` is less than `a`, then `a` is less than or equal to `b`. In other words, if `b` is not strictly lesser than `a` in a linearly ordered set, it must be that `a` is either equal to `b` or less than `b`.

If `α` is a linearly ordered type and `a` is not less than `b` in `α`, then `a` is less than or equal to `b`.


theorem Nat.mod_eq_of_lt : ∀ {a b : ℕ}, a < b → a % b = a := by sorry

This theorem states that for any two natural numbers `a` and `b`, if `a` is less than `b`, then the remainder when `a` is divided by `b` is `a` itself. In other words, for any two natural numbers, the modulo operation of the smaller number by the larger number results in the smaller number. This is because the division of a smaller number by a larger number in the set of natural numbers leads to a quotient of zero and a remainder equal to the smaller number.

For all natural numbers `a` and `b` with `a < b`, `a % b = a`.


Function.LeftInverse.injective

theorem Function.LeftInverse.injective :
    ∀ {α : Sort u₁} {β : Sort u₂} {g : β → α} {f : α → β}, Function.LeftInverse g f → Function.Injective f := by sorry

The theorem `Function.LeftInverse.injective` states that for all types `α` and `β`, and for all functions `g : β → α` and `f : α → β`, if `g` is a left inverse to `f` (meaning that for every `x : α`, applying `f` and then `g` gives back `x`), then `f` is injective. An injective function is one where if `f x = f y` then `x` must equal `y`, or in other words, no two different inputs give the same output.

If a function `g : β → α` is a left inverse of `f : α → β`, then `f` is injective. That is, for all `x, y : α`, if `f x = f y` then `x = y`.


Submodule.ext

theorem Submodule.ext :
    ∀ {R : Type u} {M : Type v} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
      {p q : Submodule R M}, (∀ (x : M), x ∈ p ↔ x ∈ q) → p = q :=
  by sorry

The theorem `Submodule.ext` asserts that for any two submodules `p` and `q` of a module `M` over a semiring `R`, if every element `x` of `M` is in `p` if and only if it is in `q`, then `p` and `q` are the same submodule. In other words, two submodules are equal if they contain exactly the same elements.

If two submodules of a module contain the same elements, then they are equal.


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

This theorem, from the Mathlib library in the Order.BoundedOrder section, asserts that for any type `α` which is equipped with a "less than or equal to" (`LE`) operation and a designated "top" element (`OrderTop`), any element `a` of this type is less than or equal to the top element. Essentially, it says that the top element is the greatest element in `α`, and all other elements are less than or equal to it.

For any type `α` with a "less than or equal to" (`LE`) relation and a top element (`OrderTop`), every element `a` in `α` satisfies `a ≤ OrderTop`.


theorem Finset.coe_subset : ∀ {α : Type u_1} {s₁ s₂ : Finset α}, ↑s₁ ⊆ ↑s₂ ↔ s₁ ⊆ s₂ := by sorry

This theorem states that for all types `α` and for all finite sets `s₁` and `s₂` of this type, the coercion of `s₁` is a subset of the coercion of `s₂` if and only if `s₁` is a subset of `s₂`. Coercion here refers to the process of converting one type into another and the `↑` symbol indicates this coercion. The subsets are represented by the `⊆` symbol. This theorem is essentially stating that the subset relationship is preserved under coercion.

For all types `α` and finite sets `s₁` and `s₂` of type `α`, `↑s₁ ⊆ ↑s₂` if and only if `s₁ ⊆ s₂`.


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

This theorem, `neg_add_cancel_right`, states that for any type `G` that has an `AddGroup` structure (i.e., an additive group), for any two elements `a` and `b` from `G`, if we add the negation of `b` to `a` and then add `b`, we get `a` back. In mathematical terms, it states that for all `a` and `b` in the additive group `G`, the equation `a + -b + b = a` holds true. This is a basic property of additive groups, reflecting the fact that adding an element and its negation results in a neutral element of the group (usually denoted as zero), essentially canceling each other out.

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


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

This theorem states that for any semiring `R` and an additively commutative monoid `M` that forms a module over `R`, and for any set `s` of elements of `M`, the set `s` is a subset of the span of `s`. In mathematical terms, this theorem asserts that each element of the set `s` is contained within the smallest submodule of `M` that contains all elements of `s`. This is a fundamental property that defines the concept of a span in the context of module theory.

For any semiring `R`, additively commutative `R`-module `M`, and set `s` of elements in `M`, the span of `s` contains `s`.


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

This theorem states that for any type `G` that forms an additive group, adding any element `a` of type `G` to its additive inverse `-a` results in the additive identity `0`. This is a fundamental property of all additive groups, denoted mathematically as `a + (-a) = 0` for all `a` in the group.

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


theorem eq_of_forall_ge_iff : ∀ {α : Type u} [inst : PartialOrder α] {a b : α}, (∀ (c : α), a ≤ c ↔ b ≤ c) → a = b := by
  sorry

This theorem states that for any type `α` that has a partial order, given any two elements `a` and `b` of `α`, if for every element `c` of `α`, `a` is less than or equal to `c` if and only if `b` is less than or equal to `c`, then `a` must equal `b`. In other words, if `a` and `b` have identical relationships of being less than or equal to every other element in the set, then `a` and `b` must be equal.

If `α` is a type with a partial order such that `a ≤ c` if and only if `b ≤ c` for all `c` in `α`, then `a = b`.


Polynomial.ext

theorem Polynomial.ext :
    ∀ {R : Type u} [inst : Semiring R] {p q : Polynomial R},
      (∀ (n : ℕ), Polynomial.coeff p n = Polynomial.coeff q n) → p = q :=
  by sorry

The theorem `Polynomial.ext` asserts that for any type `R` that is a semiring and any two polynomials `p` and `q` over this semiring, if the coefficient of `X^n` in `p` is equal to the coefficient of `X^n` in `q` for every natural number `n`, then the polynomials `p` and `q` are identical. In other words, two polynomials are the same if and only if they have the same coefficients for each degree in the natural numbers.

Given semirings R and polynomials p and q over R, if for all natural numbers n, the coefficients of X^n in p and q are equal, then p and q are identical.


theorem Set.image_singleton : ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {a : α}, f '' {a} = {f a} := by sorry

This theorem states that for any types `α` and `β` and any function `f` from `α` to `β`, the image under `f` of the singleton set containing only an element `a` from `α` is the singleton set containing only the image of `a` under `f`. In other words, this theorem connects the concepts of function application and set image by showing that applying a function to a single element is the same as finding the image of a singleton set under that function.

For any types `α` and `β` and function `f` from `α` to `β`, the image of the singleton set {`a`} under `f` is the set {`f a`}.


theorem List.map_map :
    ∀ {β : Type u_1} {γ : Type u_2} {α : Type u_3} (g : β → γ) (f : α → β) (l : List α),
      List.map g (List.map f l) = List.map (g ∘ f) l :=
  by sorry

The theorem `List.map_map` states that for any list `l` of elements of some type `α`, and any two functions `f : α → β` and `g : β → γ`, applying `f` to each element in `l` using `List.map` and then applying `g` to the result using `List.map` is equivalent to applying the function `g ∘ f` to each element in `l` using `List.map`. This is an example of function composition in the context of lists.

For any lists `l` of elements from type `α`, and functions `f : α → β` and `g : β → γ`, `List.map (g ∘ f) l` is equivalent to `(List.map g (List.map f l))`.


theorem Nat.mul_comm : ∀ (n m : ℕ), n * m = m * n := by sorry

This theorem, `Nat.mul_comm`, states that for all natural numbers `n` and `m`, the multiplication of `n` and `m` is commutative. In other words, the order in which the numbers are multiplied does not change the result, so `n * m` is equal to `m * n`.

For all natural numbers `n` and `m`, `n * m` equals `m * n`.


theorem isEmpty_or_nonempty : ∀ (α : Sort u_1), IsEmpty α ∨ Nonempty α := by sorry

This theorem, named `isEmpty_or_nonempty`, states that for any sort (a type or a proposition) `α`, `α` is either `IsEmpty` (i.e., it has no elements) or `Nonempty` (i.e., it has at least one element). In other words, a given type or proposition cannot simultaneously be empty and nonempty.

For any type or proposition `α`, `α` is either empty or nonempty.


RingHom.injective

theorem RingHom.injective :
    ∀ {α : Type u_1} {β : Type u_2} [inst : DivisionRing α] [inst_1 : Semiring β] [inst_2 : Nontrivial β] (f : α →+* β),
      Function.Injective ⇑f :=
  by sorry

The theorem `RingHom.injective` states that for any two types `α` and `β`, if `α` is a division ring (a type of algebraic structure), `β` is a semiring (another type of algebraic structure), and `β` is non-trivial (i.e., it contains at least two distinct elements), then any ring homomorphism `f` from `α` to `β` is injective. In other words, if `f a1` and `f a2` are equal for some elements `a1` and `a2` in `α`, then `a1` and `a2` must be the same element.

If `α` is a division ring and `β` is a non-trivial semiring, then every ring homomorphism from `α` to `β` is injective.


theorem Nat.succ_le_of_lt : ∀ {n m : ℕ}, n < m → Nat.succ n ≤ m := by sorry

This theorem, `Nat.succ_le_of_lt`, states that for any two natural numbers `n` and `m`, if `n` is less than `m`, then the successor of `n` (which is `n + 1`) is less than or equal to `m`. In other words, it expresses that if one natural number is strictly smaller than another, then the next natural number will be either still smaller or exactly equal to the second number. This is a fundamental property of the natural number ordering.

For all natural numbers `n` and `m`, if `n` < `m`, then `nat.succ n` ≤ `m`.


theorem CategoryTheory.IsIso.inv_hom_id :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} (f : X ⟶ Y) [I : CategoryTheory.IsIso f],
      CategoryTheory.CategoryStruct.comp (CategoryTheory.inv f) f = CategoryTheory.CategoryStruct.id Y :=
  by sorry

This theorem, `CategoryTheory.IsIso.inv_hom_id`, states that for any category `C` and any two objects `X` and `Y` in `C`, if `f` is an isomorphism from `X` to `Y` (denoted as `f : X ⟶ Y`), then the composition of the inverse of `f` (denoted as `CategoryTheory.inv f`) and `f` itself is equal to the identity morphism on `Y` (denoted as `CategoryTheory.CategoryStruct.id Y`). In other words, if `f` is an invertible function, then the inverse of `f` followed by `f` brings us back to where we started. This is a key characteristic of isomorphisms in category theory.

For any category `C` and objects `X` and `Y` with an isomorphism `f : X ⟶ Y`, the composition of `CategoryTheory.inv f` and `f` is equal to the identity morphism on `Y`, i.e., `CategoryTheory.inv f ∘ f = CategoryTheory.id Y`.


theorem smul_smul :
    ∀ {M : Type u_1} {α : Type u_6} [inst : Monoid M] [inst_1 : MulAction M α] (a₁ a₂ : M) (b : α),
      a₁ • a₂ • b = (a₁ * a₂) • b :=
  by sorry

This theorem states that for any monoid `M` and any type `α` that has a multiplication action of `M` on it, the double scalar multiplication of two elements `(a₁, a₂)` from `M` and an element `b` from `α` is equal to the scalar multiplication of the product of `(a₁ * a₂)` and `b`. In other words, the scalar multiplication operation is associative with respect to the multiplication in the monoid. It means that scaling `b` by `a₁` and then by `a₂` is the same as scaling `b` by the product of `a₁` and `a₂`. This is expressed in mathematical notation as `a₁ • a₂ • b = (a₁ * a₂) • b`.

For any monoid action of `M` on a type `α` and any `a₁, a₂ ∈ M` and `b ∈ α`, we have `a₁ * a₂ * b = (a₁ * a₂) * b`.


theorem Int.cast_zero : ∀ {R : Type u} [inst : AddGroupWithOne R], ↑0 = 0 := by sorry

This theorem states that for any type `R` that forms an additive group with an identity element (specifically, a structure that complies with the `AddGroupWithOne` typeclass in Lean), the casting of the integer zero `↑0` into type `R` is equal to the zero of type `R`. Essentially, it guarantees that zero maintains its identity when cast to different types that have a notion of zero and a specified algebraic structure.

For any additive group `R` with identity element, the cast of integer zero `↑0` is equal to the additive identity of `R`.


TopologicalSpace.Opens.openEmbedding

theorem TopologicalSpace.Opens.openEmbedding :
    ∀ {X : TopCat} (U : TopologicalSpace.Opens ↑X), OpenEmbedding ⇑(TopologicalSpace.Opens.inclusion U) := by sorry

This theorem asserts that for any topological space `X` (from the category `TopCat`) and any open subset `U` of `X`, the inclusion map from `U` to `X` (as denoted by `TopologicalSpace.Opens.inclusion U`) is an open embedding. In terms of topology, an open embedding is a continuous and injective function that also has the property that the image of any open set under this function is open. Therefore, the theorem essentially guarantees that the inclusion of an open subset into a topological space preserves the topological structure, specifically the open sets.

The inclusion map of an open subset into a topological space is an open embedding.


/-- **Alias** of the reverse direction of `sub_nonpos`. -/
theorem sub_nonpos_of_le :
    ∀ {α : Type u} [inst : AddGroup α] [inst_1 : LE α]
      [inst_2 : CovariantClass α α (Function.swap fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] {a b : α},
      a ≤ b → a - b ≤ 0 :=
  by sorry

The theorem `sub_nonpos_of_le` states that for any type `α` that forms an additive group and has a less than or equal to (`≤`) relation, and for which the relation is covariant with respect to the operation of adding two elements of the type, if `a` and `b` are two elements of `α` such that `a` is less than or equal to `b`, then the difference `a - b` is less than or equal to zero. This is an alias of the reverse direction of the theorem `sub_nonpos`. Essentially, if `a` is less than or equal to `b`, then `a - b` is nonpositive.

For any additive group type `α` with a covariant `≤` relation, if `a ≤ b`, then `a - b ≤ 0`.


/-- A cardinal lifted to the same universe equals itself.  -/
theorem Cardinal.lift_id : ∀ (a : Cardinal.{u}), Cardinal.lift.{u, u} a = a := by sorry

The theorem `Cardinal.lift_id` states that for any cardinal number `a` in a given universe `u`, lifting `a` to the same universe `u` results in the cardinal number `a` itself. In other words, the process of lifting a cardinal to its own universe does not change its value. This is expressed in the language of Lean 4's type theory and cardinal arithmetic.

For any cardinal number `a` in universe `u`, `Cardinal.lift a = a`.


/-- **Alias** of `lt_of_le_of_ne`. -/
theorem LE.le.lt_of_ne : ∀ {α : Type u} [inst : PartialOrder α] {a b : α}, a ≤ b → a ≠ b → a < b := by sorry

This theorem, `LE.le.lt_of_ne`, states that for any type `α` that has a partial order, given two elements `a` and `b` of type `α`, if `a` is less than or equal to `b` and `a` is not equal to `b`, then `a` is strictly less than `b`. This is essentially a restatement of the `lt_of_le_of_ne` theorem, acting as an alias for convenience.

If `α` is a type with a partial order, and `a` and `b` are elements of `α` with `a ≤ b` and `a ≠ b`, then `a < b`.


theorem Mathlib.Algebra.NeZero._auxLemma.3 :
    ∀ {α : Type u_2} [inst : Zero α] [inst_1 : One α] [inst_2 : NeZero 1], (0 = 1) = False := by sorry

This theorem, referred to as `Mathlib.Algebra.NeZero._auxLemma.3`, states that for any type `α` (denoted as `u_2`) that has defined instances of zero (`inst`) and one (`inst_1`), and the number one is not equal to zero (`inst_2 : NeZero 1`), the proposition that zero equals one (`0 = 1`) is false. In other words, it ensures that, in the given algebraic context, zero and one are distinct entities.

If `α` has defined instances of zero and one, and one is not equal to zero, then zero is not equal to one.


theorem mul_right_inv : ∀ {G : Type u_1} [inst : Group G] (a : G), a * a⁻¹ = 1 := by sorry

This theorem states that for any type `G` that is a Group, the multiplication of any element `a` in `G` with its inverse `a⁻¹` results in the identity element `1`. This is a fundamental property of groups in mathematics, where each element has an inverse such that their multiplication equals the group's identity element.

For all groups G and all elements a in G, a * a⁻₁ = 1.


theorem Subtype.range_coe : ∀ {α : Type u_1} {s : Set α}, Set.range Subtype.val = s := by sorry

This theorem states that for any type `α` and for any set `s` of type `α`, the range of the subtype coercion function (i.e., `Subtype.val`) is equal to the set `s`. In other words, if you take all the elements of the subtype and retrieve their underlying elements in `α` (using `Subtype.val`), you will obtain exactly the set `s`. This underlines the correspondence between a set `s` and the subtype determined by the membership to `s` in terms of their elements.

For any subtype `s` of type `α`, the image of `s` under the subtype coercion function is equal to `s`. In mathematical notation, `Subtype.val (Subtype.mk ��igma) = ��igma`, where `��igma` is the set represented by the subtype `s`.


theorem Multiset.map_map :
    ∀ {α : Type u_1} {β : Type v} {γ : Type u_2} (g : β → γ) (f : α → β) (s : Multiset α),
      Multiset.map g (Multiset.map f s) = Multiset.map (g ∘ f) s :=
  by sorry

The theorem `Multiset.map_map` is about the composition and association of functions with the `map` operation in the context of multisets. Given three types `α`, `β`, and `γ`, and two functions `f : α → β` and `g : β → γ`, this theorem states that for any multiset `s` of type `α`, mapping `f` over `s` first and then mapping `g` over the result is equivalent to mapping the composition of `g` and `f` (i.e., `g ∘ f`) over `s` directly. This can be seen as a kind of associativity property for the `map` operation on multisets, aligning with the common intuition from functional programming.

For any multisets `s` of type `α`, the application of functions `g ∘ f` and `g ∘ Map (f) s` to `s` is equal.


theorem lt_or_le : ∀ {α : Type u} [inst : LinearOrder α] (a b : α), a < b ∨ b ≤ a := by sorry

This theorem states that for any given type `α` that has a linear order, for all instances of `α` named `a` and `b`, either `a` is less than `b` or `b` is less than or equal to `a`. This is a fundamental principle of ordered sets, reflecting that any two elements can be compared, with one being less than (or possibly equal to, in case of non-strict ordering) the other.

For any type `α` with a linear order, for all `a` and `b` of type `α`, either `a` is less than `b` or `b` is less than or equal to `a`.


MeasurableSet.inter

theorem MeasurableSet.inter :
    ∀ {α : Type u_1} {m : MeasurableSpace α} {s₁ s₂ : Set α},
      MeasurableSet s₁ → MeasurableSet s₂ → MeasurableSet (s₁ ∩ s₂) :=
  by sorry

The theorem `MeasurableSet.inter` states that for any type `α` and any measurable space `m` on `α`, if `s₁` and `s₂` are sets of `α` both of which are measurable sets, then their intersection `s₁ ∩ s₂` is also a measurable set. In terms of measure theory, it means that the intersection of any two measurable sets within a given measurable space is also a measurable set.

If `α` is a type with a measurable space `m`, and `s₁` and `s₂` are measurable sets in `α` according to `m`, then `s₁ ∩ s₂` is also a measurable set according to `m`.


/-- Specialisation of `Nat.cast_pos'`, which seems to be easier for Lean to use.  -/
theorem Nat.cast_pos : ∀ {α : Type u_3} [inst : OrderedSemiring α] [inst_1 : Nontrivial α] {n : ℕ}, 0 < ↑n ↔ 0 < n := by
  sorry

This theorem, `Nat.cast_pos`, is a specialized version of another theorem, `Nat.cast_pos'`. It states that for any natural number `n`, the statement "0 is less than the cast of `n` to a type `α`" is equivalent to the statement "0 is less than `n`". Here, `α` is any type that forms an ordered semiring and is nontrivial (i.e., it contains at least two distinct elements).

For any natural number `n` and type `α` forming an ordered semiring, `0` is less than `Nat.cast (α) n` if and only if `0` is less than `n`.


theorem Finset.mem_singleton : ∀ {α : Type u_1} {a b : α}, b ∈ {a} ↔ b = a := by sorry

This theorem, `Finset.mem_singleton`, states that for all types `α` and for all elements `a` and `b` of type `α`, `b` is an element of the singleton set that only contains `a` if and only if `b` is equal to `a`. In other words, in a set with only one element, an element is contained in that set if and only if it's the same as that one element.

For any type `α` and elements `a` of `α`, the singleton set `{a : α}` contains `a` if and only if `a` is equal to the element in the set.


theorem dvd_refl : ∀ {α : Type u_1} [inst : Monoid α] (a : α), a ∣ a := by sorry

This theorem states that for any type `α` that is a monoid, any element `a` of this type divides itself. In mathematical terms, this means that for any element `a` in a monoid `α`, there exists some other element in `α` such that when multiplied by `a`, results in `a` again. This element is obviously the multiplicative identity of the monoid.

For any monoid `α` and element `a` in `α`, there exists an identity element `e` in `α` such that `a * e = a` and `e * a = a`.


theorem norm_smul :
    ∀ {α : Type u_1} {β : Type u_2} [inst : NormedDivisionRing α] [inst_1 : SeminormedAddGroup β]
      [inst_2 : MulActionWithZero α β] [inst_3 : BoundedSMul α β] (r : α) (x : β), ‖r • x‖ = ‖r‖ * ‖x‖ :=
  by sorry

This theorem, `norm_smul`, states that for any normed division ring `α` and any semi-normed add group `β`, if `α` multiplies `β` with zero and there exists a bounded scalar multiplication between `α` and `β`, then the norm of the scalar multiplication of any element `r` from `α` and `x` from `β` is equal to the product of the norms of `r` and `x`. In mathematical terms, for any `r` in `α` and `x` in `β`, `‖r • x‖ = ‖r‖ * ‖x‖`.

Given a normed division ring `α` and a semi-normed add group `β` with a bounded scalar multiplication, the norm of the product of any `r` in `α` and `x` in `β` is equal to the product of the norms of `r` and `x`. That is, `‖r • x‖ = ‖r‖ * ‖x‖`.


theorem Nat.le_refl : ∀ (n : ℕ), n ≤ n := by sorry

This theorem, `Nat.le_refl`, is an assertion about the reflexivity of less than or equal to relation on natural numbers. It states that for any natural number `n`, `n` is less than or equal to itself. In other words, it proves the property of reflexivity for the "less than or equal to" relation in the set of natural numbers.


theorem pow_mul : ∀ {M : Type u} [inst : Monoid M] (a : M) (m n : ℕ), a ^ (m * n) = (a ^ m) ^ n := by sorry

This theorem states that for any type `M` that forms a monoid, and any element `a` of type `M`, the exponentiation of `a` by the product of two natural numbers `m` and `n` is equal to the result of raising `a` to the power of `m` and then raising that result to the power of `n`. In simpler terms, it asserts the identity `a^(m*n) = (a^m)^n` for any monoid element `a` and natural numbers `m` and `n`.

For any monoid `M` and element `a` in `M`, and natural numbers `m` and `n`, `a^(m * n) = (a^m)^n`.


theorem isOpen_interior : ∀ {X : Type u} {s : Set X} [inst : TopologicalSpace X], IsOpen (interior s) := by sorry

The theorem `isOpen_interior` states that for any type `X` and any set `s` of type `X`, given that a topological structure `inst` is defined on `X`, the interior of set `s` is an open set in this topological space. In other words, in any given topological space, the interior of any set is always an open set. This is a fundamental property in topology, and is universally true regardless of the specific details of the topological space or the set.

In any topological space, the interior of a set is an open set.


SetLike.ext

/-- Note: implementers of `SetLike` must copy this lemma in order to tag it with `@[ext]`.  -/
theorem SetLike.ext : ∀ {A : Type u_1} {B : Type u_2} [i : SetLike A B] {p q : A}, (∀ (x : B), x ∈ p ↔ x ∈ q) → p = q :=
  by sorry

The theorem `SetLike.ext` states that for any two objects `p` and `q` of type `A`, which has a `SetLike` relationship with type `B`, if for every `x` of type `B`, `x` belongs to `p` if and only if `x` belongs to `q`, then `p` is equal to `q`. In other words, two `SetLike` objects are considered equal if they contain exactly the same elements. Note that implementers of `SetLike` must reproduce this lemma in their code and tag it with `@[ext]`.

If two `SetLike` objects `p` and `q` over type `A` with respect to type `B` have equal elements, then `p` is equal to `q`.


theorem Measurable.comp_aemeasurable :
    ∀ {α : Type u_1} {β : Type u_2} {δ : Type u_4} {m : MeasurableSpace α} [inst : MeasurableSpace β]
      {μ : MeasureTheory.Measure α} [inst_1 : MeasurableSpace δ] {f : α → δ} {g : δ → β},
      Measurable g → AEMeasurable f μ → AEMeasurable (g ∘ f) μ :=
  by sorry

The theorem `Measurable.comp_aemeasurable` states that for all types `α`, `β`, and `δ` and for a given measurable space `α`, measurable spaces `β` and `δ`, a measure `μ` on `α`, and functions `f : α → δ` and `g : δ → β`, if function `g` is measurable and function `f` is almost everywhere measurable with respect to measure `μ`, then the composition of `g` and `f` (denoted as `g ∘ f`) is also almost everywhere measurable with respect to measure `μ`. In more mathematical terms, this theorem says that the composition of a measurable function and an almost everywhere measurable function remains almost everywhere measurable.

If `f : α → δ` is almost everywhere measurable and `g : δ → β` is measurable, then their composition `g ∘ f : α → β` is almost everywhere measurable.


theorem ENNReal.coe_ne_top : ∀ {r : NNReal}, ↑r ≠ ⊤ := by sorry

This theorem states that for every nonnegative real number `r` (represented as `NNReal`), the coextension of `r` is not equal to positive infinity (denoted by `⊤`). In other words, no nonnegative real number can be coextended to become positive infinity.

For every non-negative real number `r`, `r` is not equal to positive infinity (⊤).


theorem self_mem_nhdsWithin : ∀ {α : Type u_1} [inst : TopologicalSpace α] {a : α} {s : Set α}, s ∈ nhdsWithin a s := by
  sorry

The theorem `self_mem_nhdsWithin` states that for any given type `α` equipped with a topology, an element `a` of type `α`, and a set `s` of type `α`, the set `s` is an element of the "neighborhood within" filter created from `a` and `s`. In other words, `s` itself is considered a "neighborhood within" `s` of `a` in the given topological space. This implies that `s` contains the intersection of `s` and some neighborhood of `a`.

For any topological space $(X, \tau)$, element $a \in X$, and set $s \subseteq X$, we have $s \in \mathit{nhdsWithin} \ a$ (the neighborhood filter of $a$ in $X$), hence $s \cap \mathit{open}(a) \neq \emptyset$.


theorem add_left_comm : ∀ {G : Type u_3} [inst : AddCommSemigroup G] (a b c : G), a + (b + c) = b + (a + c) := by sorry

This theorem, `add_left_comm`, states that for any type `G` that forms an additive commutative semigroup, for any three elements `a`, `b`, and `c` of type `G`, the operation of addition is left-commutative. In other words, adding `a` to the sum of `b` and `c` (`a + (b + c)`) results in the same value as adding `b` to the sum of `a` and `c` (`b + (a + c)`). This property holds for all instances of `a`, `b`, and `c` in the commutative semigroup `G`.

For any additive commutative semigroup `G`, the operation `+` is left-commutative, i.e., `a + (b + c) = b + (a + c)` for all `a, b, c` in `G`.


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

This theorem, named `top_unique`, states that for any type `α` that has a partial order and a top element (`OrderTop`), if the top element is less than or equal to any element `a` of the type, then that element `a` must be the top element. Essentially, it means in the given order, there cannot be any element greater than the top element.

If `α` is a type with a partial order and a top element `top`, then `top ≤ a` for all `a` in `α` implies `top = a`.


/-- See `zero_lt_two'` for a version with the type explicit.  -/
theorem zero_lt_two :
    ∀ {α : Type u_1} [inst : AddMonoidWithOne α] [inst_1 : PartialOrder α] [inst_2 : ZeroLEOneClass α]
      [inst_3 : NeZero 1] [inst_4 : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1], 0 < 2 :=
  by sorry

This theorem, named `zero_lt_two`, states that for any type `α` that has the structures of an additive monoid with 1 (i.e., it supports addition and has a distinguished element "1"), a partial order (i.e., it supports comparison operations like ≤), and a `ZeroLEOneClass` (which enforces that 0 is less than or equal to 1), and also satisfies the properties that 1 is not zero (`NeZero 1`) and the covariant property for addition and order (`CovariantClass`), then 0 is less than 2. In other words, in a mathematical setting that supports these features, we have 0 < 2.

If `α` is an additive monoid with 1, a partial order, and `ZeroLEOneClass` such that `1` is not zero and addition and order are covariant, then `0 < 2`.


DifferentiableAt.hasDerivAt

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

This theorem states that for any function `f` from a non-trivially normed field `𝕜` to a normed additive commutative group `F` (which is a normed space over `𝕜`), at any point `x` in `𝕜`, if `f` is differentiable at `x`, then `f` has a derivative at `x` and that derivative is given by the function `deriv f x`. This means the derivative of `f` at the point `x` exists and satisfies the property of being the rate of change of `f` at `x`. In mathematical terms, if `f` is differentiable at `x`, then the function `f` at `x` approximates to `f x + (x' - x) • deriv f x + o(x' - x)` as `x'` converges to `x`, where `deriv f x` is the derivative of `f` at `x`.

If `f` is a differentiable function from a non-trivially normed field to a normed additive commutative group, then the derivative `deriv f x` exists at any point `x` in the field, and `f(x) ≈ f(x + h) + h • deriv f x` as `h` approaches 0.


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

The theorem `abs_nonneg` states that for any value `a` of a type `α`, which is a lattice and an additive group, and has both left and right covariant classes with respect to addition and order, the absolute value of `a` is always nonnegative, i.e., `0 ≤ |a|`. In mathematical terms, this can be represented as: ∀a ∈ α, 0 ≤ |a|. The covariant classes ensure that the type `α` is ordered and has properties that relate its order and its binary operation (addition in this case).

For any element `a` in a lattice and additive group type `α` with covariant classes for addition and order, the absolute value `|a|` is nonnegative.


theorem isClosed_eq :
    ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] [inst_2 : T2Space X]
      {f g : Y → X}, Continuous f → Continuous g → IsClosed {y | f y = g y} :=
  by sorry

This theorem states that for any types `X` and `Y` where `X` is a Hausdorff (or T2) space and there are topological spaces defined on `X` and `Y`, if `f` and `g` are continuous functions from `Y` to `X`, then the set of all `y` in `Y` such that `f(y) = g(y)` is a closed set in the topological space `Y`. In other words, the set of points where the two continuous functions coincide is a closed set.

If `X` is a Hausdorff space and `f` and `g` are continuous functions from a topological space `Y` to `X`, then the graph of their equality, `{y : Y | f(y) = g(y)}`, is a closed subset of `Y`.


theorem CategoryTheory.Functor.map_zero :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂}
      [inst_1 : CategoryTheory.Category.{v₂, u₂} D] [inst_2 : CategoryTheory.Limits.HasZeroMorphisms C]
      [inst_3 : CategoryTheory.Limits.HasZeroMorphisms D] (F : CategoryTheory.Functor C D)
      [inst_4 : CategoryTheory.Functor.PreservesZeroMorphisms F] (X Y : C), F.map 0 = 0 :=
  by sorry

This theorem states that for any category `C` and category `D` which both have zero morphisms, and any functor `F` from `C` to `D` that preserves zero morphisms, the image of the zero morphism under `F` is the zero morphism in `D`. In simpler terms, applying the functor `F` to the zero morphism in `C` gives the zero morphism in `D`.

For any functor F between categories with zero morphisms, if F preserves zero morphisms then F(0) = 0, where 0 denotes the zero morphism in the respective categories.


theorem GaloisConnection.l_sup :
    ∀ {α : Type u} {β : Type v} {a₁ a₂ : α} [inst : SemilatticeSup α] [inst_1 : SemilatticeSup β] {l : α → β}
      {u : β → α}, GaloisConnection l u → l (a₁ ⊔ a₂) = l a₁ ⊔ l a₂ :=
  by sorry

The theorem `GaloisConnection.l_sup` states that for any types `α` and `β` where `α` and `β` are both semilattices, and any elements `a₁` and `a₂` of type `α`, if a Galois connection exists between a function `l` from `α` to `β` and a function `u` from `β` to `α`, then the function `l` preserves the operation of taking supremum (join operation in semilattice), i.e., the value of `l` at the supremum of `a₁` and `a₂` is the same as the supremum of the values of `l` at `a₁` and `a₂`. In mathematical notation, this can be represented as `l(a₁ ⊔ a₂) = l(a₁) ⊔ l(a₂)`.

For any semilattices types `α` and `β` and elements `a₁` and `a₂` in `α`, if there exists a Galois connection between functions `l: α → β` and `u: β → α`, then `l( sup a₁ a₂ ) = sup ( l(a₁) ) ( l(a₂) )`.


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

This theorem states that for any division commutative monoid `α` and any elements `a` and `b` of `α`, the operation of dividing `a` by `b` is equivalent to multiplying the inverse of `b` by `a`. In mathematical terms, it expresses that `a / b = b⁻¹ * a` for all `a` and `b` in the division commutative monoid `α`.

For any division commutative monoid `α`, the operation of dividing `a` by `b` is equivalent to multiplying the inverse of `b` by `a`, that is, `a / b ≈ b⁻¹ * a`.


theorem add_tsub_cancel_of_le :
    ∀ {α : Type u_1} [inst : AddCommSemigroup α] [inst_1 : PartialOrder α] [inst_2 : ExistsAddOfLE α]
      [inst_3 : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] [inst_4 : Sub α] [inst_5 : OrderedSub α]
      {a b : α}, a ≤ b → a + (b - a) = b :=
  by sorry

This theorem, `add_tsub_cancel_of_le`, states that for any type `α` that has the structure of an additive commutative semigroup, a partial order, and an existence of addition for elements less than or equal to another, and also has the properties of being a subclass and having subtraction with a specific order, given two elements `a` and `b` of that type where `a` is less than or equal to `b`, the sum of `a` and the difference of `b` and `a` is equal to `b`. This theorem is essentially the algebraic property that adding the difference of two numbers to the smaller number yields the larger number, formalized in the context of ordered semigroups.

For any additive commutative semigroup with order and subtraction, if `a` is less than or equal to `b`, then `a + (b - a) = b`.


/-- **Alias** of `add_sub_cancel_left`. -/
theorem add_sub_cancel' : ∀ {G : Type u_3} [inst : AddCommGroup G] (a b : G), a + b - a = b := by sorry

This theorem, `add_sub_cancel'`, is an alias of `add_sub_cancel_left`. It states that for any type `G` that forms an additive commutative group, for any two elements `a` and `b` of this type, adding `a` and `b` and then subtracting `a` is equal to `b`. In other words, the operation of adding an element to another, and then subtracting the first element, effectively cancels out the first element, resulting in the second element. This can be written in mathematical notation as: ∀ a, b ∈ G, a + b - a = b, where G is an additive commutative group.

For any additive commutative group G and elements a, b in G, a + b - a = b.


theorem lt_iff_lt_of_le_iff_le :
    ∀ {α : Type u} {β : Type u_3} [inst : LinearOrder α] [inst_1 : LinearOrder β] {a b : α} {c d : β},
      (a ≤ b ↔ c ≤ d) → (b < a ↔ d < c) :=
  by sorry

This theorem states that for any two types α and β, both of which are linearly ordered, and for any respective pairs of elements (a, b) from α and (c, d) from β, if the "less than or equal to" relation between a and b is equivalent to the "less than or equal to" relation between c and d, then the "less than" relation between b and a is equivalent to the "less than" relation between d and c. In simpler words, if a is less than or equal to b exactly when c is less than or equal to d, then b is less than a exactly when d is less than c.

If two linearly ordered types α and β, and their elements a, b from α and c, d from β satisfy a ≤ b if and only if c ≤ d, then b ≤ a if and only if d ≤ c.


theorem measurable_const :
    ∀ {α : Type u_1} {β : Type u_2} {x : MeasurableSpace α} {x_1 : MeasurableSpace β} {a : α}, Measurable fun x => a :=
  by sorry

The theorem `measurable_const` states that for any two types `α` and `β`, and for any measurable spaces `x` on `α` and `x_1` on `β`, and for any element `a` of type `α`, the constant function that maps every element of the domain to `a` is a measurable function. In other words, if we have a measurable space structure on two types `α` and `β`, and an element `a` of type `α`, then the function which assigns `a` to each element of `β` is a measurable function.

For any measurable spaces (X, Σ) on type α and (Y, Σ₁) on type β, and any element a of α, the constant function mapping every element of Y to a is measurable.


/-- **Alias** of `add_sub_cancel`. -/
theorem add_sub_cancel'_right : ∀ {G : Type u_3} [inst : AddCommGroup G] (a b : G), a + (b - a) = b := by sorry

This is a theorem in the context of an additive commutative group. For any pair of elements 'a' and 'b' in this group, the theorem states that if you subtract 'a' from 'b' and then add 'a', you get back 'b'. In mathematical notation, this is expressed as a + (b - a) = b. It is an alias of the theorem `add_sub_cancel`.

For all elements 'a' and 'b' in an additive commutative group, 'a' + ( 'b' - 'a' ) = 'b'.


theorem NNReal.coe_nonneg : ∀ (r : NNReal), 0 ≤ ↑r := by sorry

The theorem `NNReal.coe_nonneg` states that for every nonnegative real number `r`, the real number corresponding to `r` (obtained by applying the coercion (`↑r`)) is nonnegative. In other words, the coercion of any element in the set of nonnegative real numbers, denoted as `NNReal`, is always greater than or equal to zero.

For every non-negative real number `r`, `↑r` ≥ 0 holds true.


/-- **Alias** of `dist_eq_norm_sub`. -/
theorem dist_eq_norm : ∀ {E : Type u_6} [inst : SeminormedAddGroup E] (a b : E), dist a b = ‖a - b‖ := by sorry

This theorem, named `dist_eq_norm`, applies to any seminormed add group `E` of an arbitrary type `u_6`. It states that for 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`. In mathematical notation, this means `dist(a, b) = ‖a - b‖`.

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


DFunLike.ext'

theorem DFunLike.ext' :
    ∀ {F : Sort u_1} {α : Sort u_2} {β : α → Sort u_3} [i : DFunLike F α β] {f g : F}, ⇑f = ⇑g → f = g := by sorry

This theorem states that for any dependent function-like type `F` with a domain `α` and a codomain that depends on `α,` denoted as `β : α → Sort u_3`, if we have two instances `f` and `g` of this type `F`, and their function applications (represented by the coercion to a function, `⇑f` and `⇑g`) are equal, then `f` and `g` themselves are equal. Essentially, it asserts the extensionality of dependent function-like objects.

If `F` is a dependent function-like type with domain `α` and codomain `β : α → Sort u_3`, and `⇑f = ⇑g` for `f, g : F α`, then `f = g`.


theorem mul_ne_zero :
    ∀ {M₀ : Type u_2} [inst : Mul M₀] [inst_1 : Zero M₀] [inst_2 : NoZeroDivisors M₀] {a b : M₀},
      a ≠ 0 → b ≠ 0 → a * b ≠ 0 :=
  by sorry

This theorem states that for any type `M₀` which has a multiplication operation, a zero element, and has no zero divisors, if `a` and `b` are elements of `M₀` such that neither `a` nor `b` is zero, then the product of `a` and `b` is also not zero. This is a generalization of a well-known property from number theory: the product of two non-zero numbers is always non-zero.

In a type with multiplication, zero element, and no zero divisors, the product of two non-zero elements is non-zero.


theorem Finset.coe_univ : ∀ {α : Type u_1} [inst : Fintype α], ↑Finset.univ = Set.univ := by sorry

This theorem asserts that, for any type `α` that is finite (`Fintype α`), the coercion of the universal finite set of type `Finset α` (denoted as `Finset.univ`) is equal to the universal set of type `α` (`Set.univ`). In other words, when viewed as a set, the universal finite set contains all and only the elements of the type `α`, which is the definition of the universal set of type `α`.

For any finite type `α`, the universal finite set `Finset.univ (Fintype α)` equals the universal set `Set.univ` of type `α`.


theorem IsClosed.closure_eq : ∀ {X : Type u} {s : Set X} [inst : TopologicalSpace X], IsClosed s → closure s = s := by
  sorry

This theorem states that for any type `X` and any set `s` of `X`, in the context of a topological space given by `inst`, if `s` is a closed set, then the closure of `s` is equal to `s` itself. In other words, the closure of a closed set in a topological space is the set itself. In mathematical terms, if `s` is a closed set in a topological space, then the intersection of all closed sets that contain `s` (the closure of `s`) is just `s`.

A closed set in a topological space is equal to its closure.


theorem le_iInf :
    ∀ {α : Type u_1} {ι : Sort u_5} [inst : CompleteLattice α] {f : ι → α} {a : α}, (∀ (i : ι), a ≤ f i) → a ≤ iInf f :=
  by sorry

The theorem `le_iInf` states that for any type `α` that forms a complete lattice, any function `f` from some index set `ι` to `α`, and any element `a` of `α`, if `a` is less than or equal to every value `f(i)` for all `i` in `ι`, then `a` is less than or equal to the indexed infimum of the function `f`. In other words, if `a` is less than or equal all values of `f`, then `a` is less than or equal to the greatest lower bound of the range of `f`.

For any complete lattice `α`, if `a ≤ f(i)` for all `i` in the index set `ι`, then `a ≤ ∧ⁱ i.in f` (the infimum of `f`).


ContDiff.contDiffAt

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

This theorem states that for any non-trivially normed field `𝕜`, normed additive commutative groups `E` and `F`, and a function `f` mapping from `E` to `F`, if `f` is continuously differentiable up to order `n` (where `n` can be any natural number or infinity), then `f` is also continuously differentiable at a specific point `x` in `E`. This holds for all such `x` in `E`.

If `f` is continuously differentiable up to order `n` on a non-trivially normed field `𝕜` from normed additive commutative groups `E` to `F`, then `f` is continuously differentiable at every point `x` in `E`.


/-- If `f` is a monoid homomorphism then `f 1 = 1`.  -/
theorem MonoidHom.map_one :
    ∀ {M : Type u_4} {N : Type u_5} [inst : MulOneClass M] [inst_1 : MulOneClass N] (f : M →* N), f 1 = 1 := by sorry

This theorem states that for any given monoid homomorphism `f` from a type `M` to a type `N`, where `M` and `N` are both instances of the `MulOneClass` (which means they have a multiplication operation and an identity element `1`), the image of the identity element under the homomorphism `f` is the identity element in `N`. In other words, if `f` is a monoid homomorphism, then applying `f` to the identity element `1` in `M` results in the identity element `1` in `N`.

For any monoid homomorphism f from a monoid (M, ∧, 1) to a monoid (N, ⊤, 1), the image of the identity element 1 under f is the identity element 1 in N.


theorem Or.imp_right : ∀ {b c a : Prop}, (b → c) → a ∨ b → a ∨ c := by sorry

This theorem, `Or.imp_right`, states that for any three propositions `a`, `b`, and `c`, if we have a hypothetical implication from `b` to `c`, then an implication from the logical disjunction `a ∨ b` to `a ∨ c` is guaranteed. In other words, if we know that `b` implies `c`, and if we have either `a` or `b`, then we can assert that we have either `a` or `c`.

If `b` implies `c`, then `a ∨ b` implies `a ∨ c` in Lean.


theorem HomologicalComplex.hom_ext :
    ∀ {ι : Type u_1} {V : Type u} [inst : CategoryTheory.Category.{v, u} V]
      [inst_1 : CategoryTheory.Limits.HasZeroMorphisms V] {c : ComplexShape ι} {C D : HomologicalComplex V c}
      (f g : C ⟶ D), (∀ (i : ι), f.f i = g.f i) → f = g :=
  by sorry

This theorem states that for any two morphisms ("f" and "g") between two Homological Complexes ("C" and "D"), in a given category ("V") with a specific complex shape ("c"), if the morphisms "f" and "g" coincide on every index "i" (i.e., `f.f i = g.f i` for all "i"), then the two morphisms "f" and "g" are essentially the same (i.e., `f = g`). The category "V" is assumed to have zero morphisms, which are important in the theory of Homological Complexes.

If two morphisms between Homological Complexes in a category with zero morphisms have the same action on every index, then they are equal.


theorem Nat.card_eq_fintype_card : ∀ {α : Type u_1} [inst : Fintype α], Nat.card α = Fintype.card α := by sorry

This theorem states that, for any type `α` that is a finite type (as indicated by `[inst : Fintype α]`), the cardinality of `α` as a natural number (`Nat.card α`) is equal to the number of elements in `α` (`Fintype.card α`). In other words, for a finite type, the number of distinct values it can take (its cardinality) is equal to the count of its elements.

For any finite type `α`, the number of elements in `α` (`Fintype.card α`) equals its cardinality as a set (`Nat.card α`).


theorem Fintype.card_congr :
    ∀ {α : Type u_4} {β : Type u_5} [inst : Fintype α] [inst_1 : Fintype β], α ≃ β → Fintype.card α = Fintype.card β :=
  by sorry

The theorem `Fintype.card_congr` asserts that for any two types `α` and `β`, if they are both finite (`Fintype`) and there exists a bijective mapping (an equivalence, represented as `α ≃ β`) between them, then they have the same number of elements. In other words, the cardinality (`Fintype.card`) of `α` equals the cardinality of `β`.

If two types `α` and `β` are finite and there exists a bijective mapping between them, then they have the same number of elements.


theorem map_natCast :
    ∀ {R : Type u_3} {S : Type u_4} {F : Type u_5} [inst : NonAssocSemiring R] [inst_1 : NonAssocSemiring S]
      [inst_2 : FunLike F R S] [inst_3 : RingHomClass F R S] (f : F) (n : ℕ), f ↑n = ↑n :=
  by sorry

The theorem `map_natCast` states that for any types `R`, `S` and `F`, where `R` and `S` are non-associative semirings, `F` is a function-like structure from `R` to `S`, and `F` forms a ring homomorphism from `R` to `S`, then for any function `f` of type `F` and any natural number `n`, the result of applying `f` to the cast of `n` into `R` (denoted by `f ↑n`) is equal to the cast of `n` into `S` (denoted by `↑n`). This theorem essentially asserts that the function `f` preserves the natural number under its operation, which is a property usually expected of homomorphisms.

For any non-associative semirings R, S, and a ring homomorphism F from R to S, for all natural numbers n, we have F (cast n to R) = cast n to S.


Function.Embedding.injective

theorem Function.Embedding.injective : ∀ {α : Sort u_1} {β : Sort u_2} (f : α ↪ β), Function.Injective ⇑f := by sorry

The theorem `Function.Embedding.injective` states that for all types `α` and `β`, any function `f` from `α` to `β` that is an embedding (denoted as `α ↪ β`) is also injective. Here, a function is called injective if applying the function to two equal elements from `α` (i.e., `f a₁ = f a₂`) implies that these elements were already equal in `α` (i.e., `a₁ = a₂`). In other words, an embedding function does not map distinct elements in `α` to the same element in `β`.

An embedding function between types `α` and `β` is a injective function.


theorem Set.subset_union_right : ∀ {α : Type u} (s t : Set α), t ⊆ s ∪ t := by sorry

This theorem, `Set.subset_union_right`, states that for any type `α` and any two sets `s` and `t` of type `α`, `t` is a subset of the union of `s` and `t`. In other words, all elements of `t` are also elements of the union of `s` and `t`. This is a basic property of sets and union operation: any set is always a subset of the union of itself with another set.

For any types `α` and sets `s` and `t` of type `α`, `t` is a subset of `s ∪ t`.


theorem div_pos : ∀ {α : Type u_1} [inst : LinearOrderedSemifield α] {a b : α}, 0 < a → 0 < b → 0 < a / b := by sorry

This theorem, named `div_pos`, states that for any type `α` that is a `LinearOrderedSemifield` (a structure where order and operations like addition, subtraction, multiplication, and division are defined and follow certain rules), if `a` and `b` are two elements of `α` where both `a` and `b` are greater than zero, then the result of `a` divided by `b` is also greater than zero. In other words, the division of two positive numbers in a linearly ordered semifield produces a positive number.

If `α` is a LinearOrderedSemifield and `a`, `b` are positive elements of `α`, then `a / b` is also positive.


theorem GaloisConnection.l_iSup :
    ∀ {α : Type u} {β : Type v} {ι : Sort x} [inst : CompleteLattice α] [inst_1 : CompleteLattice β] {l : α → β}
      {u : β → α}, GaloisConnection l u → ∀ {f : ι → α}, l (iSup f) = ⨆ i, l (f i) :=
  by sorry

The theorem `GaloisConnection.l_iSup` states that for all types `α`, `β`, and `ι`, given `α` and `β` are complete lattices, and provided a Galois connection between functions `l : α → β` and `u : β → α`, for any function `f : ι → α`, the function `l` applied to the indexed supremum of `f` is equal to the supremum over `ι` of `l` applied to `f(i)`. In other words, the `l` function distributes over the indexed supremum.

For any complete lattices α and β, and a Galois connection between functions l : α → β and u : β → α, the supremum of l o f over an indexed family f : ι → α equals l (supremum of f over ι), where supremum denotes the indexed supremum.


Quiver.Hom.le

/-- **Alias** of `CategoryTheory.leOfHom`.

---

Extract the underlying inequality from a morphism in a preorder category.
 -/
theorem Quiver.Hom.le : ∀ {X : Type u} [inst : Preorder X] {x y : X}, (x ⟶ y) → x ≤ y := by sorry

The theorem `Quiver.Hom.le` states that for any types `X` and preorder instance on `X`, and for any elements `x` and `y` of `X`, if there exists a morphism from `x` to `y` in the category of `X`, then `x` is less than or equal to `y` according to the preorder on `X`. In the context of category theory, this theorem extracts the underlying inequality from a morphism in a preorder category.

If there exists a morphism from `x` to `y` in a preorder category, then `x` is less than or equal to `y` according to the preorder.


theorem Nat.le_of_dvd : ∀ {m n : ℕ}, 0 < n → m ∣ n → m ≤ n := by sorry

This theorem, `Nat.le_of_dvd`, states that for all natural numbers `m` and `n`, if `n` is greater than zero and `m` divides `n` (denoted by `m ∣ n`), then `m` is less than or equal to `n`. In simpler terms, any positive divisor of a natural number is always less than or equal to that number.

For all natural numbers m and n, if n > 0 and m | n then m <= n.


/-- A variant of `image_comp`, useful for rewriting  -/
theorem Set.image_image :
    ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} (g : β → γ) (f : α → β) (s : Set α),
      g '' (f '' s) = (fun x => g (f x)) '' s :=
  by sorry

This theorem, referred to as `Set.image_image`, states that for any three types `α`, `β`, and `γ`, and any two functions `f` from `α` to `β` and `g` from `β` to `γ`, and a set `s` of type `α`, the image of the image of `s` under `f` and then `g` is equal to the image of `s` under the composition of `g` and `f`. In other words, applying `f` to each element of `s` and then `g` to the result is the same as applying the composition of `g` and `f` to each element of `s`. This theorem is a variant of `image_comp` and is useful for rewriting expressions in Lean 4.

For any sets `α, β, γ`, functions `f : α → β` and `g : β → γ`, and set `s ⊆ α`, `image (image s f) g = image s (g ∘ f)`.


theorem Mathlib.Data.Nat.Cast.Order._auxLemma.13 :
    ∀ {α : Type u_1} [inst : AddMonoidWithOne α] [inst_1 : PartialOrder α]
      [inst_2 : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] [inst_3 : ZeroLEOneClass α]
      [inst_4 : CharZero α] {m n : ℕ}, (↑m < ↑n) = (m < n) :=
  by sorry

This theorem states that for any type `α` that is a sum monoid with an identity element, is partially ordered, fulfills covariant class conditions, has zero less than or equal to one, and has character zero, and for any natural numbers `m` and `n`, the cast of `m` to `α` is less than the cast of `n` to `α` if and only if `m` is less than `n`. This establishes a correspondence between the less-than relation in the natural numbers and the less-than relation in the structure `α` after casting the natural numbers to `α`.

For any sum monoid with an identity element `α` that is partially ordered, covariant, has zero less than or equal to one, and has character zero, the natural number `m` is less than `n` if and only if the cast of `m` to `α` is less than the cast of `n` to `α`.


theorem Finset.le_sup :
    ∀ {α : Type u_2} {β : Type u_3} [inst : SemilatticeSup α] [inst_1 : OrderBot α] {s : Finset β} {f : β → α} {b : β},
      b ∈ s → f b ≤ Finset.sup s f :=
  by sorry

The theorem `Finset.le_sup` states that for any types `α` and `β`, given a semilattice structure and a bottom element on `α`, a finite set `s` of `β`, a function `f` from `β` to `α`, and an element `b` of `β`, if `b` belongs to the set `s`, then the value of the function `f` at `b` is less than or equal to the supremum of the values of `f` over the set `s`. In other words, for all elements in a set, the function value at each element is always less than or equal to the supremum (greatest value) of the function values at all elements in the set.

For any semilattice `α` with bottom element, function `f` from a finite set `s` of type `β` to `α`, and element `b` in `s`, we have `f b ≤ sup (map f s)`.


theorem nonpos_iff_eq_zero : ∀ {α : Type u} [inst : CanonicallyOrderedAddCommMonoid α] {a : α}, a ≤ 0 ↔ a = 0 := by
  sorry

This theorem, `nonpos_iff_eq_zero`, states that for any type `α` that is a canonically ordered additive commutative monoid, an element `a` of type `α` is non-positive (i.e., `a ≤ 0`) if and only if `a` is equal to zero (`a = 0`). In other words, in such a data structure, the only non-positive element is zero itself.

For any additive commutative monoid `α` with canonical order, an element `a` in `α` is non-positive if and only if it is equal to zero.


Fin.ext

theorem Fin.ext : ∀ {n : ℕ} {a b : Fin n}, ↑a = ↑b → a = b := by sorry

The theorem `Fin.ext` states that for any natural number `n` and for any two objects `a` and `b` of the type `Fin n` (i.e., finite sets of size `n`), if their coercion to natural numbers (denoted by `↑a` and `↑b`) are equal, then `a` and `b` are also equal. In other words, two elements of a finite set of size `n` are identical if and only if their corresponding natural numbers are identical.

For any natural number `n` and any `a, b : Fin n`, `a = b` if and only if `↑a = ↑b`.


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

This theorem, `norm_neg`, states that for any type `E` that forms a semi-normed addition group, the norm of the negation of any element `a` in that group is equal to the norm of `a` itself. In mathematical terms, for a seminormed addition group `E`, for all `a` in `E`, the norm of `-a` is equal to the norm of `a`. This is usually denoted as `‖-a‖ = ‖a‖`.

For any seminormed additive group `E`, the negation of an element `a` in `E` has the same norm as `a`, i.e., `‖-a‖ = ‖a‖`.


theorem Mathlib.Algebra.CharZero.Defs._auxLemma.7 :
    ∀ {R : Type u_1} [inst : AddMonoidWithOne R] [inst_1 : CharZero R] (n : ℕ) [inst_2 : Nat.AtLeastTwo n],
      (OfNat.ofNat n = 0) = False :=
  by sorry

This theorem, named `Mathlib.Algebra.CharZero.Defs._auxLemma.7`, states for any type `R`, provided that `R` is a type that has an additive monoid with one structure, and a characteristic zero structure. For a natural number `n` that is at least two (`n` is greater than or equal to 2), the proposition that the `OfNat.ofNat` function, which converts this natural number `n` to type `R`, equals zero is always false. In other words, for all such `n` and `R`, `OfNat.ofNat n` cannot be zero.

For any type `R` with an additive monoid and characteristic zero structure, the conversion of a natural number `n` (greater than or equal to 2) to `R` is never equal to zero.


Equiv.bijective

theorem Equiv.bijective : ∀ {α : Sort u} {β : Sort v} (e : α ≃ β), Function.Bijective ⇑e := by sorry

The theorem `Equiv.bijective` states that for any two types `α` and `β`, if there exists a bijective mapping `e` from `α` to `β` (denoted as `α ≃ β`), then the function denoted by `⇑e` (which refers to the application of `e`) is bijective. In other words, if there exists an equivalence between two types, then the function that represents this equivalence is both injective (no two different inputs give the same output) and surjective (every possible output is produced by some input).

If `α ≃ β` (there exists a bijective function from `α` to `β`), then the application function `⇑e` is a bijective function from `α` to `β`.


theorem Subtype.val_injective : ∀ {α : Sort u_1} {p : α → Prop}, Function.Injective Subtype.val := by sorry

The theorem `Subtype.val_injective` states that for any type `α` and a property `p` defined for `α`, the function `Subtype.val` is injective. In other words, if we have two subtypes `s1` and `s2` of `α` that satisfy the property `p`, and if `Subtype.val s1` is equal to `Subtype.val s2`, then `s1` and `s2` are the same. This essentially says that the `Subtype.val` function does not map different subtypes to the same value in `α`.

If `s1` and `s2` are subtypes of a type `α` such that `p(x)` holds for all `x ∈ s1` and `x ∈ s2`, then `Subtype.val s1 = Subtype.val s2` implies `s1 = s2`.


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

This theorem, `Set.nonempty_iff_ne_empty`, states that for any set `s` of type `α`, the assertion that the set `s` is nonempty is equivalent to the claim that the set `s` is not equal to the empty set. In other words, a set `s` is nonempty if and only if it is not an empty set. It's an assertion about the equivalence of two ways of expressing the notion of a set being nonempty: either directly using the `Set.Nonempty` predicate or by stating that the set is not the empty set.

A set is nonempty if and only if it is not equal to the empty set.


theorem zpow_negSucc : ∀ {G : Type u_1} [inst : DivInvMonoid G] (a : G) (n : ℕ), a ^ Int.negSucc n = (a ^ (n + 1))⁻¹ :=
  by sorry

This theorem states that for any type `G` that forms a `DivInvMonoid` (a structure with division and inversion operations), and any element `a` of type `G` and a natural number `n`, raising `a` to the power of the negation of the successor of `n` (in terms of integers, represented by `Int.negSucc n`) is equivalent to taking the inverse (`⁻¹`) of `a` raised to the power of `n+1`. In mathematical notation, this would be written as `a ^ - (n + 1) = 1 / (a ^ (n + 1))`.

For any `DivInvMonoid` type `G` and its element `a` and natural number `n`, `a ^ (negation (succ n)) = 1 / (a ^ (n + 1))`.


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

This theorem states that, for any type `α`, any property `p` of `α`, and any property `q` of the subtype of `α` satisfying `p`, the proposition that `q` applies to all elements of the subtype is equivalent to the proposition that, for all elements `a` of `α` and proofs `b` that `a` satisfies `p`, `q` applies to the subtype element composed of `a` and `b`. This is a theorem about the relationship between properties of a subtype and properties of the elements in the underlying type.

For any type `α`, property `p` of `α`, and property `q` of its subtype satisfying `p`, the subtype elementwise satisfies `q` if and only if `q` applies to all elements in the subtype with proofs of `p`.


theorem add_tsub_cancel_right :
    ∀ {α : Type u_1} [inst : PartialOrder α] [inst_1 : AddCommSemigroup α] [inst_2 : Sub α] [inst_3 : OrderedSub α]
      [inst : ContravariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] (a b : α), a + b - b = a :=
  by sorry

The theorem `add_tsub_cancel_right` states that for any type `α` which has a partial order, a commutative semigroup structure under addition, a subtraction operation, an ordered subtraction structure, and a contravariant class structure relating addition to the partial order, subtracting `b` from the sum of `a` and `b` returns `a`. In simple terms, for any two elements `a` and `b` in this type `α`, adding `b` to `a` and then subtracting `b` will leave you with `a` again. This mirrors the intuitive arithmetic property `a + b - b = a`.

For any type `α` equipped with a partial order, commutative semigroup structure under addition, subtraction operation, ordered subtraction structure, and contravariant class structure, the law of cancellation holds for right subtraction: `a + b = c + b -> a = c`.


theorem LinearMap.map_add :
    ∀ {R : Type u_1} {S : Type u_6} {M : Type u_9} {M₃ : Type u_12} [inst : Semiring R] [inst_1 : Semiring S]
      [inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid M₃] [inst_4 : Module R M] [inst_5 : Module S M₃] {σ : R →+* S}
      (f : M →ₛₗ[σ] M₃) (x y : M), f (x + y) = f x + f y :=
  by sorry

This theorem states that for any two elements `x` and `y` of a certain module `M`, the linear map `f` preserves the addition operation. More formally, if `R` and `S` are semirings, `M` and `M₃` are additive commutative monoids, `M` is an `R`-module, `M₃` is an `S`-module, and `σ` is a ring homomorphism from `R` to `S`, then for any linear map `f` from `M` to `M₃` (with respect to `σ`), the image of the sum of `x` and `y` under `f` equals the sum of the images of `x` and `y` under `f`. This theorem is essentially the statement of one of the key properties of linear maps: they preserve the algebraic structure of their domain.

For any linear map $f$ from an additive commutative monoid $M$ (over semirings $R$ and $S$, with a ring homomorphism $\sigma$ from $R$ to $S$) between an $R$-module $M$ and an $S$-module $M\_3$, the image of the sum of any two elements $x, y \in M$ under $f$ equals the sum of the images of $x$ and $y$ under $f$.


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

The theorem `CategoryTheory.MonoidalCategory.tensorHom_id` states that for any Category `C` with a Monoidal structure, and for any two objects `X₁` and `X₂` in `C`, if there's a morphism `f` from `X₁` to `X₂`, then tensoring `f` with the identity morphism on any object `Y` in `C` is the same as whiskering `f` on the right with `Y`. In other words, it expresses the equality between the two operations `tensorHom` and `whiskerRight` in a Monoidal Category when the second component of the tensor product is the identity morphism.

For any monoidal category `C` and objects `X₁`, `X₂` in `C` with a morphism `f : X₁ → X₂`, the tensoring of `f` with the identity on any object `Y` is equal to whiskering `f` on the right with `Y`. That is, `tensorHom f idY = whiskerRight f Y`.


theorem dist_nonneg : ∀ {α : Type u} [inst : PseudoMetricSpace α] {x y : α}, 0 ≤ dist x y := by sorry

This theorem states that for any two points `x` and `y` in any pseudo metric space `α`, the distance between `x` and `y` is always non-negative. In other words, you can't have a negative distance between two points in a pseudo metric space. This is a fundamental property of distances in these mathematical structures.

In any pseudo metric space, the distance between any two points is non-negative.


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

This theorem, `add_sub_cancel`, states that for any type `G` that is an additive commutative group (denoted by `AddCommGroup G`), for any two elements `a` and `b` of this type, the result of adding `a` to the difference of `b` and `a` (`a + (b - a)`) is always `b`. This is a basic property of subtraction in the context of additive commutative groups, reflecting the idea that adding a quantity and then subtracting the same quantity results in the original value.

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


theorem Nat.cast_le :
    ∀ {α : Type u_1} [inst : AddMonoidWithOne α] [inst_1 : PartialOrder α]
      [inst_2 : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] [inst_3 : ZeroLEOneClass α]
      [inst_4 : CharZero α] {m n : ℕ}, ↑m ≤ ↑n ↔ m ≤ n :=
  by sorry

This theorem, `Nat.cast_le`, states that for any type `α` that is an additive monoid with a one element, has a partial order, satisfies the covariant class property for addition and order, has zero less than or equal to one, and has characteristic zero, the inequality between the natural number castings `m` and `n` to `α` holds if and only if the inequality between `m` and `n` holds. In other words, casting doesn't change the order of natural numbers.

For types `α` that are additive monoids with a one element, have a partial order, satisfy the covariant class property for addition and order, have zero less than or equal to one, and have characteristic zero, the natural number castings to `α` preserve the order relation.


Set.Subset.refl

theorem Set.Subset.refl : ∀ {α : Type u} (a : Set α), a ⊆ a := by sorry

This theorem states that, for any type `α` and any set `a` of type `α`, the set `a` is a subset of itself. In mathematical terms, this theorem establishes the reflexivity of the subset relation, i.e., for every set `a`, `a ⊆ a`.

For any set `a`, `a` is a subset of `a` (`a ⊆ a`).


theorem Mathlib.Data.Finset.Basic._auxLemma.64 :
    ∀ {α : Type u_1} [inst : DecidableEq α] {s : Finset α} {a b : α}, (a ∈ insert b s) = (a = b ∨ a ∈ s) := by sorry

This theorem, named `Mathlib.Data.Finset.Basic._auxLemma.64`, states that for any type `α` which has decidable equality, any finite set `s` of type `α`, and any two elements `a` and `b` of type `α`, the proposition that `a` belongs to the set resulting from inserting `b` into `s` is equivalent to the proposition that `a` is equal to `b` or `a` belongs to the original set `s`. In other words, an element belongs to the set obtained by adding a new element into a finite set if and only if it is either equal to the newly added element or it was in the original set.

For any type `α` with decidable equality and finite set `s` of type `α`, the element `a` is in the set `s.insert(b)` if and only if `a = b` or `a` is in `s`.


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

This theorem states that for any set `s` of a type `α`, if every element `x` of type `α` belongs to `s` (i.e., `s` contains all elements of type `α`), then `s` is equal to the universal set of `α`, denoted by `Set.univ`. In other words, any set that contains all possible elements of a particular type is considered the universal set for that type.

If a set `s` of type `α` contains all elements of `α`, then `s` is equal to the universal set `Set.univ` of type `Set α`.


IsOpen.preimage

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

The theorem `IsOpen.preimage` states that for any types `X` and `Y` equipped with topological spaces, if `f` is a continuous function mapping from `X` to `Y`, then for any open set `t` in `Y`, the preimage of `t` under `f` is an open set in `X`.

If `f` is a continuous function from topological spaces `X` and `Y`, then for any open set `t` in `Y`, the preimage `f⁻¹(t)` is an open set in `X`.


theorem Nat.lt_of_lt_of_le : ∀ {n m k : ℕ}, n < m → m ≤ k → n < k := by sorry

This theorem, `Nat.lt_of_lt_of_le`, states that for any three natural numbers `n`, `m`, and `k`, if `n` is less than `m` and `m` is less than or equal to `k`, then `n` is less than `k`. Essentially, it expresses a property of the order of natural numbers: the transitivity of the less than relation through a less than or equal relation.

If `n` is less than `m` and `m` is less than or equal to `k`, then `n` is less than `k`. (Transitivity of the less than relation through a less than or equal relation in the context of natural numbers.)


theorem zero_div : ∀ {G₀ : Type u_3} [inst : GroupWithZero G₀] (a : G₀), 0 / a = 0 := by sorry

This theorem states that for any type `G₀` that has the structure of a group with zero (i.e., it is equipped with an operation and a zero element such that it behaves like a mathematical group with an additional zero element), the division of zero by any element `a` of `G₀` is zero. In mathematical terms, this theorem simply states the universal property that zero divided by anything equals zero in a group with zero.

In a group with zero, the product of any element with zero is zero.


theorem Int.add_comm : ∀ (a b : ℤ), a + b = b + a := by sorry

This theorem, `Int.add_comm`, asserts the commutativity of addition for integers. Specifically, it states that for all integers `a` and `b`, the sum of `a` and `b` is equal to the sum of `b` and `a`. In mathematical notation, this would be expressed as ∀(a, b ∈ ℤ), a + b = b + a.

For all integers `a` and `b`, `a + b` equals `b + a`.


Prod.mk.eta

theorem Prod.mk.eta : ∀ {α : Type u_1} {β : Type u_2} {p : α × β}, (p.1, p.2) = p := by sorry

This theorem, named `Prod.mk.eta`, states that for any pair `p` of arbitrary type `α` and `β`, the pair formed by taking the first and second elements of `p`, i.e. `(p.1, p.2)`, is equal to the original pair `p`. In simple terms, it demonstrates the property of reconstructing a pair from its components without any loss of information.

For any pair `p` of type `α × β`, the tuple `(p.1, p.2)` is equal to `p`.


theorem Units.mul_inv : ∀ {α : Type u} [inst : Monoid α] (a : αˣ), ↑a * ↑a⁻¹ = 1 := by sorry

This theorem states that for any type `α` that forms a Monoid (a set equipped with an associative binary operation and an identity element), the multiplication of any unit `a` and its inverse yields the identity element. In mathematical terms, for any `a` in the group of units of `α`, `a * a⁻¹ = 1`. This is a fundamental property of elements in any Monoid.

For any monoid `α` and its unit `a`, `a * a⁻¹ = 1`.


theorem Nat.mod_add_div : ∀ (m k : ℕ), m % k + k * (m / k) = m := by sorry

This theorem states that for all natural numbers `m` and `k`, the modulus of `m` by `k` added to `k` times the integer division of `m` by `k` equals `m`. In other words, if you divide `m` by `k`, multiply the quotient by `k`, and then add the remainder, you get back the original number `m`. This is a formalization of the Euclidean division algorithm in the natural numbers.

For all natural numbers m and k, m = k * (m div k) + m mod k.


MeasurableSet.nullMeasurableSet

theorem MeasurableSet.nullMeasurableSet :
    ∀ {α : Type u_2} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} {s : Set α},
      MeasurableSet s → MeasureTheory.NullMeasurableSet s μ :=
  by sorry

This theorem states that for any type `α`, any measurable space `m0` over `α`, any measure `μ` from the `MeasureTheory.Measure` class over `α`, and any set `s` of type `α`, if `s` is a measurable set (i.e., `MeasurableSet s` is true), then `s` is also a null measurable set with respect to measure `μ` (i.e., `MeasureTheory.NullMeasurableSet s μ` is true). In other words, any measurable set can be approximated by a measurable set up to a set of null measure.

Any measurable set in a measurable space is a null measurable set with respect to any measure.


theorem Function.Injective.eq_iff' :
    ∀ {α : Sort u_1} {β : Sort u_2} {f : α → β},
      Function.Injective f → ∀ {a b : α} {c : β}, f b = c → (f a = c ↔ a = b) :=
  by sorry

This theorem states that for any types `α` and `β`, and any function `f` from `α` to `β`, if `f` is injective (meaning that `f` maps distinct inputs to distinct outputs), then for any two elements `a` and `b` of `α` and any element `c` of `β`, if `f b = c`, then `f a = c` if and only if `a = b`. In simpler terms, if an injective function `f` maps `b` to `c`, then it also maps `a` to `c` if and only if `a` and `b` are the same.

If `f` is an injective function from type `α` to type `β`, then for all `a, b : α` and `c : β`, if `f b = c`, then `a = b` implies `f a = c`.


Filter.Eventually.mp

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

The theorem `Filter.Eventually.mp` states that for any type `α`, any properties `p` and `q` of `α`, and any filter `f` on `α`, if `p` holds eventually for some `x` in the filter `f`, and if it is also the case that `p x` implies `q x` eventually in the filter `f`, then `q` also holds eventually for some `x` in the filter `f`. In other words, it shows that the "eventually" filter condition is closed under logical implication.

If a property `p` holds eventually for some elements in a filter `f` and `p(x)` implies `q(x)` eventually in `f` for all `x` in the domain, then property `q` holds eventually for some elements in the filter `f`.


theorem Equiv.symm_symm : ∀ {α : Sort u} {β : Sort v} (e : α ≃ β), e.symm.symm = e := by sorry

This theorem states that for any equivalence relation 'e' between two sorts (or types) 'α' and 'β', taking the symmetric of the symmetric of 'e' returns 'e'. In other words, the double application of the 'symm' operation to an equivalence 'e' is an identity operation, leaving 'e' unchanged. The 'symm' operation here refers to swapping the domain and codomain of the equivalence relation.

For any equivalence relation e between types α and β, (symm e) ^^ (symm e) = e.


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

This is an alias of the theorem `mul_sub_left_distrib`. It states that for any type `α` that forms a `NonUnitalNonAssocRing` (a mathematical structure similar to a ring but without the requirement of having a multiplicative identity or associative multiplication), and for any three elements `a`, `b`, and `c` of that type, the property `a * (b - c) = a * b - a * c` holds. In mathematical terms, this expresses the left distributivity of multiplication over subtraction in such a structure.

For any non-unital, non-associative ring `α`, the multiplication is left distributive over subtraction: `a * (b - c) = a * b - a * c`.


/-- Note that most of the lemmas about powers of two refer to it as `sq`.  -/
theorem pow_two : ∀ {M : Type u} [inst : Monoid M] (a : M), a ^ 2 = a * a := by sorry

This theorem, `pow_two`, states that for any type `M` that is a monoid (an algebraic structure with a single associative binary operation and an identity element), the square of any element `a` of `M` (noted as `a ^ 2`) is equal to the product of `a` with itself (`a * a`). This is a fundamental property of squaring in the context of monoids.

For any monoid `M` and its element `a`, `a ^ 2 = a * a`.