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

This theorem, named `add_le_add`, states that for any type `α` that has an addition operation (`Add α`), a preorder relation (which is a reflexive and transitive binary relation), and satisfies the covariance properties for addition and order, if `a` and `b` are elements of `α` such that `a` is less than or equal to `b`, and `c` and `d` are elements of `α` such that `c` is less than or equal to `d`, then `a + c` is less than or equal to `b + d`. In conventional mathematical notation, this can be written as: ∀a, b, c, d ∈ `α`, if a ≤ b and c ≤ d, then a + c ≤ b + d. This theorem essentially formalizes one of the key properties of ordered rings.

For any type `α` with an addition operation and a preorder relation that is covariant with respect to addition, if `a ≤ b` and `c ≤ d` in `α`, then `a + c ≤ b + d`.


theorem or_false : ∀ (p : Prop), (p ∨ False) = p := by sorry

This theorem is named `or_false` and it states that for all propositions `p`, the logical disjunction of `p` and `False` is simply `p`. In other words, if we take a statement `p` and form a new statement that is the 'or' of `p` and `False`, then the new statement is logically equivalent to just `p`. This makes sense because 'or' is true if either of the components is true, hence 'or' with `False`, which is never true, isn't changing the original proposition.

For all propositions p, pOrFalse ≡ p in Lean logic. (Here, pOrFalse represents the logical disjunction of p and False.)


theorem mul_neg : ∀ {α : Type u} [inst : Mul α] [inst_1 : HasDistribNeg α] (a b : α), a * -b = -(a * b) := by sorry

This theorem, `mul_neg`, states that for all types `α` that support multiplication (indicated by `Mul α`) and distributed negation (indicated by `HasDistribNeg α`), for any two elements `a` and `b` of this type, the product of `a` and `-b` is equal to the negation of the product of `a` and `b`. In mathematical notation, this corresponds to the statement `a * (-b) = -(a * b)`.

For all types `α` with multiplication and distributive negation, `a * (-b) = -(a * b)`.


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

This theorem, `lt_of_lt_of_le`, states that for any type `α` that has a preorder structure, given three elements `a`, `b`, and `c` of type `α`, if `a` is less than `b` and `b` is less than or equal to `c`, then `a` is less than `c`. In mathematical terms, this is just stating the transitivity of less-than relationship in a preordered set.

If `a` is less than `b` and `b` is less than or equal to `c` in a preordered set `α`, then `a` is less than `c`.


theorem Finset.prod_congr :
    ∀ {α : Type u_3} {β : Type u_4} {s₁ s₂ : Finset α} {f g : α → β} [inst : CommMonoid β],
      s₁ = s₂ → (∀ x ∈ s₂, f x = g x) → Finset.prod s₁ f = Finset.prod s₂ g :=
  by sorry

The theorem `Finset.prod_congr` states that for any two sets `s₁` and `s₂` of the same type `α`, and any two functions `f` and `g` from `α` to another type `β` (where `β` is a commutative monoid), if `s₁` and `s₂` are the same, and `f(x)` equals `g(x)` for every element `x` in `s₂`, then the product of `f(x)` over all elements `x` in `s₁` is equal to the product of `g(x)` over all elements `x` in `s₂`. In mathematical terms, if $s_1 = s_2$ and $f(x) = g(x)$ for all $x \in s_2$, then $\prod_{x \in s_1} f(x) = \prod_{x \in s_2} g(x)$.

If two sets have the same elements and every element maps the same way under two functions to a commutative monoid, then the products of the functions over the sets are equal.


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

This theorem states that for any natural number 'n', 0 is less than or equal to 'n'. In other words, zero is always less than or equal to any given natural number. This is a fundamental property of natural numbers in mathematics, as no natural number can be negative.


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

The theorem `Set.mem_univ` states that for any type `α` and any element `x` of that type, `x` is a member of the universal set `Set.univ` on type `α`. In other words, every element of any given type is included in the universal set of that type. This aligns with the concept of a universal set in set theory, which contains all possible elements of a given universe.

For any type `α` and any `x : α`, `x ∈ Set.univ (α)`.


theorem le_sup_left : ∀ {α : Type u} [inst : SemilatticeSup α] {a b : α}, a ≤ a ⊔ b := by sorry

This theorem states that for any type `α` that is a semilattice with an operation `sup` (or supremum), and for any two elements `a` and `b` of that type, `a` is less than or equal to the supremum of `a` and `b`. In other words, in any semilattice, an element is always less than or equal to the supremum of itself with any other element. In the language of order theory, this property is one of the defining characteristics of a join-semilattice.

For any semilattice type `α` and elements `a, b ∈ α`, we have `a ≤ sup a b`.


theorem Mathlib.Data.Fintype.Basic._auxLemma.1 :
    ∀ {α : Type u_1} [inst : Fintype α] (x : α), (x ∈ Finset.univ) = True := by sorry

The theorem `Mathlib.Data.Fintype.Basic._auxLemma.1` states that for any type `α` that is a finite type (expressed as `[inst : Fintype α]`), any element `x` of that type is indeed a member of the universal finite set of type `Finset α` (expressed as `(x ∈ Finset.univ) = True`). In simpler terms, it confirms that every element in a finite type is a part of the universal set of that type.

For any finite type `α`, every `α` is an element of the universal finite set `Finset α`.


theorem Set.image_univ : ∀ {α : Type u_1} {β : Type u_2} {f : α → β}, f '' Set.univ = Set.range f := by sorry

The theorem `Set.image_univ` states that for any types `α` and `β`, and any function `f` from `α` to `β`, the image of the universal set (`Set.univ`) under the function `f` is equal to the range of the function `f`. In more formal terms, it means that the set of all outputs of `f` when applied to all elements of `α` (represented by `f '' Set.univ`) is the same as the set of all possible outputs of `f` (represented by `Set.range f`). This theorem essentially formalizes the idea that the range of a function includes every possible output value when the function is applied to every possible input.

For any function `f` from type `α` to type `β`, `Set.range f = f '' Set.univ`.


theorem DFunLike.congr_fun :
    ∀ {F : Sort u_1} {α : Sort u_2} {β : α → Sort u_3} [i : DFunLike F α β] {f g : F}, f = g → ∀ (x : α), f x = g x :=
  by sorry

This theorem, named `DFunLike.congr_fun`, states that for any dependent function-like `F` from `α` to `β`, given `f` and `g` are two instances of `F`, if `f` is equal to `g`, then the results of applying `f` and `g` to any element `x` of `α` are also equal. This ensures the congruence property of dependent function-like structures.

For any dependent function-like `F` from `α` to `β` and `x` in `α`, if `F.app f x` equals `F.app g x` for all `f` and `g` instances of `F`, then `f` equals `g`.


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

This theorem states that for any type `X` with a topological space structure, any open set `s` of `X`, and any element `x` of `X`, if `x` is an element of `s`, then `s` is a neighborhood of `x`. In other words, if an element `x` belongs to an open set `s`, then `s` is a part of the neighborhood filter at `x`, denoted by `nhds x` in the context of topology.

For any topological space `(X, τ)` and open set `s ∈ τ` in `X`, if `x ∈ s`, then `s ∈ nhds x`. (In other words, any open set containing an element is a neighborhood of that element.)


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

This theorem states that for any type `G` that is a Division Inverse Monoid (i.e., a set equipped with an operation, often multiplication, and an inversion operation that satisfies certain axioms), the operation of dividing 1 by any element `a` of `G` is equivalent to taking the inverse of `a`. In mathematical terms, we can express this as: ∀a ∈ G, 1/a = a⁻¹.

For any Division Inverse Monoid `G`, the operation of taking inverses and dividing by an element `a` in `G` are equal, i.e., `a⁻¹ = 1/a`.


theorem Nat.cast_add : ∀ {R : Type u_1} [inst : AddMonoidWithOne R] (m n : ℕ), ↑(m + n) = ↑m + ↑n := by sorry

This theorem states that for any type `R`, which is an additive monoid with one, and for any natural numbers `m` and `n`, the cast of the sum of `m` and `n` to `R` is equal to the sum of the cast of `m` to `R` and the cast of `n` to `R`. In other words, in terms of mathematical notation, given a ring `R` and natural numbers `m` and `n`, we have `(m + n) ∈ R = m ∈ R + n ∈ R`.

For any additive monoid with one `R` and natural numbers `m` and `n`, the cast of `m + n` to `R` equals the cast of `m` to `R` plus the cast of `n` to `R`. In mathematical notation: `(m + n: R) = (m: R) + (n: R)`.


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

This theorem, `Set.inter_comm`, states that for all types `α` and sets `a` and `b` of type `α`, the intersection of `a` and `b` is equal to the intersection of `b` and `a`. In other words, the order in which the sets are intersected does not matter, demonstrating the commutative property of intersection. In mathematical notation, this is equivalent to saying for all sets `a` and `b`, `a ∩ b = b ∩ a`.

The theorem asserts that for all types `α` and sets `a` and `b` of type `α`, the intersection `a ∩ b` is equal to the intersection `b ∩ a`.


theorem Int.ofNat_add : ∀ (n m : ℕ), ↑(n + m) = ↑n + ↑m := by sorry

This theorem states that for any two natural numbers `n` and `m`, the operation of adding the numbers and then converting the result to an integer is equivalent to converting each number to an integer first and then adding them. In other words, if you have two natural numbers, `n` and `m`, then the integer representation of `(n + m)` is equal to the sum of the integer representation of `n` and the integer representation of `m`. In mathematical notation, we could write this as: "For all natural numbers `n` and `m`, `↑(n + m) = ↑n + ↑m`." In this equation, the `↑` symbol is used to denote the conversion from a natural number to an integer.

For all natural numbers `n` and `m`, the conversion of `(n + m)` to an integer is equal to the sum of the conversions of `n` and `m` to integers. (i.e., `↑(n + m) = ↑n + ↑m`)


theorem Mathlib.Data.Set.Defs._auxLemma.1 : ∀ {α : Type u} (x : α), (x ∈ Set.univ) = True := by sorry

This theorem states that for any type `α` and any element `x` of type `α`, `x` is an element of the universal set of type `α`. This is always true regardless of the specific type or element. In terms of set theory, this can be seen as the fact that any element of a certain type belongs to the set of all elements of that type.

For any type `α` and any element `x` of type `α`, `x` is a member of the type `α`.


theorem forall_congr' :
    ∀ {α : Sort u_1} {p q : α → Prop}, (∀ (a : α), p a ↔ q a) → ((∀ (a : α), p a) ↔ ∀ (a : α), q a) := by sorry

This theorem states that for all types `α` and any two properties `p` and `q` that can be applied to elements of `α`, if for every element `a` of type `α`, the property `p a` is equivalent to the property `q a`, then the statement "for all `a` of type `α`, `p a` holds" is equivalent to "for all `a` of type `α`, `q a` holds". In simpler words, if two properties are equivalent for all elements of a certain type, then any statement about all elements of that type having one property is equivalent to the same statement with the other property.

If for all `α` and properties `p` and `q` on `α`, `p a ↔ q a` for all `a : α` implies `∀ a, p a ↔ ∀ a, q a`.


Measurable.comp

theorem Measurable.comp :
    ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {x : MeasurableSpace α} {x_1 : MeasurableSpace β}
      {x_2 : MeasurableSpace γ} {g : β → γ} {f : α → β}, Measurable g → Measurable f → Measurable (g ∘ f) :=
  by sorry

The theorem `Measurable.comp` states that for all types `α`, `β`, and `γ` and for all measurable spaces over these types, if we have a function `g` from `β` to `γ` and a function `f` from `α` to `β` such that both `g` and `f` are measurable, then the composition of `g` and `f` (denoted by `g ∘ f`) is also measurable. In other words, the measurability property is preserved under function composition.

If `f` from `α` to `β` and `g` from `β` to `γ` are measurable functions, then their composition `g ∘ f` is also a measurable function.


/-- **Alias** of `right_distrib`. -/
theorem add_mul :
    ∀ {R : Type x} [inst : Mul R] [inst_1 : Add R] [inst_2 : RightDistribClass R] (a b c : R),
      (a + b) * c = a * c + b * c :=
  by sorry

This theorem, `add_mul`, is an alias of `right_distrib`, and states that for any given type `R` which has multiplication and addition operations, and also satisfies the property of right distribution (as specified by `RightDistribClass`), the multiplication of the sum of two elements `a` and `b` with a third element `c` is equal to the sum of the product of `a` and `c` and the product of `b` and `c`. In mathematical terms, it asserts the distributive law: $(a + b) * c = a * c + b * c$.

The theorem asserts that for any type `R` with right-distributive multiplication and addition, we have $(a + b) \cdot c = a \cdot c + b \cdot c$.


theorem subset_closure : ∀ {X : Type u} {s : Set X} [inst : TopologicalSpace X], s ⊆ closure s := by sorry

This theorem states that for any type `X` and any set `s` of type `X` in a given topological space, `s` is a subset of its closure. In other words, for all sets in a topological space, every element of the set is also an element of the set's closure. This is a fundamental property of closures in topology.

For any topological space and set `s` of type `X`, every element of `s` belongs to the closure of `s`.


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

This theorem states that for any preordered type `α` and any two elements `a` and `b` of this type, if `b` is strictly less than `a`, then `a` is not equal to `b`. The preordered type could be any type that has a preorder relation defined on it, such as the integers, real numbers, or other types where there is a sense of "less than" or "greater than". This theorem essentially captures the intuitive idea that in a preordered set, if one element is greater than another, they cannot be the same element.

In a preordered type, if one element is strictly less than another, then they are not equal.


Continuous.continuousAt

theorem Continuous.continuousAt :
    ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {f : X → Y} {x : X},
      Continuous f → ContinuousAt f x :=
  by sorry

This theorem states that for any two types `X` and `Y` equipped with a topological structure (i.e., they are topological spaces), and any function `f` from `X` to `Y`, if the function `f` is continuous, then it is also continuous at any point `x` in `X`. In mathematical terms, if `f` is a continuous function, then for every point `x` in the domain, the function values `f(x)` approach `f(x₀)` as `x` approaches `x₀`.

If `f` is a continuous function between topological spaces `X` and `Y`, then `f` is continuous at every point `x` in `X`.


LT.lt.trans

/-- **Alias** of `lt_trans`. -/
theorem LT.lt.trans : ∀ {α : Type u} [inst : Preorder α] {a b c : α}, a < b → b < c → a < c := by sorry

This theorem, which is an alias of `lt_trans`, states that for any type `α` that has a `Preorder` structure, if `a`, `b`, `c` are objects of `α` and `a` is less than `b`, and `b` is less than `c`, then `a` is less than `c`. This is essentially transitivity of the less than relation in a preordered set.

In a preordered set, if `a` is less than `b` and `b` is less than `c`, then `a` is less than `c`.


theorem false_or : ∀ (p : Prop), (False ∨ p) = p := by sorry

This theorem states that for any proposition `p`, the disjunction of `False` and `p` is equivalent to `p` itself. In other words, it asserts that "False or `p`" is the same as just saying "`p`". This makes sense because in logic, an "or" statement is true if either or both of its components are true, and "False" is by definition not true, so "`False` or `p`" can only be true if `p` is true.

For all propositions p, `False`Or p equivalents p.


theorem one_pow : ∀ {M : Type u} [inst : Monoid M] (n : ℕ), 1 ^ n = 1 := by sorry

This theorem states that for any natural number `n`, the nth power of `1` in any Monoid `M` is `1`. In other words, for any monoidal structure (which is a type `M` endowed with an associative binary operation and an identity element), raising the identity element (`1` in this context) to any natural number power results in the identity element. This is a generalization of the familiar rule from elementary arithmetic that any power of 1 is 1.

For any monoid, raising its identity element to any natural number power yields the identity element.


refl

theorem refl : ∀ {α : Sort u} {r : α → α → Prop} [inst : IsRefl α r] (a : α), r a a := by sorry

This theorem, named `refl`, is stating that for any type `α` (which could be of any sort `u`), given a binary relation `r` on `α` and given that `r` is reflexive on `α` (as indicated by the `IsRefl α r` instance), then for any element `a` of `α`, the relation `r` holds between `a` and itself. In other words, it's asserting the reflexive property of the relation `r`: every element is related to itself.

For any reflexive binary relation `r` on type `α`, `r a a` holds for every `a` in `α`.


theorem Set.image_congr :
    ∀ {α : Type u_1} {β : Type u_2} {f g : α → β} {s : Set α}, (∀ a ∈ s, f a = g a) → f '' s = g '' s := by sorry

The theorem `Set.image_congr` states that for all types `α` and `β`, and for all functions `f` and `g` from `α` to `β`, and for any set `s` of type `α`, if for every element `a` in the set `s`, `f(a)` equals `g(a)`, then the image of the set `s` under the function `f` is equal to the image of the set `s` under the function `g`. In other words, if two functions agree on all elements of a given set, their images of that set are equal.

If two functions from a set to a type agree on every element of the set, then they have equal images of the set.


Ne.def

theorem Ne.def : ∀ {α : Sort u} (a b : α), (a ≠ b) = ¬a = b := by sorry

This theorem, `Ne.def`, defines the concept of non-equality for any type `α`. Specifically, for any two elements `a` and `b` of the type `α`, it states that `a` is not equal to `b` if and only if it is not the case that `a` is equal to `b`. This is a fundamental principle in mathematical logic.

For any type `α` and elements `a` and `b` of type `α`, `a` is not equal to `b` if and only if `a = b` fails.


Filter.EventuallyEq.symm

theorem Filter.EventuallyEq.symm : ∀ {α : Type u} {β : Type v} {f g : α → β} {l : Filter α}, f =ᶠ[l] g → g =ᶠ[l] f := by
  sorry

This theorem states that for any two functions `f` and `g` from type `α` to type `β` and any filter `l` on type `α`, if `f` is eventually equal to `g` at filter `l` (denoted as `f =ᶠ[l] g`), then `g` is also eventually equal to `f` at the same filter (denoted as `g =ᶠ[l] f`). In other words, the property of two functions being eventually equal at a certain filter is symmetric.

If `f` is eventually equal to `g` at filter `l` (`f =ᶠ[l] g`), then `g` is also eventually equal to `f` at filter `l` (`g =ᶠ[l] f`). (Symmetry of eventual equality at a filter)


theorem le_sup_right : ∀ {α : Type u} [inst : SemilatticeSup α] {a b : α}, b ≤ a ⊔ b := by sorry

This is a theorem in the field of order theory relating to semilattices. It states that for any type `α` that is a semilattice with respect to an operation `⊔` (typically representing "sup" or "supremum"), and for any two elements `a` and `b` of type `α`, `b` is less than or equal to the supreme of `a` and `b`. This means that the supremum of `a` and `b` is at least as great as `b`, a fundamental property of the supremum operation in semilattices.

In a semilattice with respect to the operation `⊔`, for all elements `a` and `b`, `b ≤ a ⊔ b`.


Set.Subset.trans

theorem Set.Subset.trans : ∀ {α : Type u} {a b c : Set α}, a ⊆ b → b ⊆ c → a ⊆ c := by sorry

This theorem, named as "Set.Subset.trans", states that for any type `α` and for any three sets `a`, `b`, and `c` of type `α`, if `a` is a subset of `b` and `b` is a subset of `c`, then `a` is also a subset of `c`. This is the transitive property of the subset relation among sets. In mathematical notation, for all sets $a$, $b$, and $c$, this can be expressed as: if $a \subseteq b$ and $b \subseteq c$, then $a \subseteq c$.

If sets `a`, `b`, and `c` are such that `a` is a subset of `b` and `b` is a subset of `c`, then `a` is a subset of `c` (transitive property of subset relation).


DFunLike.ext

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

This theorem states that for any type `F` of a certain sort `u_1`, any type `α` of a certain sort `u_2`, and any function `β` from `α` to a certain sort `u_3` such that `F` is like a dependent function from `α` to `β` (as denoted by the `DFunLike F α β` instance `i`), if two elements `f` and `g` of `F` are the same for all values of type `α` (i.e., `f x = g x` for all `x` in `α`), then `f` and `g` must actually be the same, or in other words `f = g`.

If `F` is a dependent function type from `α` to `β` and `f` and `g` are elements of `F` such that `f x = g x` for all `x` in `α`, then `f = g`.


theorem inf_le_right : ∀ {α : Type u} [inst : SemilatticeInf α] {a b : α}, a ⊓ b ≤ b := by sorry

This theorem states that for any type `α` which forms a `SemilatticeInf` (i.e., a mathematical structure with a binary operation called `inf` that is associative, commutative, and idempotent), and for any two elements `a` and `b` of this type, the infimum (greatest lower bound) of `a` and `b` is less than or equal to `b`. This captures one of the fundamental properties of the infimum operation in a semilattice.

For any semilattice `α` and elements `a, b` in `α`, we have `a <= b` when `a` is the infimum of `a` and `b`.


Finsupp.ext

theorem Finsupp.ext : ∀ {α : Type u_1} {M : Type u_5} [inst : Zero M] {f g : α →₀ M}, (∀ (a : α), f a = g a) → f = g :=
  by sorry

This theorem, `Finsupp.ext`, establishes that for any types `α` and `M`, given `M` has zero element, if we have two functions `f` and `g` from `α` to `M` with support (considered as finitely supported functions), and for every `a` in `α`, `f` of `a` equals `g` of `a`, then it implies that function `f` is equal to function `g`. In other words, two finitely supported functions are considered equal if they return the same result for every element in the domain.

If two finitely supported functions from a type to a type with zero element have equal values at every domain element, then they are equal.


theorem Finset.mem_univ : ∀ {α : Type u_1} [inst : Fintype α] (x : α), x ∈ Finset.univ := by sorry

The theorem `Finset.mem_univ` states that for any type `α` which is a finite type (i.e., it has a `Fintype` instance), every element `x` of type `α` belongs to the universal finite set `Finset.univ` of type `Finset α`. In other words, `Finset.univ` includes all possible elements of a finite type.

For any finite type `α`, every element `x` of type `α` belongs to the universal finite set `Finset.univ` of type `Finset α`.


Quotient.inductionOn

/-- The analogue of `Quot.inductionOn`: every element of `Quotient s` is of the form `Quotient.mk s a`.  -/
theorem Quotient.inductionOn :
    ∀ {α : Sort u} {s : Setoid α} {motive : Quotient s → Prop} (q : Quotient s), (∀ (a : α), motive ⟦a⟧) → motive q :=
  by sorry

The `Quotient.inductionOn` theorem states that for any type `α` and any equivalence relation `s` on `α`, for any property `motive` that we might want to prove about elements of the quotient type `Quotient s` and any element `q` of `Quotient s`, if we can prove the property for elements of the form `⟦a⟧` (where `a` is any element of `α`), then we can conclude that the property holds for `q`. In essence, this theorem provides an induction principle to reason about elements in the quotient type `Quotient s`, asserting that every element is in the equivalence class of some `a` from `α`.

Given an equivalence relation `s` on type `α`, if a property `motive` holds for all `⟦a⟧` in `Quotient s` for some `a` in `α`, then the property holds for any `q` in `Quotient s`.


theorem Int.cast_ofNat : ∀ {R : Type u} [inst : AddGroupWithOne R] (n : ℕ), ↑↑n = ↑n := by sorry

This theorem states that for any natural number 'n', the two-step integer casting of 'n' to a type 'R' (which has 'AddGroupWithOne' structure) is the same as the single-step casting of 'n' to 'R'. In other words, if you first cast a natural number to an integer, and then cast that integer to a type 'R' (which is an additive group with an identity element), it's the same as if you cast the natural number directly to 'R'.

For any natural number n, the two-step casting of n to an additive group with an identity element R is equal to the single-step casting of n to R.


theorem Mathlib.Data.Set.Defs._auxLemma.4 :
    ∀ {α : Type u} {β : Type v} {f : α → β} {s : Set β} {a : α}, (a ∈ f ⁻¹' s) = (f a ∈ s) := by sorry

This theorem states that for any types `α` and `β`, for any function `f` from `α` to `β`, for any set `s` of type `β`, and for any element `a` of type `α`, `a` is in the preimage of `s` under `f` if and only if `f(a)` is in `s`. In other words, it says that an element is in the preimage of a set via a function if and only if the image of the element under the function is in the set. This is a fundamental property of the preimage operation in set theory.

For any functions f: α → β, set s ⊆ β, and element a ∈ α, a ∈ f⁻¹(s) if and only if f(a) ∈ s. (The preimage of a set under a function is equal to the set of elements mapping to elements in the set.)


theorem implies_congr_ctx : ∀ {p₁ p₂ q₁ q₂ : Prop}, p₁ = p₂ → (p₂ → q₁ = q₂) → (p₁ → q₁) = (p₂ → q₂) := by sorry

This theorem, `implies_congr_ctx`, states that for any four propositions `p₁`, `p₂`, `q₁`, and `q₂`, if `p₁` is equal to `p₂` and, within the context where `p₂` is true, `q₁` is equal to `q₂`, then the implication `p₁ → q₁` is equivalent to `p₂ → q₂`. Essentially, it establishes that if we change the antecedent and consequent of an implication in a congruent way, the overall truth of the implications remains the same.

If `p₁ = p₂` and `(p₂ ⊢ q₁ = q₂)`, then `(p₁ → q₁) = (p₂ → q₂)`. (In Lean's type theory, `⊢` represents the context in which a judgment is being made.)


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

This theorem, `add_le_add_left`, states that for any type `α` with addition and a less than or equal to order that is covariant under addition, if `b` is less than or equal to `c`, then for any `a`, the sum of `a` and `b` is less than or equal to the sum of `a` and `c`. In simpler terms, if one number `b` is less than or equal to another number `c`, then adding the same number `a` to both `b` and `c` will preserve this inequality.

For all types `α` with covariant addition and order `≤`, if `b ≤ c` then `a + b ≤ a + c`.


AddMonoidHom.ext

theorem AddMonoidHom.ext :
    ∀ {M : Type u_4} {N : Type u_5} [inst : AddZeroClass M] [inst_1 : AddZeroClass N] ⦃f g : M →+ N⦄,
      (∀ (x : M), f x = g x) → f = g :=
  by sorry

The theorem `AddMonoidHom.ext` states that for any two additive monoid homomorphisms `f` and `g` from an add-zero class `M` to another add-zero class `N`, if for every element `x` in `M`, `f(x)` is equal to `g(x)`, then `f` is equal to `g`. In other words, two additive monoid homomorphisms are considered identical if they produce the same result for each element of the domain.

If two additive monoid homomorphisms between add-zero classes map the same element to the same image, then they are equal.


theorem exists_congr : ∀ {α : Sort u_1} {p q : α → Prop}, (∀ (a : α), p a ↔ q a) → ((∃ a, p a) ↔ ∃ a, q a) := by sorry

This theorem, `exists_congr`, is a statement about properties and existence in any sort (a type-like construct in Lean 4). Specifically, it says that for any sort `α`, and any two properties `p` and `q` of elements of `α`, if for every element `a` of `α`, `p` and `q` are equivalent (meaning `p a` if and only if `q a`), then the existence of an element satisfying `p` is equivalent to the existence of an element satisfying `q`. In simpler terms, if two properties are equivalent for all elements of a sort, then an element of the sort satisfies one property if and only if it satisfies the other.

If two properties `p` and `q` are equivalent for all elements of a sort `α`, then the existence of an element of `α` satisfying `p` is equivalent to the existence of an element of `α` satisfying `q`.


Set.Subset.rfl

theorem Set.Subset.rfl : ∀ {α : Type u} {s : Set α}, s ⊆ s := by sorry

This theorem, named `Set.Subset.rfl`, asserts that for any set `s` of a given type `α`, `s` is a subset of itself. In mathematical terms, for all sets `s`, we have `s ⊆ s`. This is a reflection of the reflexivity property of the subset relation in set theory.

For any set `s`, `s` is a subset of `s`. In mathematical notation, `s ⊆ s`.


theorem Set.mem_range_self : ∀ {α : Type u} {ι : Sort u_1} {f : ι → α} (i : ι), f i ∈ Set.range f := by sorry

This theorem, `Set.mem_range_self`, states that for any type `α`, any sort `ι`, and any function `f` from `ι` to `α`, for any element `i` of `ι`, the image of `i` under the function `f` is in the range of `f`. In other words, the image of any element of the domain of a function is always in the range (set of output values) of that function.

For any function `f : ι -> α`, and any `i : ι`, we have `f i in range f`.


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

This theorem, `not_lt`, states that for all types `α` that have a linear order, for any two elements `a` and `b` from this type, `a` is not less than `b` if and only if `b` is less than or equal to `a`. In other words, this theorem defines the relationship between the "not less than" and "less than or equal to" comparison operations in any ordered set.

For all types with a linear order, `a` is not less than `b` if and only if `b` is less than or equal to `a`.


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

This theorem, in the context of a canonically ordered additive commutative monoid, states that zero is less than or equal to any element of the monoid. In more specific terms, for any type `α` that forms a canonically ordered additive commutative monoid, and for any element `a` of this type, it asserts the truth of the inequality `0 ≤ a`.

In a canonically ordered additive commutative monoid, the zero element is less than or equal to every other element.


theorem smul_assoc :
    ∀ {α : Type u_6} {M : Type u_10} {N : Type u_11} [inst : SMul M N] [inst_1 : SMul N α] [inst_2 : SMul M α]
      [inst_3 : IsScalarTower M N α] (x : M) (y : N) (z : α), (x • y) • z = x • y • z :=
  by sorry

This theorem, `smul_assoc`, asserts the associativity of scalar multiplication across three types `M`, `N`, and `α` in a scalar tower context. In particular, for any elements `x` of type `M`, `y` of type `N`, and `z` of type `α`, with `M` being a scalar of `N` and `N` being a scalar of `α`, the result of first performing scalar multiplication of `x` and `y`, and then taking the result to scalar multiply `z`, is the same as the result of first scalar multiplying `y` and `z`, and then letting `x` scale the result. In mathematical notation, it states that $(x \cdot y) \cdot z = x \cdot (y \cdot z)$, where $\cdot$ denotes scalar multiplication.

For any scalars x of type M, y of type N, and z of type α, with M being a scalar of N and N being a scalar of α, the associativity of scalar multiplication holds: (x · y) · z = x · (y · z).


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

The theorem `Set.inter_subset_left` states that for all types `α` and for any two sets `s` and `t` of type `α`, the intersection of `s` and `t` is a subset of `s`. In other words, every element that is both in set `s` and set `t` (i.e., in the intersection of `s` and `t`) is guaranteed to be in set `s`.

For all types α and sets s and t of type α, s ∩ t is a subset of s.


/-- **Alias** of `le_of_le_of_eq`. -/
theorem LE.le.trans_eq : ∀ {α : Type u} {a b c : α} [inst : LE α], a ≤ b → b = c → a ≤ c := by sorry

This theorem, `LE.le.trans_eq`, states that for any type `α` equipped with a "less than or equal to" relation (`≤`), if we have some elements `a`, `b`, and `c` of type `α` such that `a` is less than or equal to `b` (`a ≤ b`), and `b` is equal to `c` (`b = c`), then it follows that `a` is less than or equal to `c` (`a ≤ c`). This theorem is essentially a version of the transitivity property of the `≤` relation, taking into account equality.

If `a ≤ b` and `b = c`, then `a ≤ c`. (The "less than or equal to" relation `≤` is transitive over equality.)


Set.Subset.antisymm

theorem Set.Subset.antisymm : ∀ {α : Type u} {a b : Set α}, a ⊆ b → b ⊆ a → a = b := by sorry

The theorem `Set.Subset.antisymm` states that for all types `α` and for all sets `a` and `b` of type `α`, if `a` is a subset of `b` and `b` is a subset of `a`, then `a` and `b` are equal. This is a formalization of the concept of antisymmetry in the context of set theory. In mathematical terms, given any two sets `a` and `b`, if every element of `a` also belongs to `b` (i.e., `a` is a subset of `b`) and every element of `b` also belongs to `a` (i.e., `b` is a subset of `a`), then `a` and `b` are the same set.

If sets `a` and `b` have the property that every element in `a` is in `b` and every element in `b` is in `a`, then `a` and `b` are equal.


RingHom.ext

theorem RingHom.ext :
    ∀ {α : Type u_2} {β : Type u_3} {x : NonAssocSemiring α} {x_1 : NonAssocSemiring β} ⦃f g : α →+* β⦄,
      (∀ (x_2 : α), f x_2 = g x_2) → f = g :=
  by sorry

This theorem, `RingHom.ext`, states that for any two ring homomorphisms `f` and `g` from a non-associative semiring `α` to another non-associative semiring `β`, if `f` and `g` are equal for every element in semiring `α`, then `f` and `g` are indeed the same function. In other words, two ring homomorphisms are identical if they map each element of the domain semiring to the same element in the codomain semiring.

If two ring homomorphisms between non-associative semirings map every element to the same image, then they are equal as functions.


theorem MeasureTheory.measure_mono :
    ∀ {α : Type u_1} [inst : MeasurableSpace α] {μ : MeasureTheory.Measure α} {s₁ s₂ : Set α},
      s₁ ⊆ s₂ → ↑↑μ s₁ ≤ ↑↑μ s₂ :=
  by sorry

This theorem, `MeasureTheory.measure_mono`, states that for every type `α` that forms a measurable space, given any measure `μ` from the `MeasureTheory.Measure` applied to this type, and any two sets `s₁` and `s₂` of this type, if the set `s₁` is a subset of the set `s₂` (denoted by `s₁ ⊆ s₂`), then the measure of set `s₁` (denoted by `μ s₁`) is less than or equal to the measure of set `s₂` (denoted by `μ s₂`). This theorem is fundamental to measure theory as it implies that the measure of a larger set is always greater than or equal to the measure of its subset.

For any measurable space (α, Σ, μ), if A ⊆ B in Σ then μ(A) ≤ μ(B).


Classical.em

/-- **Diaconescu's theorem**: excluded middle from choice, Function extensionality and propositional extensionality.  -/
theorem Classical.em : ∀ (p : Prop), p ∨ ¬p := by sorry

**Diaconescu's Theorem**: This theorem states that for any proposition `p`, either `p` or `not p` holds true. This is the principle of the excluded middle, which is derived from the axiom of choice, function extensionality, and propositional extensionality. In other words, it asserts that any proposition is either true or its negation is true, leaving no room for a proposition to exist in a state of uncertainty or ambiguity.

For any proposition `p` in Lean 4 logic, either `p` or `not p` holds.


theorem CategoryTheory.cancel_epi :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z : C} (f : X ⟶ Y) [inst_1 : CategoryTheory.Epi f]
      {g h : Y ⟶ Z}, CategoryTheory.CategoryStruct.comp f g = CategoryTheory.CategoryStruct.comp f h ↔ g = h :=
  by sorry

This theorem, `CategoryTheory.cancel_epi`, states that for any category `C`, and any three objects `X`, `Y`, `Z` in `C`, given a morphism `f` from `X` to `Y` that is epi (an epimorphism, meaning that it is surjective or "onto"), and two morphisms `g` and `h` from `Y` to `Z`, the composition of `f` and `g` (`f ≫ g` in category theory notation) is equal to the composition of `f` and `h` (`f ≫ h`) if and only if `g` is equal to `h`.

In simpler terms, if we know that a morphism is an epimorphism, then if composing it with two other morphisms yields the same result, those two morphisms must be identical.

In any category, if an epimorphism's composition with two morphisms is equal, then those morphisms are equal.


theorem dite_congr :
    ∀ {b c : Prop} {α : Sort u_1} {x : Decidable b} [inst : Decidable c] {x_1 : b → α} {u : c → α} {y : ¬b → α}
      {v : ¬c → α} (h₁ : b = c), (∀ (h : c), x_1 ⋯ = u h) → (∀ (h : ¬c), y ⋯ = v h) → dite b x_1 y = dite c u v :=
  by sorry

This theorem, `dite_congr`, states that for any propositions `b` and `c`, a sort `α`, a decidable `b` denoted by `x`, a decidable `c` denoted by `inst`, functions `x_1 : b → α`, `u : c → α`, `y : ¬b → α`, `v : ¬c → α`, if `b` is equal to `c` (expressed by `h₁ : b = c`), and if for all `c`, `x_1` equals `u`, and for all `¬c`, `y` equals `v`, then the application of `dite` (if then else construct) on `b`, `x_1`, `y` equals the application of `dite` on `c`, `u`, `v`. In other words, under these conditions, the 'if-then-else' evaluations of `b` and `c` will be equivalent.

Given decidable propositions `b` and `c`, functions `x_1 : b → α`, `u : c → α`, `y : ¬b → α`, `v : ¬c → α`, and if `b = c`, `x_1 = u` on `c` and `y = v` on `¬c`, then `dite b x_1 y` = `dite c u v`.


Or.imp

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

This theorem states that, given four propositions `a`, `b`, `c`, and `d`, if `a` implies `c` and `b` implies `d`, then `a` OR `b` necessarily implies `c` OR `d`. The implications act as transformation rules: if `a` is true, it would lead to `c` being true, and if `b` is true, it would lead to `d` being true. Hence, if either `a` or `b` is true, then either `c` or `d` must be true as well.

If `a` implies `c` and `b` implies `d`, then `a` or `b` implies `c` or `d`.


theorem or_self : ∀ (p : Prop), (p ∨ p) = p := by sorry

This theorem states that for any proposition `p`, the logical disjunction of `p` and `p` is equivalent to `p` itself. In other words, in terms of classical logic, if you say "Either `p` is true, or `p` is true," you are essentially just saying "`p` is true". This is a fundamental property of the "or" operator in logic.

For any proposition `p` in Lean, `p` or `p` is logically equivalent to `p`.


Quot.inductionOn

theorem Quot.inductionOn :
    ∀ {α : Sort u} {r : α → α → Prop} {motive : Quot r → Prop} (q : Quot r),
      (∀ (a : α), motive (Quot.mk r a)) → motive q :=
  by sorry

This theorem is called 'Quotient Induction On', and it states that for any type `α`, a relation `r` on `α`, and a property `motive` defined on the quotient of `α` by `r`, if we know that this property holds for every element `a` of type `α` under the quotient mapping `Quot.mk r a`, then the property also holds for any element `q` in the quotient type `Quot r`. Essentially, it allows reasoning on the quotient type by considering representatives of each equivalence class under the relation `r`.

If a property `motive` holds for all representatives `Quot.mk r a` of every equivalence class under relation `r` on type `α`, then the property holds for all elements `q` in the quotient type `Quot r`.


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

This theorem states that for any linearly ordered type `α` and any two elements `a` and `b` of this type, `a` is not less than or equal to `b` if and only if `b` is less than `a`. In other words, in a linear order, the assertion that `a` is not less than or equal to `b` is equivalent to asserting that `b` is strictly less than `a`.

In a linearly ordered type, `a` is not less than or equal to `b` if and only if `b` is strictly less than `a`.


theorem two_mul : ∀ {α : Type u} [inst : NonAssocSemiring α] (n : α), 2 * n = n + n := by sorry

This theorem states that for all types 'α' that have the structure of a 'NonAssocSemiring' (which is a mathematical structure like a ring but without the requirement that multiplication is associative), the multiplication of any element 'n' of this type by 2 is equivalent to adding 'n' to itself. In other words, for all 'n' in such a semiring, `2 * n = n + n`.

For any non-associative semiring 'α', the multiplication of an element 'n' by 2 is equivalent to adding 'n' to itself: 2 * n = n + n.


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

This theorem, `neg_add_rev`, states that for any type `G` that is a subtraction monoid, the additive inverse of the sum of two elements `a` and `b` (i.e., `-(a + b)`) is equal to the sum of the additive inverses of `b` and `a` (i.e., `-b + -a`). This is basically a restatement in a monoid context of the well-known property from elementary mathematics that the negation of a sum can be distributed over the summands.

For any subtraction monoid `G`, the additive inverse of `a + b` equals `-a + -b`.


theorem Mathlib.Order.Basic._auxLemma.2 : ∀ {α : Type u} [inst : Preorder α] (x : α), (x < x) = False := by sorry

This theorem, `Mathlib.Order.Basic._auxLemma.2`, states that for any type `α` where a preorder is defined, for any element `x` of that type, the proposition that `x` is less than itself is false. In other words, it establishes the irreflexivity of the "less than" relation in a preorder, i.e., no element in the set can be less than itself.

In any preorder, no element is less than itself.


theorem compl_compl : ∀ {α : Type u} [inst : BooleanAlgebra α] (x : α), xᶜᶜ = x := by sorry

This theorem states that for all types `α` that have a `BooleanAlgebra` structure, the double complement of an element `x` from `α` is equal to `x`. In mathematical terms, this corresponds to the widely applicable principle that the double negation of a proposition is the proposition itself.

For all types `α` with a `BooleanAlgebra` structure, the double negation of an element `x` equals `x`.


Function.Surjective.forall

theorem Function.Surjective.forall :
    ∀ {α : Sort u_1} {β : Sort u_2} {f : α → β},
      Function.Surjective f → ∀ {p : β → Prop}, (∀ (y : β), p y) ↔ ∀ (x : α), p (f x) :=
  by sorry

The theorem `Function.Surjective.forall` states that for all types `α` and `β` and for any function `f` from `α` to `β`, if `f` is surjective, then for any property `p` defined on `β`, `p` holds for all elements of `β` if and only if `p` holds for all elements of `α` when applied to `f(x)`. In other words, a property is true for all of `β` if it is true for all of the images of `α` under a surjective function `f`.

If `f : α → β` is a surjective function, then for any property `p` on `β`, `∀x ∈ β, p(x) ↔ ∀x ∈ α, p(f(x))`.


/-- **Alias** of `zpow_natCast`. -/
theorem zpow_coe_nat : ∀ {G : Type u_1} [inst : DivInvMonoid G] (a : G) (n : ℕ), a ^ ↑n = a ^ n := by sorry

This is a theorem about exponentiation in a division and inversion monoid (a type of mathematical structure). This theorem states that for any element `a` of type `G` (where `G` is a division and inversion monoid) and any natural number `n`, raising `a` to the power of the coercion of `n` to an integer is the same as raising `a` to the power of `n`. In other words, it doesn't matter whether we treat `n` as a natural number or an integer when doing exponentiation in this context.

For any division and inversion monoid `G` and any natural number `n`, the exponentiation `a ^ (coe n)` is equal to `a ^ n`, where `a` is an element of `G`.


theorem continuous_fst :
    ∀ {X : Type u} {Y : Type v} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y], Continuous Prod.fst := by
  sorry

This theorem, `continuous_fst`, states that for any two types `X` and `Y` equipped with topological spaces (denoted by `inst : TopologicalSpace X` and `inst_1 : TopologicalSpace Y`), the function `Prod.fst`, which projects an ordered pair to its first component, is continuous. In other words, if we have a pair from the Cartesian product of `X` and `Y`, taking the first component of the pair and mapping it back to `X` preserves topological properties. In mathematical terms, if `p : X × Y`, then the function `p ↦ p.1` is continuous.

The function `Prod.fst` from a Cartesian product `X × Y` equipped with product topology to `X` is continuous.


theorem and_comm : ∀ {a b : Prop}, a ∧ b ↔ b ∧ a := by sorry

This theorem, `and_comm`, states that for all propositions `a` and `b`, the logical conjunction of `a` and `b` is equivalent to the logical conjunction of `b` and `a`. In other words, the order does not matter in the 'and' operation; `a` and `b` is the same as `b` and `a`. This property is known as commutativity, hence the name `and_comm`.

For all propositions `a` and `b`, `(a ∧ b)` is equivalent to `(b ∧ a)`.


theorem map_sum :
    ∀ {α : Type u_3} {β : Type u_4} {γ : Type u_5} [inst : AddCommMonoid β] [inst_1 : AddCommMonoid γ] {G : Type u_6}
      [inst_2 : FunLike G β γ] [inst_3 : AddMonoidHomClass G β γ] (g : G) (f : α → β) (s : Finset α),
      g (Finset.sum s fun x => f x) = Finset.sum s fun x => g (f x) :=
  by sorry

This theorem, `map_sum`, states that for any types `α`, `β`, `γ` and `G`, with `β` and `γ` being additive commutative monoids, and `G` being a function-like type from `β` to `γ` with a additive monoid homomorphism, and for any function `g : G`, function `f : α → β` and finite set `s : Finset α`, applying the function `g` to the sum of the results of applying `f` to each element in `s` is the same as first applying `f` to each element in `s`, then applying `g` to each result, and finally summing these results. In mathematical terms, this can be represented as $g(\sum_{x\in s} f(x)) = \sum_{x\in s} g(f(x))$. This is a property of homomorphisms in the context of additive commutative monoids.

For any additive commutative monoids β and γ, additive monoid homomorphism G: β -> γ, and function f: α -> β, the map G o (∑ x in s. f x) equals ∑ x in s. (G o f x), where s is a finite set and ∑ denotes summation.


theorem not_congr : ∀ {a b : Prop}, (a ↔ b) → (¬a ↔ ¬b) := by sorry

This theorem, `not_congr`, states that for any two propositions `a` and `b`, if `a` is logically equivalent to `b` (denoted as `a ↔ b`), then the negation of `a` (denoted as `¬a`) is also logically equivalent to the negation of `b` (denoted as `¬b`). In other words, if two statements are equivalent, their negations are also equivalent.

If `a` is logically equivalent to `b`, then the negations `¬a` and `¬b` are logically equivalent.


theorem lt_irrefl : ∀ {α : Type u} [inst : Preorder α] (a : α), ¬a < a := by sorry

This theorem, named `lt_irrefl`, states that for any type `α` that has a preorder (a relation that is reflexive and transitive), an element of that type cannot be strictly less than itself. In other words, it is impossible for `a` to be less than `a` in any preordered set. This is a fundamental property of orderings in mathematics, often referred to as irreflexivity.

In any preordered type, no element is strictly less than itself.


Units.ext

theorem Units.ext : ∀ {α : Type u} [inst : Monoid α], Function.Injective Units.val := by sorry

The theorem `Units.ext` states that for all types `α` that have a `Monoid` structure, the function `Units.val` which gets the underlying value in the base `Monoid`, is injective. In other words, if two elements of the type `αˣ` (the units of the monoid `α`) have the same underlying value in the base `Monoid`, then they are the same element.

For any type `α` with a `Monoid` structure, the function `Units.val` mapping the units of `α` to their underlying values in the base `Monoid` is an injection.


theorem Set.subset_univ : ∀ {α : Type u} (s : Set α), s ⊆ Set.univ := by sorry

This theorem, named `Set.subset_univ`, states that for any given type `α` and any set `s` of type `α`, `s` is a subset of the universal set `Set.univ` of type `α`. In other words, every element of the set `s` is also an element of the universal set `Set.univ`. Here, the symbol `⊆` denotes the subset relation. This is a fundamental property of universal sets, conforming to the idea that a universal set contains all elements of a given type.

For any type α and set s of type α, s is a subset of the universal set Set.univ of type α. (Written mathematically: s ⊆ Set.univ)


theorem dite_cond_eq_true :
    ∀ {α : Sort u} {c : Prop} {x : Decidable c} {t : c → α} {e : ¬c → α} (h : c = True), dite c t e = t ⋯ := by sorry

This theorem states that for any type `α`, proposition `c`, decidable instance `x` of `c`, function `t` from `c` to `α`, and function `e` from the negation of `c` to `α`, if `c` is equal to `True`, then the expression `dite c t e`, which chooses between `t` and `e` based on the truth of `c`, is equal to `t`. In other words, when the condition `c` is true, `dite` expression will select the first function `t`.

For any decidable proposition `c` of type `Prop`, function `t : c → α`, and function `e : ¬c → α`, if `c` holds, then `dite c t e = t`.


theorem smul_add :
    ∀ {M : Type u_1} {A : Type u_4} [inst : AddZeroClass A] [inst_1 : DistribSMul M A] (a : M) (b₁ b₂ : A),
      a • (b₁ + b₂) = a • b₁ + a • b₂ :=
  by sorry

This theorem, `smul_add`, states that for any types `M` and `A`, given that `A` is an `AddZeroClass` and there exists a scalar multiplication (`DistribSMul`) operation from `M` to `A`, the scalar product of `a`, an instance of `M`, with the addition of `b₁` and `b₂`, instances of `A`, is equal to the sum of the scalar product of `a` with `b₁` and the scalar product of `a` with `b₂`. In mathematical notation, for any scalar `a` and vectors `b₁`, `b₂`, we have: `a • (b₁ + b₂) = a • b₁ + a • b₂`. This is one of the standard axioms for a vector space.

For any type `M` with scalar multiplication `DistribSMul` over an additive zero class `A`, the scalar product of an element `a` from `M` with the sum of two elements `b₁` and `b₂` from `A` equals the sum of the scalar products of `a` with `b₁` and `b₂`.


theorem inv_one : ∀ {G : Type u_1} [inst : InvOneClass G], 1⁻¹ = 1 := by sorry

This theorem, `inv_one`, states that for any given type `G` with an instance of the `InvOneClass` (meaning `G` has definitions for inversion and the number one), the inverse of one is always equal to one. This is a general property that holds in many mathematical structures, such as groups, fields, and rings where the element "one" is defined and has an inverse. In Layman's terms, turning one upside down (or taking its inverse) still gives you one.

For any type `G` with an `InvOneClass`, the inverse of `1` in `G` equals `1`.


theorem sub_eq_zero : ∀ {G : Type u_3} [inst : AddGroup G] {a b : G}, a - b = 0 ↔ a = b := by sorry

This theorem states that for any type `G` that is an additive group, the result of subtraction operation `a - b` is zero if and only if `a` and `b` are equal. In other words, within any additive group, the difference between two elements is zero exactly when those two elements are the same.

In any additive group, for all elements `a` and `b`, `a - b = 0` if and only if `a = b`.


theorem not_iff_not : ∀ {a b : Prop}, (¬a ↔ ¬b) ↔ (a ↔ b) := by sorry

This theorem states that for any two propositions 'a' and 'b', the equivalence of the negations of 'a' and 'b' (¬a is equivalent to ¬b) if and only if 'a' is equivalent to 'b'. That is, if 'a' and 'b' are either both true or both false, then their negations are also both true or both false, and conversely, if the negations of 'a' and 'b' are both true or both false, then 'a' and 'b' are also both true or both false.

The negations of propositions 'a' and 'b' are equivalent if and only if 'a' and 'b' are logically equivalent.


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

This theorem, named `le_max_left`, states that for all types `α` that have a linear order, for any two elements `a` and `b` of type `α`, `a` is less than or equal to the maximum of `a` and `b`. In other words, for any two elements in a linearly ordered set, one of the elements is always less than or equal to the maximum of the two elements.

For all types `α` with a linear order and any `a, b` in `α`, `a ≤ max a b`.


Continuous.continuousOn

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

The theorem `Continuous.continuousOn` asserts that for any two topological spaces `α` and `β`, and a function `f` from `α` to `β`, if `f` is continuous over the entire domain `α`, then `f` is also continuous on any subset `s` of its domain. In mathematical terms, if a function is continuous in a topological sense, then it remains continuous when restricted to any subset of its original domain.

If a function is continuous on its entire domain, then it is continuous on any of its subsets.


MonoidHom.ext

theorem MonoidHom.ext :
    ∀ {M : Type u_4} {N : Type u_5} [inst : MulOneClass M] [inst_1 : MulOneClass N] ⦃f g : M →* N⦄,
      (∀ (x : M), f x = g x) → f = g :=
  by sorry

This theorem, `MonoidHom.ext`, states that for any two types `M` and `N` that are instances of the `MulOneClass` (which means they have multiplication and one-element, i.e., they are monoids), if we have two homomorphisms `f` and `g` from `M` to `N`, and for all elements `x` of `M`, `f(x)` is equal to `g(x)`, then `f` and `g` must be the same homomorphism. In simpler terms, two homomorphisms between two monoids are equivalent if they give the same result for every element of the source monoid.

If `M` and `N` are monoids, and `f` and `g` are homomorphisms from `M` to `N` such that `f(x) = g(x)` for all `x` in `M`, then `f` and `g` are equal.


MeasureTheory.Measure.ext

theorem MeasureTheory.Measure.ext :
    ∀ {α : Type u_1} [inst : MeasurableSpace α] {μ₁ μ₂ : MeasureTheory.Measure α},
      (∀ (s : Set α), MeasurableSet s → ↑↑μ₁ s = ↑↑μ₂ s) → μ₁ = μ₂ :=
  by sorry

The theorem `MeasureTheory.Measure.ext` establishes the uniqueness of measures in a measurable space. Specifically, for a given measurable space `α`, if two measures `μ₁` and `μ₂` agree on the measure of every measurable set `s`, i.e., `μ₁ s = μ₂ s` for all `s` such that `s` is a measurable set, then the two measures `μ₁` and `μ₂` are identical, i.e., `μ₁ = μ₂`. This means that a measure is entirely determined by its values on measurable sets.

If two measures agree on all measurable sets in a measurable space, then they are equal.


theorem Set.mem_singleton : ∀ {α : Type u} (a : α), a ∈ {a} := by sorry

This theorem, `Set.mem_singleton`, states that for any type `α` and any element `a` of type `α`, `a` is a member of the set that contains only `a`. In other words, `a` is an element of the singleton set `{a}`.

For any type `α` and element `a` of type `α`, `a` is an element of the singleton set `{a}`. Equivalently, the singleton set `{a}` contains `a` as an element.


theorem continuous_snd :
    ∀ {X : Type u} {Y : Type v} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y], Continuous Prod.snd := by
  sorry

This theorem, `continuous_snd`, states that for all types `X` and `Y` where `X` and `Y` are equipped with a topological space structure (denoted by `inst` and `inst_1` respectively), the second projection function `Prod.snd` is continuous. In mathematical terms, this means that if we have a product space `X × Y`, the function that maps each pair to the second element of the pair is a continuous function.

The second projection function of a product of topological spaces is continuous.


/-- In any concrete category, we can test equality of morphisms by pointwise evaluations. -/
theorem CategoryTheory.ConcreteCategory.hom_ext :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.ConcreteCategory C] {X Y : C}
      (f g : X ⟶ Y), (∀ (x : (CategoryTheory.forget C).obj X), f x = g x) → f = g :=
  by sorry

This theorem states that in any concrete category, we can compare the equality of morphisms by evaluating them pointwise. Specifically, given a concrete category `C` and two morphisms `f` and `g` from object `X` to object `Y` in `C`, if for every element `x` in the underlying set of `X`, the application of `f` and `g` to `x` yields the same result, then the morphisms `f` and `g` are equal in `C`. In essence, this is a formal way of saying that if two functions behave the same way on all inputs, they are indeed the same function.

In a concrete category, two morphisms from an object to another are equal if and only if they map every object element to the same image.


theorem CategoryTheory.Iso.inv_hom_id_assoc :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} (self : X ≅ Y) {Z : C} (h : Y ⟶ Z),
      CategoryTheory.CategoryStruct.comp self.inv (CategoryTheory.CategoryStruct.comp self.hom h) = h :=
  by sorry

This theorem is in the field of Category Theory and it states that for any category `C` and any two objects `X` and `Y` in `C`, given an isomorphism `self` between `X` and `Y`, and a morphism `h` from `Y` to another object `Z` in `C`, the composition of the inverse of `self` with the composition of `self` and `h` is equal to `h`. In mathematical terms, it states that for an isomorphism `f: X → Y` with inverse `f⁻¹: Y → X`, we have `f⁻¹ ∘ (f ∘ h) = h` for any morphism `h: Y → Z`. This theorem essentially encapsulates the property of isomorphisms that reversing an isomorphism and then following it gives the identity, in the context of additional composition with a morphism `h`.

For any isomorphism $f:X \rightarrow Y$ in a category with inverse $f^{-1}:Y \rightarrow X$, and any morphism $h:Y \rightarrow Z$, we have $f^{-1} \circ (f \circ h) = h$.


theorem neg_sub : ∀ {α : Type u_1} [inst : SubtractionMonoid α] (a b : α), -(a - b) = b - a := by sorry

This theorem, named `neg_sub`, states that for all types `α` in an instance of a subtraction monoid, the negation of the difference of two elements `a` and `b` equals the difference of `b` and `a`. In other words, for any elements `a` and `b` in `α`, `- (a - b) = b - a`. This theorem captures the property of subtraction monoids that swapping the operands of subtraction and then negating the result gives the same outcome as the original subtraction operation.

For all types `α` in a subtraction monoid and all `a, b` in `α`, `- (a - b) = b - a`.


theorem Nat.succ_pos : ∀ (n : ℕ), 0 < Nat.succ n := by sorry

This theorem states that for every natural number `n`, the succeeding number (`Nat.succ n`) is greater than zero. In other words, the successor of any natural number is always positive.

For every natural number `n`, `Nat.succ n` is positive. (Alternatively, `Nat.succ n` > 0.)


theorem Mathlib.Data.SetLike.Basic._auxLemma.3 :
    ∀ {A : Type u_1} {B : Type u_2} [i : SetLike A B] {p : A} {x : B}, (x ∈ ↑p) = (x ∈ p) := by sorry

This theorem states that for any types `A` and `B`, given a `SetLike` instance `i` between `A` and `B`, and for any object `p` of type `A` and `x` of type `B`, the statement "`x` is in the set corresponding to `p`" is equivalent to the statement "`x` is in `p`". In mathematical terms, if `A` and `B` are sets and `p` is an element of `A`, then `x` belonging to the set corresponding to `p` is the same as `x` belonging to `p`.

For any type `A` and `B`, and for any `SetLike` instance `i` between them, and for any `p : A` and `x : B`, `x ∈ i.toSet p` if and only if `x ∈ p`.


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

This theorem, `sub_add_cancel`, states that for any type `G` that forms an additive group, for any two elements `a` and `b` of that type, subtracting `b` from `a` and then adding `b` back results in `a`. In mathematical terms, this is expressing the identity `a - b + b = a` for all `a` and `b` in an additive group `G`.

For all additive groups `G` and elements `a, b` in `G`, `a - b + b = a`.


theorem Nat.lt_succ_self : ∀ (n : ℕ), n < Nat.succ n := by sorry

This theorem states that for any natural number `n`, `n` is less than the successor of `n`. In terms of ordinary mathematical notation, this is saying that ∀n ∈ ℕ, n < n + 1. Essentially, any number is always less than the next number.

For all natural numbers `n`, `n` is less than `n + 1`.


theorem tendsto_const_nhds :
    ∀ {X : Type u} {α : Type u_1} {x : X} [inst : TopologicalSpace X] {f : Filter α},
      Filter.Tendsto (fun x_1 => x) f (nhds x) :=
  by sorry

The theorem `tendsto_const_nhds` states that for any topological space `X`, any filter `f` on a type `α`, and any element `x` of `X`, the constant function that sends any element to `x` is continuous at `x` with respect to the filter `f` and the neighborhood filter at `x`. In other words, for every neighborhood of `x`, the preimage of this neighborhood under the constant function is in the filter `f`, thus indicating that the function "converges" to `x` according to the filter `f`.

For any topological space X, filter f on α, and x ∈ X, the constant function from α to x is continuous at x with respect to filter f iff for every neighborhood V of x in X, the preimage x⁁⁻¹(V) is in the filter f.


theorem Mathlib.Data.Set.Defs._auxLemma.7 :
    ∀ {α : Type u} {ι : Sort u_1} {f : ι → α} {x : α}, (x ∈ Set.range f) = ∃ y, f y = x := by sorry

The theorem `Mathlib.Data.Set.Defs._auxLemma.7` states that for any type `α` and sort `ι`, given a function `f` from `ι` to `α` and an element `x` of type `α`, `x` is in the range of `f` if and only if there exists an element `y` of type `ι` such that `f(y) = x`. In other words, an element is in the range of a function if it's the image of some input to the function.

For any function from a type to another type, an element is in the range if and only if it is the image of some input element.


/-- **Alias** of `not_lt_of_le`. -/
theorem LE.le.not_lt : ∀ {α : Type u} [inst : Preorder α] {a b : α}, a ≤ b → ¬b < a := by sorry

This theorem, also known as an alias of `not_lt_of_le`, states that for any type `α` that has a preorder, and for any two elements `a` and `b` of type `α`, if `a` is less than or equal to `b` then `b` is not less than `a`. In other words, if `a` is less than or equal to `b`, it is not possible for `b` to be less than `a` in the context of a preorder.

 For any preorder (α, ≤), if a ≤ b then ∥ b < a \SyntaxError: unable to parse '∥ b < a'

In Lean, use `not.lt` instead of `<` for the negation of the less-than relation in a preorder context:

For any preorder (α, ≤), if a ≤ b then ∥ b < a \SyntaxError: unable to parse '∥ b < a'

Correctly stated:
For any preorder (α, ≤), if a ≤ b then ∀ (h : a ≤ b), ¬ (b < a) (using not.lt instead of <)

So, the theorem statement can be concisely expressed as:
In a preorder (α, ≤), if a ≤ b, then b cannot be less than a.


sq

/-- **Alias** of `pow_two`.

---

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

This theorem, known as an alias of `pow_two`, states that for any given type `M` that is a monoid, the square (`^ 2`) of any element (`a`) of `M` is equal to the element multiplied by itself (`a * a`). Most of the lemmas about powers of two refer to this as `sq`.

For any monoid M and its element a, the square of a (a ^ 2) equals the product of a with itself (a * a).


theorem Nat.le_of_not_lt : ∀ {a b : ℕ}, ¬a < b → b ≤ a := by sorry

This theorem states that for any two natural numbers `a` and `b`, if it is not true that `a` is less than `b`, then `b` must be less than or equal to `a`. In other words, in the natural numbers, not being less than implies being greater than or equal to.

If `a` is not less than `b` in the natural numbers, then `b` is less than or equal to `a`.


theorem mul_inv_rev : ∀ {G : Type u_1} [inst : DivisionMonoid G] (a b : G), (a * b)⁻¹ = b⁻¹ * a⁻¹ := by sorry

This theorem, named `mul_inv_rev`, states that for any type `G` that forms a Division Monoid, the multiplicative inverse of the product of two elements `a` and `b` in `G`, is equal to the product of the inverse of `b` and the inverse of `a`. In traditional mathematical notation, this theorem says that for any `a`, `b` in a Division Monoid `G`, (ab)⁻¹ = b⁻¹a⁻¹. This is the reverse order of multiplication of the inverses, hence the name `mul_inv_rev`.

For any division monoid `G` and elements `a`, `b` in `G`, the multiplicative inverse of their product is equal to the product of their inverses in reverse order: (ab)⁻¹ = b⁻¹a⁻¹.


theorem Set.singleton_subset_iff : ∀ {α : Type u} {a : α} {s : Set α}, {a} ⊆ s ↔ a ∈ s := by sorry

The theorem `Set.singleton_subset_iff` is a statement about sets in a general type `α`. It states that for any element `a` of type `α` and any set `s` of type `α`, the singleton set containing only `a` is a subset of `s` if and only if `a` is an element of `s`. In other words, all the elements of the singleton set `{a}` (which is just `a` itself) are in `s` exactly when `a` is in `s`. This theorem provides a way to relate the subset relation and the membership relation for singleton sets.

A set {a} is a subset of set s if and only if a is an element of s.


theorem Set.univ_inter : ∀ {α : Type u} (a : Set α), Set.univ ∩ a = a := by sorry

This theorem states that for all types `α` and for any set `a` of type `α`, the intersection of the universal set `Set.univ` with the set `a` is equal to `a` itself. In other words, when you intersect any set with the universal set (which contains all elements of the type), you simply get the original set back. In mathematical notation, this can be written as: ∀α, ∀a ∈ Set α, Set.univ ∩ a = a.

For all types `α` and sets `a` of type `α`, the intersection of the universal set `Set.univ` with `a` equals `a` (i.e., `Set.univ ∩ a = a`).


theorem DFunLike.ext_iff :
    ∀ {F : Sort u_1} {α : Sort u_2} {β : α → Sort u_3} [i : DFunLike F α β] {f g : F}, f = g ↔ ∀ (x : α), f x = g x :=
  by sorry

This theorem, `DFunLike.ext_iff`, states that for any two dependent function-like structures `f` and `g` of type `F`, with `α` as the input sort and `β` as the function from `α` to a sort `u_3`, they are equal if and only if they return the same output for every input `x` of type `α`. This is a fundamental property of function-like structures in type theory, encapsulating a version of the 'extensionality' axiom for dependent functions.

Two dependent function-like structures of type `F` with input sort `α` and output sort `u_3`, `f` and `g`, are equal if and only if for all `x` of type `α`, `f x = g x`.


theorem add_le_add_right :
    ∀ {α : Type u_1} [inst : Add α] [inst_1 : LE α]
      [i : CovariantClass α α (Function.swap fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] {b c : α},
      b ≤ c → ∀ (a : α), b + a ≤ c + a :=
  by sorry

The theorem `add_le_add_right` in Lean 4 states that for any type `α` that has an addition operation (`Add α`) and a less or equal to relation (`LE α`), and for this type if it holds that swapping the order of two arguments of the addition operation does not change the order of the relation (which is the property described by the `CovariantClass`), then for any two elements `b` and `c` of this type such that `b` is less than or equal to `c`, and for any other element `a` of this type, the inequality `b + a ≤ c + a` is always true. In other words, adding the same value to both sides of an inequality does not affect the inequality.

For types `α` with covariant addition `(Add α)` and order relation `(LE α)`, if swapping addends preserves the order, then for all `a`, `b`, and `c` in `α` with `b ≤ c`, we have `b + a ≤ c + a`.


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

This theorem states that for any type `R` that is an instance of the `AddGroupWithOne` typeclass, casting the integer `1` to `R` results in `1` in `R`. The `AddGroupWithOne` typeclass is a type that has both addition and `1` as an identity element for multiplication. Thus, this theorem is essentially stating that the identity element for multiplication in the integers (`1`) is the same as the identity element for multiplication in any additive group with an identity for multiplication (`1`).

For any additive group with identity element for multiplication `R`, the conversion of the integer `1` to `R` equals the multiplicative identity `1` in `R`.


theorem Or.resolve_right : ∀ {a b : Prop}, a ∨ b → ¬b → a := by sorry

This theorem, named "Or.resolve_right", states that for any two propositions `a` and `b`, if `a` OR `b` is true and `b` is not true (denoted as ¬b), then `a` must be true. Essentially, it resolves a disjunction from the right, eliminating the possibility of the right-hand proposition being true, and concluding that the left-hand proposition has to be true.

If `a` OR `b` is true and `b` is false, then `a` is true.


theorem Set.eq_empty_or_nonempty : ∀ {α : Type u} (s : Set α), s = ∅ ∨ Set.Nonempty s := by sorry

This theorem states that for any set `s` of a certain type `α`, the set `s` is either equal to the empty set or it is not empty (i.e., it has at least one element). In other words, any set is either empty or nonempty, there is no third option. This is a formal logical expression of the law of the excluded middle for sets. Here, `Set.Nonempty s` is a way of saying that there exists an element `x` such that `x` belongs to `s`.

Every set is nonempty or equal to the empty set.


theorem CategoryTheory.Limits.limit.lift_π :
    ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] {C : Type u} [inst_1 : CategoryTheory.Category.{v, u} C]
      {F : CategoryTheory.Functor J C} [inst_2 : CategoryTheory.Limits.HasLimit F] (c : CategoryTheory.Limits.Cone F)
      (j : J),
      CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.limit.lift F c) (CategoryTheory.Limits.limit.π F j) =
        c.π.app j :=
  by sorry

The theorem `CategoryTheory.Limits.limit.lift_π` asserts that for any category `J`, any category `C`, any functor `F` from `J` to `C` that has a limit, any cone `c` of `F`, and any object `j` of `J`, the composition of the morphism from the cone point of `c` to the limit object of `F` (given by `CategoryTheory.Limits.limit.lift F c`) and the projection from the limit object of `F` to the `j`th value of the functor `F` (given by `CategoryTheory.Limits.limit.π F j`) is the same as the `j`th component of the natural transformation from the vertex of the cone `c` to the functor `F` (given by `c.π.app j`).

In terms of category theory, this is a way of saying that the limit of a functor is a universal cone over that functor: any other cone factors uniquely through the limit cone.

For any functor with a limit, the limit object and cone projection morphisms make the limit a universal cone over the functor, meaning the limit projection to any object in the base category is equal to the composition of the projection from the limit object to that object and the cone morphism from the vertex to the functor.


/-- Definition of `HasBasis` unfolded with implicit set argument.  -/
theorem Filter.HasBasis.mem_iff :
    ∀ {α : Type u_1} {ι : Sort u_4} {l : Filter α} {p : ι → Prop} {s : ι → Set α} {t : Set α},
      Filter.HasBasis l p s → (t ∈ l ↔ ∃ i, p i ∧ s i ⊆ t) :=
  by sorry

The theorem `Filter.HasBasis.mem_iff` provides a condition for the membership of a set `t` in a filter `l`. This condition is based on the concept of a basis of a filter. For any types `α` and `ι`, a filter `l` on `α`, a property `p` of `ι`, and a function `s` from `ι` to the set of `α`, the theorem states that if the filter `l` has a basis characterized by `p` and `s`, then the set `t` is in the filter `l` if and only if there exists an `i` such that `p i` holds and the set `s i` is a subset of `t`.

A set `t` belongs to a filter `l` with basis `(p : ∀ i, Prop ι)` and `s : ∀ i, α → α` if and only if there exists an `i` such that `p i` holds and `s i ⊆ t`.


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

This theorem states that for any type `α` and for any two sets `s` and `t` of type `α`, the intersection of `s` and `t` is a subset of `t`. More formally, for any element of `α`, if it is in both `s` and `t` (i.e., it is in the intersection of `s` and `t`), then it is in `t`. This is a fundamental property of set intersection in mathematics.

For any sets `s` and `t` of type `α`, the intersection of `s` and `t` is a subset of `t`. In other words, for all `x` in `α`, if `x` is in `s` and `x` is in `t`, then `x` is in `t`.


theorem sup_le : ∀ {α : Type u} [inst : SemilatticeSup α] {a b c : α}, a ≤ c → b ≤ c → a ⊔ b ≤ c := by sorry

This theorem, `sup_le`, states that for any type `α` that forms a semilattice with the join operation `⊔`, and any three elements `a`, `b`, and `c` of this type, if `a` and `b` are both less than or equal to `c`, then the join (`⊔`) of `a` and `b` is also less than or equal to `c`. In other words, the least upper bound (`sup`, signified by `⊔`) of two elements in a semilattice that are both less than or equal to a third element, is itself less than or equal to that third element.

For any semilattice `α` with join operation `⊔`, and any elements `a`, `b`, and `c` in `α`, if `a ≤ c` and `b ≤ c`, then `a ⊔ b ≤ c`.


NNReal.eq

theorem NNReal.eq : ∀ {n m : NNReal}, ↑n = ↑m → n = m := by sorry

This theorem states that for any two nonnegative real numbers `n` and `m`, if the underlying real number representation of `n` (denoted by `↑n`) is equal to the underlying real number representation of `m` (denoted by `↑m`), then `n` is equal to `m`. In other words, it asserts the injectivity of the inclusion map from the nonnegative real numbers to the real numbers.

If two non-negative real numbers have the same underlying real number representation, then they are equal.


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

This theorem states that for any proposition `a`, the double negation of `a` is equivalent to `a`. In other words, not not `a` is the same as `a`. This is a fundamental theorem in classical logic, also known as the law of double negation.

In classical logic, the double negation of a proposition `a` is equivalent to `a`.


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

This theorem states that for all natural numbers `n` and `m`, the sum of `n` and `m` is equal to the sum of `m` and `n`. In other words, it asserts the commutative property of addition for natural numbers, that is, the order in which natural numbers are added doesn't affect the result. This can be expressed in LaTeX as: ∀ (n, m ∈ ℕ), n + m = m + n.

The theorem asserts the commutativity of natural number addition: for all natural numbers `n` and `m`, `n + m = m + n`.


/-- **Alias** of `Left.mul_pos`.

---

Assumes left covariance.  -/
theorem mul_pos :
    ∀ {α : Type u_1} {a b : α} [inst : MulZeroClass α] [inst_1 : Preorder α] [inst_2 : PosMulStrictMono α],
      0 < a → 0 < b → 0 < a * b :=
  by sorry

The theorem `mul_pos` is an alias of `Left.mul_pos` and it assumes left covariance. The theorem is defined for any type `α` that has a multiplication operation, a zero element, and a strict preorder relation, and the multiplication operation should strictly increase when you multiply by a positive element on the left side. If `a` and `b` are elements of the type `α` and both `a` and `b` are greater than zero, then the product `a * b` is also greater than zero.

If `α` is a type with multiplication, zero, and a strict preorder such that `a * b` strictly increases with positive elements on the left, then for all positive elements `a` and `b` in `α`, `a * b` is also positive.


HasSubset.Subset.antisymm

/-- **Alias** of `subset_antisymm`. -/
theorem HasSubset.Subset.antisymm :
    ∀ {α : Type u} [inst : HasSubset α] {a b : α} [inst_1 : IsAntisymm α fun x x_1 => x ⊆ x_1], a ⊆ b → b ⊆ a → a = b :=
  by sorry

This theorem, which serves as an alias of `subset_antisymm`, states that for any type `α` that has a subset operation and an antisymmetry property with respect to this operation, if `a` is a subset of `b` and `b` is a subset of `a`, then `a` is equal to `b`. This theorem encapsulates the antisymmetry property of subsets: in the context of set theory, if two sets each include all elements of the other, they must be the same set.

If `a` is a subset of `b` and `b` is a subset of `a`, then `a` equals `b`.


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

This theorem, `le_or_lt`, states that for any type `α` that has a linear order, given two elements `a` and `b` of this type, it is always the case that either `a` is less than or equal to `b` or `b` is less than `a`. In other words, in any linear order, any two elements are either in their natural order or reverse order; there is no third option.

For any linear ordered type `α`, for all `a` and `b` in `α`, either `a ≤ b` or `b < a`.


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

This theorem states that for any pseudo metric space, the distance function is commutative. In other words, for all elements `x` and `y` in some type `α` that forms a pseudo metric space, the distance from `x` to `y` is the same as the distance from `y` to `x`. This mirrors the real-world intuition that the distance between two points does not depend on the order in which we consider them.

For any pseudo metric space, the distance between two elements is symmetric.


Summable.hasSum

theorem Summable.hasSum :
    ∀ {α : Type u_1} {β : Type u_2} [inst : AddCommMonoid α] [inst_1 : TopologicalSpace α] {f : β → α},
      Summable f → HasSum f (∑' (b : β), f b) :=
  by sorry

The theorem `Summable.hasSum` states that for any types `α` and `β`, where `α` is a type with an addition operation (`AddCommMonoid`) and a topology (`TopologicalSpace`), and `f` is a function from `β` to `α`, if `f` is summable (`Summable f`), then the function `f` has a sum (`HasSum f`) that equals to the total sum of `f` over all elements of `β` (expressed as `∑' (b : β), f b`). In other words, if a function `f` is summable, then the sum of its values over all inputs equals to the sum associated with `f`.

If `f` is a summable function from a topological space `β` to an additive commutative monoid `α`, then the function `f` has a sum equal to the sum of `f` over all elements of `β`.


theorem Set.iUnion_congr_Prop :
    ∀ {α : Type u_1} {p q : Prop} {f₁ : p → Set α} {f₂ : q → Set α} (pq : p ↔ q),
      (∀ (x : q), f₁ ⋯ = f₂ x) → Set.iUnion f₁ = Set.iUnion f₂ :=
  by sorry

This theorem states that for any type `α`, given two predicates `p` and `q`, and two functions `f₁` and `f₂` that map from these predicates to sets of type `α`, if `p` is logically equivalent to `q` (i.e., `p ↔ q`) and for all `x` in `q`, `f₁` applied to some arguments equals `f₂` applied to `x`, then the indexed union of the sets produced by `f₁` is equal to the indexed union of the sets produced by `f₂`. In other words, if two predicates are equivalent and their corresponding set-producing functions yield the same sets, then the union of these sets is the same regardless of which predicate and function are used.

If two predicates are logically equivalent and their corresponding functions map equivalent sets to equal sets, then the indexed unions of these sets are equal.


theorem pos_iff_ne_zero : ∀ {α : Type u} [inst : CanonicallyOrderedAddCommMonoid α] {a : α}, 0 < a ↔ a ≠ 0 := by sorry

This theorem, `pos_iff_ne_zero`, holds for any type `α` that is a `CanonicallyOrderedAddCommMonoid`. It asserts that for any element `a` of type `α`, `a` is greater than zero if and only if `a` is not equal to zero. In other words, in the context of a `CanonicallyOrderedAddCommMonoid`, an element is positive precisely when it is non-zero.

In a `CanonicallyOrderedAddCommMonoid`, an element is positive if and only if it is non-zero.


/-- We have lots of lemmas describing how to simplify `colimit.ι F j ≫ _`,
and combined with `colimit.ext` we rely on these lemmas for many calculations.

However, since `Category.assoc` is a `@[simp]` lemma, often expressions are
right associated, and it's hard to apply these lemmas about `colimit.ι`.

We thus use `reassoc` to define additional `@[simp]` lemmas, with an arbitrary extra morphism.
(see `Tactic/reassoc_axiom.lean`)
  -/
theorem CategoryTheory.Limits.colimit.ι_desc :
    ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] {C : Type u} [inst_1 : CategoryTheory.Category.{v, u} C]
      {F : CategoryTheory.Functor J C} [inst_2 : CategoryTheory.Limits.HasColimit F]
      (c : CategoryTheory.Limits.Cocone F) (j : J),
      CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.colimit.ι F j)
          (CategoryTheory.Limits.colimit.desc F c) =
        c.ι.app j :=
  by sorry

This theorem, `CategoryTheory.Limits.colimit.ι_desc`, states that for any category `J` and `C`, any functor `F` from `J` to `C`, and any cocone `c` of `F`, the composition of the coprojection from a value of the functor to the colimit object, `colimit.ι F j` and the morphism from the colimit object to the cone point of the cocone `c`, `colimit.desc F c`, is equal to the morphism from the object `j` in the category `J` to the apex of the cocone `c`. Formally, this is written as `(CategoryTheory.Limits.colimit.ι F j) ≫ (CategoryTheory.Limits.colimit.desc F c) = c.ι.app j`. This theorem is particularly useful when working with expressions that are right associated due to the `Category.assoc` simplification lemma, allowing us to define additional simplification lemmas with an arbitrary extra morphism using the `reassoc` tactic.

The composition of the coprojection from a functor's value to the colimit object and the descrition morphism from the colimit object to the cone point equals the morphism from the original object to the cone point in a given cocone.


theorem Continuous.prod_mk :
    ∀ {X : Type u} {Y : Type v} {Z : Type u_1} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y]
      [inst_2 : TopologicalSpace Z] {f : Z → X} {g : Z → Y},
      Continuous f → Continuous g → Continuous fun x => (f x, g x) :=
  by sorry

The theorem `Continuous.prod_mk` states that for any three types `X`, `Y`, and `Z` with each a topological space, given two functions `f : Z → X` and `g : Z → Y`, if `f` and `g` are continuous, then the function that takes an element of type `Z` and returns a pair with the first element mapped by `f` and the second element mapped by `g` is also continuous.

If `f : Z -> X` and `g : Z -> Y` are continuous functions, then the function `h : Z -> X × Y` defined by `h x = (f x, g x)` is continuous.


/-- See also `nonempty_encodable`, `nonempty_denumerable`.  -/
theorem nonempty_fintype : ∀ (α : Type u_4) [inst : Finite α], Nonempty (Fintype α) := by sorry

This theorem, `nonempty_fintype`, asserts that for any type `α` which is finite (as expressed by the typeclass `Finite α`), there exists a finite type instance `Fintype α`. In simpler terms, whenever we have a finite type, it is guaranteed that there is a corresponding finite type instance available.

For any finite type `α`, there exists a finite type instance `Fintype α`.


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

This theorem, `max_eq_left`, states that for any type `α` that has a linear ordering structure, given any two elements `a` and `b` of this type, if `b` is less than or equal to `a`, then the maximum of `a` and `b` is `a`. This is essentially a formal way in Lean of expressing the intuitive concept that if `b` is less than or equal to `a`, then `a` is the maximum of `a` and `b`.

For all types `α` with a linear ordering and any `a` and `b` in `α`, if `b` is less than or equal to `a`, then `a` is the maximum of `a` and `b`. In mathematical notation: `a ≤ b → max a b = a`.


/-- Image is monotone with respect to `⊆`. See `Set.monotone_image` for the statement in
terms of `≤`.  -/
theorem Set.image_subset : ∀ {α : Type u_1} {β : Type u_2} {a b : Set α} (f : α → β), a ⊆ b → f '' a ⊆ f '' b := by
  sorry

The theorem `Set.image_subset` states that, for any two sets `a` and `b` of any type `α`, and a function `f` from `α` to some type `β`, if `a` is a subset of `b` (written as `a ⊆ b`), then the image of `a` under the function `f` is a subset of the image of `b` under `f` (written as `f '' a ⊆ f '' b`). In other words, if all elements of a first set are also in a second set, then all elements in the image of the first set under `f` are also in the image of the second set under `f`. This property is known as the monotonicity of the image with respect to the subset relation.

If `a` is a subset of `b`, then `f(a)` is a subset of `f(b)` for any function `f` from a type `α` to another type `β`.


/-- image and preimage are a Galois connection  -/
theorem Set.image_subset_iff :
    ∀ {α : Type u_1} {β : Type u_2} {s : Set α} {t : Set β} {f : α → β}, f '' s ⊆ t ↔ s ⊆ f ⁻¹' t := by sorry

This theorem states that for any two types `α` and `β`, any set `s` of type `α`, any set `t` of type `β` and any function `f` from `α` to `β`, the image of set `s` under function `f` is a subset of set `t`, if and only if set `s` is a subset of the preimage of set `t` under function `f`. In other words, given a function, the operations of taking the image and preimage form a Galois connection between the powersets of the domain and codomain.

For any functions between types `α` and `β`, the image of a set under the function is a subset of another set if and only if the preimage of the second set under the function is a subset of the first.


ContinuousMap.ext

theorem ContinuousMap.ext :
    ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] {f g : C(α, β)},
      (∀ (a : α), f a = g a) → f = g :=
  by sorry

This theorem states that for any two continuous maps `f` and `g` from a topological space `α` to another topological space `β`, if for every element `a` in `α` the value of `f` at `a` is equal to the value of `g` at `a`, then `f` and `g` are the same continuous map. In other words, two continuous maps are equal if they agree on all points of their domain.

If two continuous functions from one topological space to another agree on all points, then they are equal.


theorem tsub_add_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 → b - a + a = b :=
  by sorry

This theorem states that for any type `α` that has the structure of an additive commutative semigroup, a partial order, a structure that allows for the existence of an additive operation given a less-than-or-equal-to relation, a covariant class with respect to the plus operation and less-than-or-equal-to relation, and ordered subtraction operation, if `a` is less than or equal to `b`, then subtracting `a` from `b` and adding `a` results in `b`. In simpler terms, it's proving the cancellation property: if you subtract a number from another and then add it back, you get the original number.

For any additive commutative semigroup `α` with a partial order and covariant subtraction, if `a ≤ b`, then `b = a + (b - a)`.


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

This theorem, `Nat.pos_of_ne_zero`, states that for any natural number `n`, if `n` is not equal to zero, then `n` is greater than zero. In other words, a non-zero natural number is always positive.

For any natural number `n`, `n` is positive if and only if `n` is not zero.


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

This theorem states that for any type `α` that is a lattice and an additive group, and for any element `a` of this type, if the addition operation for this type is covariant and the element `a` is nonnegative (i.e., `0 ≤ a`), then the absolute value of `a` is equal to `a` itself. In mathematical terms, if `α` is a type with the properties mentioned and `a` is an element of `α` such that `0 ≤ a`, then `|a| = a`.

For any lattice and additive group type `α` with covariant addition, if `a` is a non-negative element of `α`, then `|a| = a`.


theorem sup_comm : ∀ {α : Type u} [inst : SemilatticeSup α] (a b : α), a ⊔ b = b ⊔ a := by sorry

This theorem, named `sup_comm`, states that for any type `α` that forms a semilattice with a supremum operation (denoted by `⊔`), the supremum of any two elements `a` and `b` of this type is commutative. In other words, the supremum of `a` and `b` is the same as the supremum of `b` and `a`. This is a fundamental property of semilattices and is equivalent to stating that the order of the elements does not matter when finding their supremum.

For any semilattice `α` with supremum operation `⊔`, the supremum of `a` and `b` equals the supremum of `b` and `a`: `a ⊔ b = b ⊔ a`.


/-- If `f` is an additive monoid homomorphism then `f (a + b) = f a + f b`. -/
theorem AddMonoidHom.map_add :
    ∀ {M : Type u_4} {N : Type u_5} [inst : AddZeroClass M] [inst_1 : AddZeroClass N] (f : M →+ N) (a b : M),
      f (a + b) = f a + f b :=
  by sorry

The theorem `AddMonoidHom.map_add` states that given any two types `M` and `N` that are additive monoids (i.e., they have a zero element and an operation `+` that is associative and has a zero element as its identity), if a function `f` is a homomorphism between these two additive monoids, then for any elements `a` and `b` from `M`, the image of the sum `a + b` under `f` is equal to the sum of the images of `a` and `b` under `f`. This property is key in defining what it means for a function to be a homomorphism between additive monoids.

Given additive monoids M and N and a homomorphism f between them, for all a, b in M, f(a + b) = f(a) + f(b).


Function.Injective.injOn

/-- **Alias** of `Set.injOn_of_injective`. -/
theorem Function.Injective.injOn :
    ∀ {α : Type u_1} {β : Type u_2} {f : α → β}, Function.Injective f → ∀ (s : Set α), Set.InjOn f s := by sorry

This theorem, referred to as an alias of `Set.injOn_of_injective`, states that for all types `α` and `β`, and for any function `f` from `α` to `β`, if `f` is injective then it is also injective on any subset `s` of `α`. In other words, if `f` is a function such that any two different elements in `α` have different images in `β`, then this property holds true not just for the elements of `α`, but also for any subset of `α`.

If `f` is an injective function from type `α` to type `β`, then `f` is injective on any subset `s` of `α`.


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

This theorem, `eq_top_iff`, states that for any type `α` with a partial order and a top element, a given element `a` of type `α` is equal to the top element if and only if the top element is less than or equal to `a`. This essentially provides a condition under which an element can be identified as the top element in a partially ordered set.

For any partially ordered type `α` with a top element, an element `a` is equal to the top element if and only if the top element is less than or equal to `a`.


Continuous.measurable

/-- A continuous function from an `OpensMeasurableSpace` to a `BorelSpace`
is measurable.  -/
theorem Continuous.measurable :
    ∀ {α : Type u_1} {γ : Type u_3} [inst : TopologicalSpace α] [inst_1 : MeasurableSpace α]
      [inst_2 : OpensMeasurableSpace α] [inst_3 : TopologicalSpace γ] [inst_4 : MeasurableSpace γ]
      [inst_5 : BorelSpace γ] {f : α → γ}, Continuous f → Measurable f :=
  by sorry

The theorem states that for any continuous function `f` from a space `α` with both a topological structure and an opens-measurable structure to a space `γ` with both a topological structure and a Borel measurable structure, the function `f` is measurable. In more mathematical terms, if `α` is a topological space that is also an opens-measurable space, and `γ` is a topological space that is also a Borel space, then any continuous function `f: α → γ` is a measurable function. Measurability here is defined as the property of a function where the preimage of every measurable set is also measurable.

A continuous function between a topological space that is also an opens-measurable space and a Borel space is measurable.


theorem exists_pair_ne : ∀ (α : Type u_3) [inst : Nontrivial α], ∃ x y, x ≠ y := by sorry

This theorem, `exists_pair_ne`, asserts that for every type `α` that is nontrivial (i.e., it has at least two distinct elements), there exist two elements `x` and `y` such that `x` is not equal to `y`. In other words, in any nontrivial type, you can always find a pair of distinct elements.

For any nontrivial type `α`, there exist `x` and `y` in `α` such that `x ≠ y`.


theorem smul_eq_mul : ∀ (α : Type u_10) [inst : Mul α] {a a' : α}, a • a' = a * a' := by sorry

This theorem states that for any type `α` with a multiplication operation and for any two elements `a` and `a'` of type `α`, the scalar multiplication of `a` and `a'` is equal to the product of `a` and `a'`. In mathematical terms, we could write this as `a • a' = a * a'` for all `a` and `a'` in a type `α` with multiplication.

For any type `α` equipped with a multiplication operation, the scalar multiplication equals the product operation: `a • a' = a * a'` for all `a, a' : α`.


theorem norm_zero : ∀ {E : Type u_6} [inst : SeminormedAddGroup E], ‖0‖ = 0 := by sorry

This theorem states that for any type `E` that forms a semi-normed group, the semi-norm of the zero element is zero. In mathematical terms, for any semi-normed add group `E`, the norm of zero (`‖0‖`) equals zero.

In a semi-normed additive group, the norm of the additive identity is zero.


theorem Subtype.ext_iff : ∀ {α : Sort u_1} {p : α → Prop} {a1 a2 : { x // p x }}, a1 = a2 ↔ ↑a1 = ↑a2 := by sorry

This theorem, `Subtype.ext_iff`, states that for any type `α`, any predicate `p` on `α`, and any two elements `a1` and `a2` of the subtype `{x // p x}`, `a1` is equal to `a2` if and only if the underlying elements of `a1` and `a2` (denoted by `↑a1` and `↑a2`) in `α` are equal. In other words, two elements of a subtype are equal if and only if their corresponding elements in the parent type are equal.

For any type `α` and predicate `p` on `α`, elements `a1` and `a2` of the subtype `{x // p x}` are equal if and only if the underlying elements `↑a1` and `↑a2` in `α` are equal.


theorem Nat.cast_succ : ∀ {R : Type u_1} [inst : AddMonoidWithOne R] (n : ℕ), ↑(Nat.succ n) = ↑n + 1 := by sorry

This theorem, `Nat.cast_succ`, states that for any countable number `n` of type natural number (`ℕ`), and for any type `R` that is equipped with an addition operation and a distinguished element called `one` (which is to say, `R` is an 'additive monoid with one'), the casting of the successor of `n` (denoted by `Nat.succ n`) into `R` is equal to the sum of the cast of `n` into `R` and `1`. In other words, it translates the natural number property that the next number after `n` is `n + 1` into the context of the type `R`.

For any countable natural number `n` and additive monoid `R` with one, `Nat.succ (Nat.cast R n) = Nat.cast R n + 1`.


theorem isClosed_closure : ∀ {X : Type u} {s : Set X} [inst : TopologicalSpace X], IsClosed (closure s) := by sorry

This theorem states that for any type `X` and for any set `s` of type `X`, given that `X` has a topology, the closure of `s` is a closed set. In mathematical terms, `closure s` represents the smallest closed set that contains all elements of `s` in a topological space. The theorem ensures that the result of this closure operation is indeed a closed set in the given topological space.

In a topological space, the closure of any set is a closed set.


theorem Nat.succ_ne_zero : ∀ (n : ℕ), Nat.succ n ≠ 0 := by sorry

This theorem states that the successor of any natural number `n` is not equal to zero. In other words, if you add 1 to any natural number, you will never get zero. In mathematical terms, for every natural number `n`, `n + 1 ≠ 0`.

For all natural numbers `n`, `n + 1 ≠ 0`.


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

This theorem, `lt_of_le_of_ne`, states that for any type `α` that has a partial order, if `a` and `b` are elements of `α` such that `a` is less than or equal to `b` and `a` is not equal to `b`, then `a` is strictly less than `b`. Here, `≤` and `<` denote the partial order and strict order respectively.

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 Quiver.Hom.unop_inj : ∀ {C : Type u₁} [inst : Quiver C] {X Y : Cᵒᵖ}, Function.Injective Quiver.Hom.unop := by
  sorry

The theorem `Quiver.Hom.unop_inj` states that for any category `C` with its quiver structure, and any two objects `X` and `Y` in the opposite category `Cᵒᵖ`, the function `Quiver.Hom.unop` is injective. In other words, if two morphisms in the opposite category `Cᵒᵖ` from `X` to `Y` have the same "unopposite" in `C` (meaning they map to the same morphism in `C` when the direction of the arrows is reversed), then the two morphisms in `Cᵒᵖ` were the same to begin with. This guarantees that the process of "unoppositing" does not lose information.

The theorem `Quiver.Hom.unop_inj` asserts that the function `Quiver.Hom.unop` is an injection on morphisms in the opposite category of any quivered category.