congrArg

/-- Congruence in the function argument: if `a₁ = a₂` then `f a₁ = f a₂` for
any (nondependent) function `f`. This is more powerful than it might look at first, because
you can also use a lambda expression for `f` to prove that
`<something containing a₁> = <something containing a₂>`. This function is used
internally by tactics like `congr` and `simp` to apply equalities inside
subterms.

For more information: [Equality](https://lean-lang.org/theorem_proving_in_lean4/quantifiers_and_equality.html#equality)
 -/
theorem congrArg : ∀ {α : Sort u} {β : Sort v} {a₁ a₂ : α} (f : α → β), a₁ = a₂ → f a₁ = f a₂ := by sorry

The theorem `congrArg` states that for any types `α` and `β`, given two elements `a₁` and `a₂` of type `α`, and any function `f` from `α` to `β`, if `a₁` equals `a₂` then the function `f` applied to `a₁` equals the function `f` applied to `a₂`. In other words, this theorem asserts that a function applied to equal arguments produces equal results. This is not just applicable to functions but also to lambda expressions. This theorem is frequently used by tactics such as `congr` and `simp` in Lean to apply equalities within subterms.

For all types α and β, and for all functions f from α to β and elements a₁ and a₂ of type α, if a₁ = a₂ then f(a₁) = f(a₂).


trans

theorem trans : ∀ {α : Sort u} {r : α → α → Prop} [inst : IsTrans α r] {a b c : α}, r a b → r b c → r a c := by sorry

This theorem, "trans", states that for any type `α`, any relation `r` on `α`, and any three elements `a`, `b`, and `c` of type `α`, if `r` is transitive (as ensured by the `IsTrans` typeclass instance), then if `r a b` and `r b c` hold, then `r a c` also holds. In more traditional mathematical notation, this is saying that for all `a`, `b`, `c` in some set, if `a r b` and `b r c` then `a r c`. This is one of the defining properties of a transitive relation.

If `r` is a transitive relation on type `α`, then `aRb` and `bRc` imply `aRc`.


theorem of_eq_true : ∀ {p : Prop}, p = True → p := by sorry

This theorem states that for any proposition `p`, if `p` equals `True`, then `p` is true. In other words, it asserts that if we can equate a proposition to the boolean value `True`, then that proposition itself must be true. This theorem is fundamental to the logical foundation, bridging the gap between propositional logic and boolean algebra.

If a proposition `p` is equal to `True`, then `p` is true.


symm

theorem symm : ∀ {α : Sort u} {r : α → α → Prop} [inst : IsSymm α r] {a b : α}, r a b → r b a := by sorry

This theorem, `symm`, states that for any type `α`, any binary relation `r` on `α`, and any two elements `a` and `b` of type `α`, if the relation `r` is symmetric (i.e., `r a b` implies `r b a` for any `a` and `b`), then if `r a b` holds, `r b a` must also hold. In other words, if `a` is related to `b` via a symmetric relation, then `b` is also related to `a` via the same relation.

If `r` is a symmetric relation on type `α`, then for all `a` and `b` in `α`, `r a b` implies `r b a`.


theorem eq_self : ∀ {α : Sort u_1} (a : α), (a = a) = True := by sorry

This theorem, `eq_self`, states that for any element `a` of any sort `α`, the proposition that `a` equals itself is true. This is a universal truth in mathematics, often referred to as the reflexivity of equality, which asserts that each element is equal to itself. The theorem applies to any sort in Lean, which could be either types or propositions.

For all elements `a` of any type `α` in Lean, `a` equals `a`.


congr

/-- Congruence in both function and argument. If `f₁ = f₂` and `a₁ = a₂` then
`f₁ a₁ = f₂ a₂`. This only works for nondependent functions; the theorem
statement is more complex in the dependent case.

For more information: [Equality](https://lean-lang.org/theorem_proving_in_lean4/quantifiers_and_equality.html#equality)
 -/
theorem congr : ∀ {α : Sort u} {β : Sort v} {f₁ f₂ : α → β} {a₁ a₂ : α}, f₁ = f₂ → a₁ = a₂ → f₁ a₁ = f₂ a₂ := by sorry

The `congr` theorem states that given two sets of nondependent functions and their respective arguments (`f₁`, `a₁`) and (`f₂`, `a₂`), if the functions (`f₁` and `f₂`) are equal and the arguments (`a₁` and `a₂`) are also equal, then applying the function to the argument (`f₁ a₁` and `f₂ a₂`) will also yield equal results. This theorem is applicable in the field of mathematical logic and functional programming where function and argument congruence is necessary. Note that the theorem becomes more complex in the case of dependent functions.

If functions `f₁` and `f₂` are equal and their arguments `a₁` and `a₂` are equal, then `f₁ a₁` and `f₂ a₂` are equal.


funext

/-- **Function extensionality** is the statement that if two functions take equal values
every point, then the functions themselves are equal: `(∀ x, f x = g x) → f = g`.
It is called "extensionality" because it talks about how to prove two objects are equal
based on the properties of the object (compare with set extensionality,
which is `(∀ x, x ∈ s ↔ x ∈ t) → s = t`).

This is often an axiom in dependent type theory systems, because it cannot be proved
from the core logic alone. However in lean's type theory this follows from the existence
of quotient types (note the `Quot.sound` in the proof, as well as the `show` line
which makes use of the definitional equality `Quot.lift f h (Quot.mk x) = f x`).
 -/
theorem funext : ∀ {α : Sort u} {β : α → Sort v} {f g : (x : α) → β x}, (∀ (x : α), f x = g x) → f = g := by sorry

The theorem `funext` is a statement of **Function Extensionality** in Lean. It asserts that if two functions, `f` and `g`, of a dependent type `β` indexed over a sort `α`, provide equal outcomes for every possible value of `α`, then the functions `f` and `g` themselves are considered equal. Formally, it is expressed as `(∀ x, f x = g x) → f = g`.

This concept is known as "extensionality", as it allows us to establish equality between two entities based on their properties. It's important to note that this is often assumed as an axiom in dependent type theory systems, because it is not provable using only the core logic. However, in Lean's type theory, this can be derived from the existence of quotient types.

If two functions `f` and `g` of type `β -> α` have the same output for all `α`, then `f` and `g` are equal.


Iff.rfl

theorem Iff.rfl : ∀ {a : Prop}, a ↔ a := by sorry

This theorem, `Iff.rfl`, states that for any proposition `a`, `a` is logically equivalent to itself. In other words, it's a statement of reflexivity for logical equivalence in propositional logic. In mathematical terms, for any propositional variable `a`, `a ↔ a` is always true.

For all propositions `a`, `a` is logically equivalent to itself (`a ↔ a` is true).


theorem iff_self : ∀ (p : Prop), (p ↔ p) = True := by sorry

This theorem, named 'iff_self', states that for any proposition 'p', the logical biconditional (if and only if) of 'p' with itself is always true. In other words, the theorem asserts that any proposition is equivalent to itself.

For any proposition p, p iff p holds true.


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

This theorem establishes the congruence of two universally quantified predicates over any sort `α`. Specifically, given two predicates `p` and `q` that map elements of `α` to propositions, if for every element of `α`, `p` and `q` are equal (i.e., they produce the same proposition), then the universal quantification of `p` is equal to the universal quantification of `q`. In other words, if two predicates are equivalent for every element in a set, then their universal quantifications are also equivalent.

If two predicates mapping elements of a set to propositions are equal for all elements, then their universal quantifications are equal.


theorem implies_congr : ∀ {p₁ p₂ : Sort u} {q₁ q₂ : Sort v}, p₁ = p₂ → q₁ = q₂ → (p₁ → q₁) = (p₂ → q₂) := by sorry

This theorem, `implies_congr`, states that for any two pairs of "Sorts" (`p₁, p₂` of type `Sort u` and `q₁, q₂` of type `Sort v`), if `p₁` equals `p₂` and likewise `q₁` equals `q₂`, then the implication (or function) from `p₁` to `q₁` is equal to the implication from `p₂` to `q₂`. In simpler terms, if we have two identical pairs, then the function that maps the elements of the first pair is the same as the function that maps the elements of the second pair.

If two functions have the same domain and codomain and their domains are equal, then they are equal as functions.


theorem eq_true : ∀ {p : Prop}, p → p = True := by sorry

This theorem states that for any proposition `p`, if `p` holds (or is true), then `p` is equal to `True`. In other words, it is asserting that if a certain condition or proposition `p` is satisfied, then we can identify `p` as being `True`. This is a foundational concept in propositional logic used in Lean 4 theorem prover.

For any proposition `p` in Lean 4, `p` is equivalent to `True` when `p` holds true.


/-- **Alias** of `congrArg`.

---

Congruence in the function argument: if `a₁ = a₂` then `f a₁ = f a₂` for
any (nondependent) function `f`. This is more powerful than it might look at first, because
you can also use a lambda expression for `f` to prove that
`<something containing a₁> = <something containing a₂>`. This function is used
internally by tactics like `congr` and `simp` to apply equalities inside
subterms.

For more information: [Equality](https://lean-lang.org/theorem_proving_in_lean4/quantifiers_and_equality.html#equality)
 -/
theorem congr_arg : ∀ {α : Sort u} {β : Sort v} {a₁ a₂ : α} (f : α → β), a₁ = a₂ → f a₁ = f a₂ := by sorry

The Lean 4 theorem `congr_arg` is about congruence in arguments of a function. It states that for any two elements `a₁` and `a₂` in a sort `α`, and any function `f` mapping from `α` to another sort `β`, if `a₁` is equal to `a₂`, then the results of applying `f` to `a₁` and `a₂` are also equal, i.e., `f a₁ = f a₂`. This theorem is notably more potent than initially apparent, as it also permits the use of a lambda expression for `f`, allowing us to prove that some expression involving `a₁` is equal to a corresponding expression involving `a₂`. Tactics like `congr` and `simp` use this theorem internally to apply equalities within subterms.

For any function `f` and elements `a₁` and `a₂` in a sort `α`, if `a₁` equals `a₂`, then `f a₁` equals `f a₂`.


Iff.trans

theorem Iff.trans : ∀ {a b c : Prop}, (a ↔ b) → (b ↔ c) → (a ↔ c) := by sorry

This theorem, `Iff.trans`, states that for any three propositions `a`, `b`, and `c`, if `a` is logically equivalent to `b`, and `b` is logically equivalent to `c`, then `a` is logically equivalent to `c`. This is a transitive property for logical equivalence in propositional logic. In mathematical terms, if we have $(a \iff b)$ and $(b \iff c)$, it follows that we have $(a \iff c)$.

If `a` is logically equivalent to `b`, and `b` is logically equivalent to `c`, then `a` is logically equivalent to `c` (`(a ��CREF b) ∧ (b ��CREF c) ⊢ a ��CREF c` in Lean 4 syntax).


theorem mul_one : ∀ {M : Type u} [inst : MulOneClass M] (a : M), a * 1 = a := by sorry

This theorem states that for any type `M` that has a multiplication operation and a specified element considered as 'one' (i.e., it belongs to the `MulOneClass`), multiplying any element `a` of type `M` by this 'one' will yield `a` itself. This is a formalization of the multiplicative identity property in mathematics, which states that any number multiplied by 1 remains unchanged.

For any type `M` with multiplication and a multiplicative identity `one`, `a * one = a` for all `a : M`.


theorem eq_false : ∀ {p : Prop}, ¬p → p = False := by sorry

This theorem states that for any proposition `p`, if `p` is not true (denoted by `¬p`), then `p` is equivalent to `false`. In other words, if we can show that a certain proposition cannot be true, then we can say that this proposition is effectively the same as `false` in our logic system.

The negation of a proposition is equivalent to false. ( ∥ ¬p ≡ false ∥)


theorem add_zero : ∀ {M : Type u} [inst : AddZeroClass M] (a : M), a + 0 = a := by sorry

This theorem states that for any type `M` that has an addition operation and a zero element, the addition of any element `a` of type `M` with the zero element results in `a` itself. In terms of mathematics, it means for any algebraic structure with addition operation and zero (0), adding zero to any element does not change the value of the element. This is equivalent to the common concept in mathematics where `a + 0 = a` for any `a`.

For any type `M` with an addition operation and a zero element, `a + 0 = a` for all `a` in `M`.


theorem not_false_eq_true : (¬False) = True := by sorry

This theorem states that the negation of `False` is equal to `True`. In other words, if something is not `False`, then it is `True`. This is a fundamental principle of Boolean logic.

The negation of `False` is `True`. Alternatively, `~False = True`.


Set.ext

theorem Set.ext : ∀ {α : Type u_1} {a b : Set α}, (∀ (x : α), x ∈ a ↔ x ∈ b) → a = b := by sorry

The theorem `Set.ext` states that for any type `α` and any two sets `a` and `b` of type `α`, if every element `x` of type `α` belongs to `a` if and only if `x` belongs to `b`, then `a` and `b` are the same set. In other words, two sets are equal if they contain exactly the same elements.

If two sets `a` and `b` of type `α` have the same elements, then `a = b`.


LE.le.trans

/-- **Alias** of `le_trans`.

---

The relation `≤` on a preorder is transitive.  -/
theorem LE.le.trans : ∀ {α : Type u} [inst : Preorder α] {a b c : α}, a ≤ b → b ≤ c → a ≤ c := by sorry

This theorem, named `LE.le.trans` in Lean 4, states that the "less than or equal to" (`≤`) relation is transitive on a preorder. In more detail, given a preorder of some type `α` and three elements `a`, `b`, and `c` of that type, if `a` is less than or equal to `b` and `b` is less than or equal to `c`, then `a` is less than or equal to `c`. This theorem is an alias of `le_trans`, meaning it's another name for the same concept or proof.

If `a ≤ b` and `b ≤ c`, then `a ≤ c`. (In the context of a preorder.)


theorem zero_add : ∀ {M : Type u} [inst : AddZeroClass M] (a : M), 0 + a = a := by sorry

This theorem, named `zero_add`, states that for any type `M` that forms an additive zero class (i.e., it has a zero element and an addition operation), adding zero to any element `a` of type `M` will yield `a` itself. This is a restatement of one of the fundamental properties of additive identity, expressed in the context of type theory.

For any additive type `M` and element `a` in `M`, `a + 0 = a`.


theorem mul_comm : ∀ {G : Type u_1} [inst : CommMagma G] (a b : G), a * b = b * a := by sorry

This theorem states that for any type `G` that forms a commutative magma (denoted as `CommMagma G`), the multiplication operation is commutative. In other words, for any two elements `a` and `b` of type `G`, the product of `a` and `b` (`a * b`) is equal to the product of `b` and `a` (`b * a`). This is a formalization of the commutative property of multiplication, which is familiar from elementary algebra.

For any commutative magma `G`, the multiplication operation is commutative, i.e., `a * b = b * a` for all `a, b` in `G`.


theorem one_mul : ∀ {M : Type u} [inst : MulOneClass M] (a : M), 1 * a = a := by sorry

This theorem states that for any type `M` that has a multiplication operation and a defined element '1' (i.e., `M` is an instance of `MulOneClass`), the product of '1' and any element `a` of type `M` is just `a` itself. In other words, '1' acts as a multiplicative identity in the type `M`. In mathematical terms, for any element `a` in `M`, the equation `1 * a = a` holds true.

For any type `M` instancing `MulOneClass` with multiplicative identity '1', the equation `1 * a = a` holds for all `a` in `M`.


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

This theorem states that for any type `G` that forms an additive commutative magma (i.e., a set with a binary operation that is commutative), the operation `+` is commutative. In other words, for any elements `a` and `b` of this type `G`, the result of `a + b` is the same as `b + a`. It enforces the general principle that the order in which two elements are added does not change the outcome, which is a fundamental property of addition in commutative magmas.

For any commutative additive magma `G`, the operation `+` is commutative, i.e., `a + b = b + a` for all `a, b` in `G`.


/-- A version of `le_refl` where the argument is implicit  -/
theorem le_rfl : ∀ {α : Type u} [inst : Preorder α] {a : α}, a ≤ a := by sorry

This theorem, `le_rfl`, asserts that for any given type `α` that has a preorder (a binary relation indicating that, for every pair of elements in the set, one of them is less than or equal to the other), every element `a` of this type is less than or equal to itself. This is a reflexive property of preorders, where every element is related to itself in the defined order.

For any preordered type `α`, every element `a` in `α` is less than or equal to itself. (That is, `a ≤ a` holds in every preorder.)


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

This theorem states that in a partially ordered set of type `α`, for any two elements `a` and `b` of this set, if `a` is less than or equal to `b` and `b` is less than or equal to `a`, then `a` must be equal to `b`. This property is known as antisymmetry and is one of the defining characteristics of a partial order.

In a partially ordered set, if `a` is less than or equal to `b` and `b` is less than or equal to `a`, then `a` equals `b` (antisymmetry property).


LT.lt.le

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

This theorem, `LT.lt.le`, states that for any preorder `α`, and for any two elements `a` and `b` of this type, if `a` is less than `b` (`a < b`), then `a` is also less than or equal to `b` (`a ≤ b`). In other words, it confirms that less than implies less than or equal to in the context of a preorder. This is a fundamental property of ordered sets in mathematics.

In a preorder, if `a` is less than `b` (`a < b`), then `a` is also less than or equal to `b` (`a ≤ b`).


Iff.symm

theorem Iff.symm : ∀ {a b : Prop}, (a ↔ b) → (b ↔ a) := by sorry

This theorem, `Iff.symm`, states that for all propositions `a` and `b`, if `a` is logically equivalent to `b` (denoted as `a ↔ b`), then `b` is also logically equivalent to `a`. This is the principle of symmetry in logical equivalence, reflecting that if both `a` and `b` have the same truth values in all cases, their order doesn't matter. This is akin to saying if `a` is true whenever `b` is true and vice versa, then the reverse statement that `b` is true whenever `a` is true and vice versa also holds.

If `a` is logically equivalent to `b`, then `b` is logically equivalent to `a`. (The principle of symmetric logical equivalence.)


theorem if_neg : ∀ {c : Prop} {h : Decidable c}, ¬c → ∀ {α : Sort u} {t e : α}, (if c then t else e) = e := by sorry

This theorem states that for any proposition `c` and `Decidable c` instance `h`, if `c` is not true (i.e., `¬c`), then for any sort `α` and any two instances `t` and `e` of that sort, the expression `if c then t else e` will evaluate to `e`. In more layman's terms, it describes the logical behavior of an "if-then-else" statement: if the condition is not true, the "else" part is returned.

If `c` is a propositional variable with decidable instance `h` and `c` is false, then `if c then t else e` evaluates to `e` for any values `t` and `e` of sort `α`.


theorem eq_of_heq : ∀ {α : Sort u} {a a' : α}, HEq a a' → a = a' := by sorry

This theorem, `eq_of_heq`, states that for any type `α` and any two elements `a` and `a'` of type `α`, if `a` is heterogeneously equal to `a'` (denoted as `HEq a a'`), then `a` is also homogeneously equal to `a'` (denoted as `a = a'`). In other words, if two elements are equivalent in a type-independent manner (`HEq`), they are also equivalent in a type-dependent manner (`=`).

If `α` is a type and `a` and `a'` are elements of `α` with `HEq a a'`, then `a = a'`.


theorem if_pos : ∀ {c : Prop} {h : Decidable c}, c → ∀ {α : Sort u} {t e : α}, (if c then t else e) = t := by sorry

This theorem, `if_pos`, states that for any proposition `c` and any decidable instance `h` of `c`, if `c` is true, then for any type `α` and any two instances `t` and `e` of this type, the expression `if c then t else e` will always evaluate to `t`. In other words, if the condition of an `if` statement is true, then the value of the whole `if` statement is the value of the `then` clause.

Given a decidable proposition `c` and instances `t` and `e` of any type `α`, if `c` holds then `if c then t else e` evaluates to `t`.


theorem implies_true : ∀ (α : Sort u), (α → True) = True := by sorry

This theorem, named `implies_true`, states that for any type or sort `α`, the proposition that `α` implies `True` is always `True`. In other words, it asserts that if you have a statement of the form "`α` implies `True`", that statement itself is always true, regardless of what `α` might be. Using the language of predicate logic, this corresponds to the tautology that "`α` implies `True`" is always `True`.

For any type or sort `α`, the proposition `α → True` is true. (In predicate logic, this is the tautology `∀α, α → True`.)


Subsingleton.elim

theorem Subsingleton.elim : ∀ {α : Sort u} [h : Subsingleton α] (a b : α), a = b := by sorry

This theorem, `Subsingleton.elim`, states that for any sort `α` that is a subsingleton (that is, a type with at most one element), any two elements `a` and `b` of that type are equal. In other words, if a type is a subsingleton, it doesn't have distinct elements.

If `α` is a subsingleton type, then for all `a` and `b` in `α`, `a = b`.


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

The theorem `Finset.sum_congr` states that for any two finite sets `s₁` and `s₂` of type `α`, and any two functions `f` and `g` from `α` to `β`, where `β` is a type with an addition operation that is commutative and associative, if `s₁` is equal to `s₂` and `f` is equal to `g` for all elements in `s₂`, then the sum of the function `f` evaluated over the set `s₁` is equal to the sum of the function `g` evaluated over the set `s₂`. In mathematical terms, this can be written as: if $s_1 = s_2$ and $f(x) = g(x)$ for all $x \in s_2$, then $\sum_{x \in s_1} f(x) = \sum_{x \in s_2} g(x)$.

If two finite sets have the same elements and a function maps them equivalently to another type with commutative and associative addition, then the sum of the function over the first set equals the sum over the second set.


theorem mul_assoc : ∀ {G : Type u_1} [inst : Semigroup G] (a b c : G), a * b * c = a * (b * c) := by sorry

This theorem is about the associativity of multiplication in a semigroup. For any semigroup `G` and any three elements `a`, `b`, and `c` of `G`, the operation of multiplication is associative. In other words, the order in which the multiplication operations are performed does not affect the result: `(a * b) * c` is the same as `a * (b * c)`.

In any semigroup, the multiplication is associative: `(a * b) * c = a * (b * c)` for all elements `a`, `b`, and `c`.


theorem Nat.cast_one : ∀ {R : Type u_1} [inst : AddMonoidWithOne R], ↑1 = 1 := by sorry

This theorem states that, for any type `R` that is an additive monoid with a one element (`AddMonoidWithOne R`), the natural number cast of `1` (represented as `↑1`) is equal to the one element of `R` (represented as `1`). In simpler terms, it says that casting one from natural numbers to any type with a one element and addition operation gives us the one element of that type.

For any additive monoid with a one element `R`, the natural number `1` equals the one element `1` in `R`.


/-- Subtracting an element is the same as adding by its negative.
This is a duplicate of `SubNegMonoid.sub_eq_mul_neg` ensuring that the types unfold better. -/
theorem sub_eq_add_neg : ∀ {G : Type u_1} [inst : SubNegMonoid G] (a b : G), a - b = a + -b := by sorry

This theorem states that in any Subtraction-Negative Monoid (`SubNegMonoid`), denoted by `G`, subtracting an element `b` from another element `a` is equivalent to adding the negative of `b` to `a`. In other words, for any elements `a` and `b` in `G`, the expression `a - b` is the same as `a + -b`. This theorem is a duplicate of `SubNegMonoid.sub_eq_mul_neg` but is written in a way that ensures the types unfold better.

In any Subtraction-Negative Monoid, for all elements `a` and `b`, `a - b` equals `a + (-b)`.


Subtype.ext

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

This theorem, `Subtype.ext`, states that for any type `α`, any predicate `p` on `α`, and any two elements `a1` and `a2` of the subtype consisting of those elements `x` of `α` for which `p x` holds, if the elements `a1` and `a2` are equal when considered as elements of the base type `α` (i.e., `↑a1 = ↑a2` where `↑` denotes the coercion from the subtype to the base type), then `a1` and `a2` must also be equal as elements of the subtype. In other words, two elements of a subtype are equal if and only if they are equal in the base type.

For any type `α` and subtype `p ⊆ α`, if `a₁` and `a₂` are equal as elements of `α` and belong to `p`, then they are equal as elements of `p`.


theorem of_decide_eq_true : ∀ {p : Prop} [inst : Decidable p], decide p = true → p := by sorry

This theorem, `of_decide_eq_true`, states that for any proposition `p`, given that `p` is decidable (meaning it can be determined whether `p` is true or false), if the decision procedure for `p` returns `true`, then `p` is indeed true. Essentially, it asserts the correctness of the decision procedure: if `decide p` is `true`, then `p` holds.

If a proposition `p` is decidable and its decision procedure returns `true`, then `p` is true.


theorem Iff.of_eq : ∀ {a b : Prop}, a = b → (a ↔ b) := by sorry

This theorem states that for any two propositions `a` and `b`, if `a` is equal to `b`, then `a` is logically equivalent to `b` (denoted as `a ↔ b`). This logical equivalence means that `a` implies `b` and `b` implies `a`. In other words, `a` and `b` both hold true or false under the same conditions.

For all propositions `a` and `b`, `a = b` implies `a ↔ b`.


/-- The relation `≤` on a preorder is transitive.  -/
theorem le_trans : ∀ {α : Type u} [inst : Preorder α] {a b c : α}, a ≤ b → b ≤ c → a ≤ c := by sorry

This theorem states that, in any preorder, the less than or equal to (`≤`) relation is transitive. Specifically, for any type `α` with a preorder structure, and for any elements `a`, `b`, and `c` of `α`, if `a` is less than or equal to `b` and `b` is less than or equal to `c`, then `a` is less than or equal to `c`. Transitivity is a fundamental property of preorders and partial orders, and this theorem formalizes that characteristic in the context of the less than or equal to relation.

In any preorder, if `a ≤ b` and `b ≤ c`, then `a ≤ c`.


/-- A variant of `eq_whisker` with a more convenient argument order for use in tactics.   -/
theorem CategoryTheory.eq_whisker' :
    ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] {X Y : C} {f g : X ⟶ Y},
      f = g → ∀ {Z : C} (h : Y ⟶ Z), CategoryTheory.CategoryStruct.comp f h = CategoryTheory.CategoryStruct.comp g h :=
  by sorry

The theorem `CategoryTheory.eq_whisker'` states that in any category `C`, if we have two morphisms `f` and `g` from object `X` to `Y` that are equal, then for any object `Z` in `C` and any morphism `h` from `Y` to `Z`, the composition of `f` and `h` is equal to the composition of `g` and `h`. In other words, if `f` equals `g`, then composing `f` or `g` with `h` (in that order) gives the same result. This theorem is a variant of `eq_whisker` with a different argument order designed to be more convenient for use in tactics.

In any category, if two morphisms from an object to another are equal, then their composition with any morphism from the second object to a third is equal.


/-- The relation `≤` on a preorder is reflexive.  -/
theorem le_refl : ∀ {α : Type u} [inst : Preorder α] (a : α), a ≤ a := by sorry

This theorem states that for any type `α` which has a Preorder relation, the 'less than or equal to' relation `≤` is reflexive. In other words, for any element `a` of type `α`, `a` is always less than or equal to itself. This is a fundamental property of preorders in mathematical order theory.

For any preorder `≤` on type `α`, `a ≤ a` holds for all `a : α`.


Eq.propIntro

theorem Eq.propIntro : ∀ {a b : Prop}, (a → b) → (b → a) → a = b := by sorry

This theorem, `Eq.propIntro`, states that for any two propositions `a` and `b`, if `a` implies `b` and `b` implies `a`, then `a` and `b` are equivalent, or in other words, `a = b`. This principle is commonly known as the equivalence of propositions. This is a fundamental concept in logic and is used throughout mathematics and computer science.

If two propositions `a` and `b` imply each other, then `a` is equivalent to `b`, denoted as `a <-> b`.


theorem Nat.cast_zero : ∀ {R : Type u_1} [inst : AddMonoidWithOne R], ↑0 = 0 := by sorry

This theorem states that for any type `R` which includes addition (`AddMonoid`) and has a distinguished 'one' element (`WithOne`), casting the natural number zero (`0`) to `R` will always yield the 'zero' element of `R`. In other words, it proves that zero in the natural numbers and zero in `R` are equivalent when treated under these conditions, which is a fundamental assumption in number theory and algebra.

For any `AddMonoid` and `WithOne` type `R`, the natural number zero maps to the additive identity (zero) of `R`.


LT.lt.ne'

theorem LT.lt.ne' : ∀ {α : Type u} [inst : Preorder α] {x y : α}, x < y → y ≠ x := by sorry

This theorem states that for all types `α` that have a preorder structure, if `x` is less than `y`, then `y` is not equal to `x`. In other words, if one element is strictly less than another in a set with an order structure, then these two elements are distinct.

In a preordered type, if `x` is less than `y`, then `x ≠ y`.


mt

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

This theorem, which we will refer to as 'mt', states that for all propositions 'a' and 'b', if 'a' implies 'b' and 'b' is not true, then 'a' is also not true. In terms of logic, this is a basic statement of modus tollens: if we have a conditional statement ("if a then b") and the consequent ('b') is known to be false, then the antecedent ('a') must also be false.

If `a` implies `b` and not `b`, then not `a`.


theorem map_zero :
    ∀ {M : Type u_4} {N : Type u_5} {F : Type u_9} [inst : Zero M] [inst_1 : Zero N] [inst_2 : FunLike F M N]
      [inst_3 : ZeroHomClass F M N] (f : F), f 0 = 0 :=
  by sorry

The theorem `map_zero` states that for any types `M`, `N`, and `F`, if `M` and `N` have zero elements, `F` is a function-like type from `M` to `N`, and `F` is a zero homomorphism class, then the function `f` of type `F` applied to the zero element of `M` gives the zero element of `N`. Essentially, this theorem states that a zero homomorphism maps the zero element of its domain to the zero element of its codomain.

If `F` is a zero homomorphism from the additive group of type `M` to the additive group of type `N` and `0` is the additive identity of `M`, then `F(0)` is the additive identity of `N`.


theorem true_and : ∀ (p : Prop), (True ∧ p) = p := by sorry

This theorem states that for any proposition 'p', the logical conjunction of 'True' and 'p' is equivalent to 'p'. In other words, 'True' combined with any proposition using the logical operator 'and' does not change the truth value of that proposition. This theorem reflects the identity law in propositional logic.

For any proposition p in Lean, True and p are logically equivalent.


theorem and_self : ∀ (p : Prop), (p ∧ p) = p := by sorry

This theorem, `and_self`, states that for any proposition `p`, `p` and `p` is equivalent to `p`. In other words, if we claim that two identical propositions are both true (i.e., `p ∧ p`) that is the same as just stating the one proposition `p` itself is true. This theorem applies to any proposition, regardless of its content.

For all propositions p, p and p are logically equivalent.


theorem one_smul : ∀ (M : Type u_1) {α : Type u_6} [inst : Monoid M] [inst_1 : MulAction M α] (b : α), 1 • b = b := by
  sorry

This theorem, `one_smul`, states that for every type `M` and for a given type `α`, given that `M` is a monoid and there exists a multiplication action (`MulAction`) of `M` on `α`, the action of the identity element (`1` of the monoid) on any element `b` of type `α` is equal to the element `b` itself. In other words, multiplying any element by the identity in this context leaves it unchanged.

For any monoid `M` and type `α` with a multiplication action, the identity element of `M` acts as the identity on elements of `α`, i.e., `1 * x = x` for all `x` in `α`.


theorem neg_neg : ∀ {G : Type u_1} [inst : InvolutiveNeg G] (a : G), - -a = a := by sorry

This theorem, `neg_neg`, states that for any type within an `InvolutiveNeg` typeclass, the double negation of an element is equivalent to the element itself. In other words, given a type `G` that has an `InvolutiveNeg` instance and any element `a` of that type `G`, applying the negation operation twice (`- -a`) results in the original element `a`. This follows the mathematical principle that the double negation of a number is the number itself.

For any type `G` with an `InvolutiveNeg` instance, `-- a = a` holds for all elements `a` of `G`.


Decidable.byContradiction

theorem Decidable.byContradiction : ∀ {p : Prop} [dec : Decidable p], (¬p → False) → p := by sorry

This theorem, `Decidable.byContradiction`, states that for any proposition `p` which we can decide as either true or false (`Decidable p`), if we assume that the negation of `p` leads to a contradiction (expressed as `¬p → False`), then `p` must be true. In other words, it states the principle of proof by contradiction: if the assumption that `p` is not true leads to an impossibility, then `p` must be true. This is a fundamental principle in many areas of mathematics.

If `p` is a decidable proposition and assuming `¬p` leads to a contradiction, then `p` is true.


theorem add_assoc : ∀ {G : Type u_1} [inst : AddSemigroup G] (a b c : G), a + b + c = a + (b + c) := by sorry

This theorem states that for any type `G` that forms an additive semigroup, the operation of addition (`+`) is associative. In other words, for any three elements `a`, `b`, and `c` of `G`, the sum of `a`, `b`, and `c` doesn't depend on how the elements are grouped: adding `a` and `b` together first and then adding `c` is the same as adding `a` to the result of adding `b` and `c` together. This is expressed mathematically as `a + b + c = a + (b + c)`.

For any additive semigroup `G`, the operation `+` is associative, that is, `a + b + c = a + (b + c)` for all elements `a, b, c` of `G`.


theorem pow_zero : ∀ {M : Type u_2} [inst : Monoid M] (a : M), a ^ 0 = 1 := by sorry

This theorem, `pow_zero`, states that for any type `M` that forms a monoid (a set equipped with an associative binary operation and an identity element), raising any element `a` of `M` to the power of zero results in the identity element of the monoid. In other words, for any `a` in a monoid `M`, `a` to the power of zero equals one. This mirrors the familiar property from mathematics where any nonzero number raised to the power of zero equals one.

For any monoid `M` and element `a` in `M`, `a^0 = id`, where `id` is the identity element of the monoid.


theorem dif_neg : ∀ {c : Prop} {h : Decidable c} (hnc : ¬c) {α : Sort u} {t : c → α} {e : ¬c → α}, dite c t e = e hnc :=
  by sorry

The theorem `dif_neg` states that for any proposition `c`, given a proof `hnc` that `c` is not true (`¬c`), and two dependent functions `t` and `e` from `c` and `¬c` to any type `α` respectively, the `if-then-else` construct `dite` (which stands for "dependent if then else") will evaluate to `e hnc`. In other words, if `c` is false, `dite` ignores the function `t` and applies `e` to the proof of `¬c`.

If `c` is false and we have a proof `hnc` of it, then the evaluation of `dite` with arguments `c`, `t`, and `e` is equal to the application of `e` to `hnc`.


theorem dif_pos : ∀ {c : Prop} {h : Decidable c} (hc : c) {α : Sort u} {t : c → α} {e : ¬c → α}, dite c t e = t hc := by
  sorry

The theorem `dif_pos` states that for any proposition `c`, given that it is decidable and true (`hc : c`), and given two functions `t : c → α` and `e : ¬c → α`, the expression `dite c t e` (if `c` then `t` else `e`) will equal `t hc`. In other words, if the condition `c` is true, then the if-then-else expression will evaluate to the function `t` applied to the proof of `c`.

If `c` is a decidable and true proposition, then `dite c t e` equals `t (proof of c)`.


theorem Mathlib.Order.Basic._auxLemma.1 : ∀ {α : Type u} [inst : Preorder α] (a : α), (a ≤ a) = True := by sorry

This theorem states that for any type `α` which has a preorder structure, any element `a` from that type is less than or equal to itself. In math terms, it's confirming the reflexivity property of the preorder, i.e., ∀a in α, a ≤ a, which is always true by definition of a preorder.

For any preorder type `α`, every element `a` satisfies `a ≤ a`.


theorem eq_comm : ∀ {α : Sort u_1} {a b : α}, a = b ↔ b = a := by sorry

This theorem is named `eq_comm`, which stands for "equality is commutative". It states that for any sort `α` and any two elements `a` and `b` of `α`, `a` is equal to `b` if and only if `b` is equal to `a`. In mathematical terms, this theorem asserts the commutativity of equality, i.e., if $a = b$, then $b = a$, for any elements $a$ and $b$ of any sort $α$. This is a fundamental property of equality in mathematics.

For all sorts `α` and elements `a`, `b` of `α`, `a = b` if and only if `b = a`.


Subtype.prop

/-- A version of `x.property` or `x.2` where `p` is syntactically applied to the coercion of `x`
instead of `x.1`. A similar result is `Subtype.mem` in `Data.Set.Basic`.  -/
theorem Subtype.prop : ∀ {α : Sort u_1} {p : α → Prop} (x : Subtype p), p ↑x := by sorry

This theorem, `Subtype.prop`, states that for any type `α` and any property `p` that `α` might satisfy, if you have a subtype `x` of `α` that satisfies property `p`, then the property `p` holds for the coercion of `x` (i.e., `x` considered as an object of the original type `α`). This is similar to the `Subtype.mem` result in `Data.Set.Basic`. Essentially, it guarantees that any member of a subtype still satisfies the defining property of that subtype when viewed as a member of the original type.

If `x` is a subtype element of type `α` satisfying property `p`, then `p` holds for the coercion of `x` in type `α`.


Ne.symm

theorem Ne.symm : ∀ {α : Sort u} {a b : α}, a ≠ b → b ≠ a := by sorry

This theorem states that for all types `α` and for any two elements `a` and `b` of that type, if `a` is not equal to `b`, then `b` is not equal to `a`. In other words, inequality is symmetric in Lean, just as it is in Mathematics. If `a` and `b` are different, it doesn't matter in which order we consider them: the inequality holds either way.

For all types `α` and for all `a` and `b` in `α`, if `a ≠ b` then `b ≠ a`.


theorem ite_congr :
    ∀ {α : Sort u_1} {b c : Prop} {x y u v : α} {s : Decidable b} [inst : Decidable c],
      b = c → (c → x = u) → (¬c → y = v) → (if b then x else y) = if c then u else v :=
  by sorry

This theorem, `ite_congr`, states that for any type `α`, propositions `b` and `c`, and elements `x`, `y`, `u`, `v` of type `α`, given that we can decide whether `b` and `c` are true or false, if `b` is equal to `c`, and if when `c` is true `x` equals `u` and when `c` is false `y` equals `v`, then the value of the if-then-else expression `if b then x else y` is equal to the value of the if-then-else expression `if c then u else v`. In simpler terms, this theorem is about the congruency of if-then-else expressions under certain conditions.

If `b` is equal to `c`, and for all elements `x`, `y`, `u`, `v` of type `α`, `x = u` when `c` is true and `y = v` when `c` is false, then `if b then x else y` is equal to `if c then u else v`.


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

This theorem, `le_of_lt`, states that for any type `α` that has a preorder structure, if one element `a` is strictly less than another element `b`, then `a` is also less than or equal to `b`. In other words, in a preordered set, the strict less-than relation implies the less-than-or-equal-to relation.

For any preordered type `α`, if `a` is strictly less than `b`, then `a ≤ b`.


/-- Dividing by an element is the same as multiplying by its inverse.

This is a duplicate of `DivInvMonoid.div_eq_mul_inv` ensuring that the types unfold better.
 -/
theorem div_eq_mul_inv : ∀ {G : Type u_1} [inst : DivInvMonoid G] (a b : G), a / b = a * b⁻¹ := by sorry

This theorem states that for any given type `G` that has a `DivInvMonoid` structure, division of two elements `a` and `b` of `G` is equivalent to the multiplication of `a` with the inverse of `b`. Essentially, it expresses the standard relationship `a / b = a * (1 / b)` in terms of multiplication and inversion. This theorem ensures better unfolding of types and is a duplicate of the `DivInvMonoid.div_eq_mul_inv` theorem in Lean 4.

For any type `G` with a `DivInvMonoid` structure, the division of two elements `a` and `b` is equivalent to the multiplication of `a` by the multiplicative inverse of `b`. (Or, `a / b = a * b^(-1)`)


LT.lt.ne

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

This theorem, `LT.lt.ne`, is an alias of `ne_of_lt`. For any given type `α` that has a `Preorder` instance (meaning that you can compare two elements of the type through "less than" or "greater than"), it states that if `a` and `b` are elements of `α` and `a` is less than `b` (`a < b`), then `a` is not equal to `b` (`a ≠ b`). In other words, this theorem formalizes the intuitive concept that a number is not equal to another number that is greater than it.

For all types `α` with a `Preorder` instance, `a < b` implies `a ≠ b`.


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

This theorem, `Equiv.apply_symm_apply`, states that for all types α and β, if there's an equivalence `e` between them, then for any value `x` of type β, applying `e` to the result of applying the inverse of `e` (`e.symm`) to `x` brings you back to `x`. In other words, `e` and `e.symm` are inverses of each other. This might be seen as a formal way of saying that you can 'undo' the application of `e` by applying `e.symm` - a key property of equivalences in mathematics and logic.

For any equivalence `e` between types `α` and `β`, `e (x.symm) = x` for all `x` of type `β`.


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

This theorem, called `LE.le.trans_lt`, is an alias of `lt_of_le_of_lt`. It states that for any type `α` which has a predefined ordering (`Preorder`), if you have three elements `a`, `b`, and `c` of this type such that `a` is less than or equal to `b` and `b` is strictly less than `c`, you can conclude that `a` is strictly less than `c`. This theorem allows for the transitive property of inequalities in a preorder to be applied in cases where there is a combination of non-strict and strict inequalities.

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


Finset.ext

theorem Finset.ext : ∀ {α : Type u_1} {s₁ s₂ : Finset α}, (∀ (a : α), a ∈ s₁ ↔ a ∈ s₂) → s₁ = s₂ := by sorry

The theorem `Finset.ext` states that for any two finite sets `s₁` and `s₂` of an arbitrary type `α`, if every element `a` of type `α` is in `s₁` if and only if it is in `s₂`, then `s₁` and `s₂` are equal. This theorem underlines the extensionality principle for finite sets in Lean 4, which means that two sets are identical if they contain exactly the same elements.

If two finite sets have the same elements, then they are equal.


Or.elim

/-- Proof by cases on an `Or`. If `a ∨ b`, and both `a` and `b` imply
proposition `c`, then `c` is true.
 -/
theorem Or.elim : ∀ {a b c : Prop}, a ∨ b → (a → c) → (b → c) → c := by sorry

This theorem, `Or.elim`, is a proof by cases on an `Or` proposition. It states that, given three propositions `a`, `b`, and `c`, if the disjunction `a ∨ b` is true, and if both `a` and `b` imply `c` (i.e., `a → c` and `b → c`), then `c` must also be true. Essentially, it allows you to conclude `c` if you know that either `a` or `b` is true, and either one would imply `c`.

If `a ∨ b` holds and `a → c` and `b → c` are true in Lean 4 logic, then `c` is also true.


Filter.Eventually.mono

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

This theorem, `Filter.Eventually.mono`, states that for any type `α`, any two properties `p` and `q` of `α`, and any filter `f` of `α`, if `p` holds eventually at `f` and `p` implies `q` for all `α`, then `q` also holds eventually at `f`. In mathematical terms, given $f$ is a filter on a type $\alpha$ and $p$ and $q$ are propositions about elements of $\alpha$, if for all elements in $f$, $p$ holds eventually, and if for all elements of $\alpha$, $p$ implies $q$, then for all elements in $f$, $q$ also holds eventually.

If `p` holds eventually in a filter `f` of type `α` and `p` implies `q` for all `α`, then `q` holds eventually in `f`. (Mathematically: For all filters `f` on a type `α` and propositions `p` and `q` on `α`, if `p` holds eventually in `f` and `p` implies `q` for all `α`, then `q` holds eventually in `f`. )


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

This theorem states that for any type `α` that has zero and one as elements, along with a partial order and is a `ZeroLEOneClass` where zero is less than or equal to one, and where one is not zero, zero is strictly less than one. Essentially, it's asserting the mathematical truism that 0 < 1 under general conditions.

For any type `α` with zero and one as elements, having a partial order and being a `ZeroLEOneClass` with zero less than one, we have 0 < 1.


theorem Classical.choose_spec : ∀ {α : Sort u} {p : α → Prop} (h : ∃ x, p x), p (Classical.choose h) := by sorry

The theorem `Classical.choose_spec` states that for any type `α` and any property `p` that holds for some element of `α`, the element chosen by the function `Classical.choose` from the existence proof `h` also satisfies the property `p`. In other words, if there exists an element `x` of type `α` for which property `p` holds, then the property `p` will hold for the element returned by `Classical.choose` when called with the proof of this existence.

If `p` is a property that holds for some element of type `α`, then the element returned by `Classical.choose` from an existence proof of `p` also satisfies `p`.


Eq.le

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

This theorem, known as `Eq.le`, states that for any preordered type `α` and any two elements `a` and `b` of that type, if `a` is equal to `b`, then `a` is less than or equal to `b`. In other words, in any preordered set, an element is always less than or equal to itself.

In any preordered type, for all elements `a` and `b`, if `a = b`, then `a ≤ b`.


theorem and_true : ∀ (p : Prop), (p ∧ True) = p := by sorry

This theorem, `and_true`, is stating that for all propositions `p`, the logical conjunction of `p` and `True` is equivalent to `p` itself. In other words, if you have a statement `p` and you add "and true" to it, it doesn't change the truth value of the original statement `p`. This statement is a basic property of logical conjunction in classical logic.

For all propositions p, p ∧ True is equivalent to p. (In classical logic, conjunction with a true proposition does not change the truth value of the original proposition.)


theorem eq_false' : ∀ {p : Prop}, (p → False) → p = False := by sorry

This theorem states that for any proposition 'p', if 'p' implies falsehood (denoted as `p → False`), then 'p' is equivalent to false (denoted as `p = False`). Essentially, it suggests that if assuming 'p' leads to a contradiction or a false statement, then 'p' itself must be false. This theorem is a formal statement of the principle of reductio ad absurdum in propositional logic.

If `p → False`, then `p = False`. (This theorem formalizes the principle of proof by contradiction or reductio ad absurdum in propositional logic.)


theorem map_mul :
    ∀ {M : Type u_4} {N : Type u_5} {F : Type u_9} [inst : Mul M] [inst_1 : Mul N] [inst_2 : FunLike F M N]
      [inst_3 : MulHomClass F M N] (f : F) (x y : M), f (x * y) = f x * f y :=
  by sorry

The theorem `map_mul` states that for all types `M`, `N`, and `F`, if `M` and `N` have a multiplication operation, `F` is a type that can be injected into a function from `M` to `N` (denoted by `[FunLike F M N]`), and `F` belongs to the `MulHomClass` (meaning it is a multiplication homomorphism), then for any function `f` of type `F` and any elements `x` and `y` of type `M`, the value of `f` at the product of `x` and `y` is the same as the product of the values of `f` at `x` and `y`. In mathematical terms, this theorem is expressing the property $f(x \cdot y) = f(x) \cdot f(y)$ for a multiplication homomorphism `f`.

For any multiplication homomorphism `f` from type `M` to type `N`, `f(x * y) = f(x) * f(y)` for all `x, y` in `M`.


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

The theorem `Function.Injective.eq_iff` states that for any types `α` and `β`, and for any function `f` from `α` to `β`, if `f` is injective (that is, `f x = f y` implies `x = y`), then for all elements `a` and `b` of `α`, `f a` is equal to `f b` if and only if `a` is equal to `b`. In other words, the equality of function outputs is equivalent to the equality of inputs for an injective function.

For any function `f:` X → Y between types X and Y, `f` being injective (i.e., `f x = f y` implies `x = y`) is equivalent to `x = y` if and only if `f x = f y`.


theorem map_one :
    ∀ {M : Type u_4} {N : Type u_5} {F : Type u_9} [inst : One M] [inst_1 : One N] [inst_2 : FunLike F M N]
      [inst_3 : OneHomClass F M N] (f : F), f 1 = 1 :=
  by sorry

The theorem `map_one` states that for any types `M`, `N`, and `F`, given that `M` and `N` have a one (unit) element (i.e., they are equipped with a `One` structure), and `F` is a function-like object from `M` to `N` (as stipulated by the `FunLike` structure), and `F` preserves the one element (as expressed by `OneHomClass`), then applying any `F` to the one element of `M` yields the one element of `N`. In short, this theorem asserts that, under the given conditions, the one element is preserved under `F`.

If `M` and `N` are types with one elements and `F` is a function-like object from `M` to `N` preserving the one element, then `F (one_M) = one_N`.


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

This theorem, `LT.lt.trans_le`, is an alias of `lt_of_lt_of_le`. It states that for any type `α` which has a `Preorder` instance, if `a`, `b` and `c` are elements of `α`, and if `a` is less than `b` and `b` is less than or equal to `c`, then `a` is less than `c`. This theorem generalizes the concept of transitivity of the less-than relation to the less-than-or-equal-to relation.

If `α` is a preordered type and `a`, `b`, `c` are elements of `α` with `a < b` and `b <= c`, then `a < c`.


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

This theorem, `sub_self`, states that for all types `G` that have an `AddGroup` structure, the subtraction of any element `a` from itself results in the identity element of addition, which is `0`. In other words, in any additive group, subtracting any element from itself always yields `0`.

For any type `G` with an `AddGroup` structure, `a` being an element of `G`, we have `a - a = 0`.


theorem map_add :
    ∀ {M : Type u_4} {N : Type u_5} {F : Type u_9} [inst : Add M] [inst_1 : Add N] [inst_2 : FunLike F M N]
      [inst_3 : AddHomClass F M N] (f : F) (x y : M), f (x + y) = f x + f y :=
  by sorry

The theorem `map_add` states that for all types `M`, `N`, and `F`, if `M` and `N` are equipped with addition operation, `F` is a function-like object from `M` to `N`, and `F` is an additive homomorphism (as specified by `AddHomClass F M N`), then for any function `f` of type `F` and any elements `x` and `y` of type `M`, the image of the sum `x + y` under `f` is equal to the sum of the images of `x` and `y` under `f`. In mathematical notation, this can be written as `f(x + y) = f(x) + f(y)`, which is the defining property of an additive homomorphism.

For any additive homomorphism F from type M to type N and any elements x, y of type M, we have F(x + y) = F(x) + F(y).


theorem eq_or_ne : ∀ {α : Sort u_1} (x y : α), x = y ∨ x ≠ y := by sorry

This theorem, `eq_or_ne`, states that for any given type `α` (which could be any sort of data, such as a number or a list), and for any two instances `x` and `y` of that type, it is always the case that either `x` equals `y`, or `x` does not equal `y`. This is a fundamental law in logic and mathematics, often referred to as the Law of Excluded Middle.

For all types `α` and elements `x, y` of type `α`, we have `x = y < burning_issues_or_x_neq_y >`. Here, `<burning_issues_or_x_neq_y>` is the logical OR of `x = y` and `x ≠ y`.


theorem Filter.univ_mem' : ∀ {α : Type u} {f : Filter α} {s : Set α}, (∀ (a : α), a ∈ s) → s ∈ f := by sorry

This theorem, named `Filter.univ_mem'`, states that for any type `α`, any filter `f` on `α`, and any set `s` of type `α`, if every element `a` of type `α` belongs to the set `s`, then the set `s` is a member of the filter `f`. In other words, it states that if all elements of a particular type are in a set, that set is part of a certain filter.

If `s` is a set of type `α` and every element `a` of `α` belongs to `s`, then `s` is an element of filter `f` on type `α`.


Continuous.comp

theorem Continuous.comp :
    ∀ {X : Type u_1} {Y : Type u_2} {Z : Type u_3} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y]
      [inst_2 : TopologicalSpace Z] {f : X → Y} {g : Y → Z}, Continuous g → Continuous f → Continuous (g ∘ f) :=
  by sorry

This theorem states that for any three types `X`, `Y`, and `Z`, where each type is equipped with a topological space structure, if `f` is a continuous function from `X` to `Y` and `g` is a continuous function from `Y` to `Z`, then the composition of `g` and `f` (denoted by `g ∘ f`) is also a continuous function. This is a fundamental theorem in topology known as the composition of continuous functions theorem.

If `f` is a continuous function from type `X` to `Y` and `g` is a continuous function from type `Y` to `Z`, then the composition `g ∘ f` is a continuous function from `X` to `Z`.


/-- **Alias** of `congrFun`.

---

Congruence in the function part of an application: If `f = g` then `f a = g a`.  -/
theorem congr_fun : ∀ {α : Sort u} {β : α → Sort v} {f g : (x : α) → β x}, f = g → ∀ (a : α), f a = g a := by sorry

The theorem `congr_fun` expresses the idea of congruence in function application. It states that for any two functions `f` and `g` from a sort `α` to a sort `β` that depends on `α`, if `f` and `g` are equal (i.e., `f = g`), then applying `f` and `g` to the same element `a` in `α` will also give equal results (i.e., `f a = g a`). This is a fundamental property of function application in Mathematics.

If `f` and `g` are equal functions from sort `α` to sort `β`, then `f(a) = g(a)` for all `a` in `α`.


theorem CategoryTheory.Limits.comp_zero :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
      {X Y : C} {f : X ⟶ Y} {Z : C}, CategoryTheory.CategoryStruct.comp f 0 = 0 :=
  by sorry

The theorem `CategoryTheory.Limits.comp_zero` states that for any category `C` which has zero morphisms, given any objects `X`, `Y`, and `Z` in `C` and a morphism `f` from `X` to `Y`, the composition of `f` with the zero morphism from `Y` to `Z` is the zero morphism from `X` to `Z`. This is a formal expression of the fact in category theory that composing any morphism with the zero morphism results in the zero morphism.

For any category with zero morphisms, the composition of any morphism with the zero morphism is the zero morphism.


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

This theorem, named "le_of_le_of_eq", states that for any type `α` which has a less-than-or-equal-to (`≤`) relation, given three elements `a`, `b`, and `c` of this type, if `a` is less than or equal to `b` and `b` is equal to `c`, then `a` is less than or equal to `c`. This theorem is applying the transitivity of the less-than-or-equal-to relation in combination with the substitution property of equality.


theorem smul_zero : ∀ {M : Type u_1} {A : Type u_4} [inst : Zero A] [inst_1 : SMulZeroClass M A] (a : M), a • 0 = 0 :=
  by sorry

This theorem states that for any type `M` and any type `A` where `A` has a zero element and `M` and `A` form a scalar multiplication zero class (which means `M` can be a scalar multiple of `A` and when scalar multiplied by zero gives zero), then the scalar multiplication of any element of `M` with the zero element of `A` is equal to zero. In mathematical notation, this can be represented as: for all `a` in `M`, `a * 0 = 0`.

For any type `M` with scalar multiplication by a type `A` having a zero element, `a * 0 = 0` for all `a` in `M`.


theorem sub_zero : ∀ {G : Type u_3} [inst : SubNegZeroMonoid G] (a : G), a - 0 = a := by sorry

This theorem, named `sub_zero`, states that in any subtraction-negative-zero monoid `G` (a specific algebraic structure with subtraction and zero elements), subtracting zero from any element `a` of `G` results in `a` itself. In other words, for any given element in this subtraction-negative-zero monoid, subtracting zero does not change the value of the element. The theorem generalizes the common idea familiar from basic arithmetic where subtracting zero from any number leaves the number unchanged.

In a subtraction-negative-zero monoid, subtracting zero from any element is the identity operation.


theorem Int.sub_nonneg_of_le : ∀ {a b : ℤ}, b ≤ a → 0 ≤ a - b := by sorry

This theorem, `Int.sub_nonneg_of_le`, states that for any two integers `a` and `b`, if `b` is less than or equal to `a` (denoted by `b ≤ a`), then the result of the subtraction of `b` from `a` (denoted by `a - b`) is guaranteed to be non-negative (denoted by `0 ≤ a - b`). In other words, it asserts that in the integer domain, subtracting a smaller number or an equal number from a larger or equal number always results in a non-negative number.

For all integers a and b, if b ≤ a then 0 ≤ a - b.


theorem not_true_eq_false : (¬True) = False := by sorry

This theorem states that the negation of the proposition `True` is equal to `False`. In other words, it's saying that if we claim `True` is not true, this is the same as saying `False`. This matches the intuitive understanding of truth values: denying something that is undeniably true gives us falsehood.

The negation of `True` is equal to `False`. In mathematical notation: `~(true : Prop) = false`.


theorem Subtype.coe_injective : ∀ {α : Sort u_1} {p : α → Prop}, Function.Injective fun a => ↑a := by sorry

The theorem `Subtype.coe_injective` states that for any type `α` and any predicate `p` on `α`, the function that maps an element `a` of the subtype `{a : α | p a}` to its corresponding element in `α` (denoted `↑a` or `coe a`) is injective. In other words, no two distinct elements of the subtype map to the same element in `α` under the coercion function. In mathematical terms, if `a` and `b` are elements of the subtype and `↑a = ↑b`, then `a = b`.

If `a` and `b` are elements of the subtype `{a : α | p a}`, then `↑a = ↑b` implies `a = b`.


theorem Filter.mp_mem : ∀ {α : Type u} {f : Filter α} {s t : Set α}, s ∈ f → {x | x ∈ s → x ∈ t} ∈ f → t ∈ f := by sorry

The theorem `Filter.mp_mem` states that for any type `α`, any filter `f` on `α`, and any two sets `s` and `t` of type `α`, if `s` is in `f` and all elements of `s` are also in `t`, then `t` is in `f`. Here, "being in `f`" is interpreted as the set being in the collection defined by the filter `f`. This theorem is a form of modus ponens specialized to the context of filters and sets.

If a filter `f` on a type `α` contains a set `s`, and every element of `s` is in another set `t`, then `t` is contained in `f`.


theorem zero_smul :
    ∀ (R : Type u_1) {M : Type u_3} [inst : Zero R] [inst_1 : Zero M] [inst_2 : SMulWithZero R M] (m : M), 0 • m = 0 :=
  by sorry

This theorem, `zero_smul`, states that for any type `R` with a zero element, and any type `M` also with a zero element, if `R` and `M` form a scalar multiplication structure with zero (`SMulWithZero`), then scalar multiplication of any element `m` of type `M` by the zero of `R` results in the zero of `M`. In mathematical terms, if we can multiply elements of `R` with elements of `M` in a way that respects zero, then 0 times any element is always zero.

For types `R` and `M` with zero elements, if `R` and `M` have a scalar multiplication structure with zero then multiplication by the zero of `R` results in the zero of `M`.


theorem CategoryTheory.Limits.zero_comp :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
      {X Y Z : C} {f : Y ⟶ Z}, CategoryTheory.CategoryStruct.comp 0 f = 0 :=
  by sorry

The theorem `CategoryTheory.Limits.zero_comp` states that for any category `C` with zero morphisms, and any objects `X`, `Y`, `Z` in `C`, if `f` is a morphism from `Y` to `Z`, then the composition of the zero morphism (from `X` to `Y`) and `f` is the zero morphism (from `X` to `Z`). Here, zero morphisms are the morphisms that behaves like zero in the category. Essentially, this theorem is saying that "zero times anything is zero" but in the context of category theory.

For any category with zero morphisms, the composition of a zero morphism with any morphism is the zero morphism.


/-- Show that an element extracted from `P : ∃ a, p a` using `P.choose` satisfies `p`.  -/
theorem Exists.choose_spec : ∀ {α : Sort u_1} {p : α → Prop} (P : ∃ a, p a), p (Exists.choose P) := by sorry

The theorem `Exists.choose_spec` states that for any propositional function `p` on elements of type `α` and for any existential statement `P` of the form "there exists an element `a` such that `p(a)` is true", the element extracted from this existential statement `P` using the function `Exists.choose` satisfies the property `p`. In other words, if `P` is a proof of existence of an element satisfying `p`, then `p` holds for `Exists.choose P`.

For any propositional function `p` and existential statement "there exists an element `a` of type `α` such that `p(a)` holds, the extracted element `Exists.choose (exists a, p a)` satisfies `p`.


theorem SetLike.coe_injective : ∀ {A : Type u_1} {B : Type u_2} [i : SetLike A B], Function.Injective SetLike.coe := by
  sorry

The theorem `SetLike.coe_injective` states that for any types `A` and `B`, given an instance of `SetLike A B`, the coercion function `SetLike.coe` is injective. In other words, if `SetLike.coe` applied to two different elements of type `A` gives the same set of type `B`, then the two elements of type `A` were actually the same. In mathematical terms, if `SetLike.coe a1 = SetLike.coe a2`, then `a1 = a2`. This theorem ensures the uniqueness of elements in the `SetLike` structure when mapped to their corresponding set.

Given types `A` and `B` with an instance of `SetLike A B`, `SetLike.coe` is an injection from `A` to the sets represented by elements of type `B`.


HasSubset.Subset.trans

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

This theorem, named `HasSubset.Subset.trans`, is an alias for `subset_trans`. It states that for any type `α` that has a subset operation (`HasSubset α`) and in which this subset relation is transitive (`IsTrans α fun x x_1 => x ⊆ x_1`), if `a` is a subset of `b` and `b` is a subset of `c`, then `a` is a subset of `c`. In other words, the subset relationship is transitive: if `a` is included in `b`, and `b` is included in `c`, then `a` must be included in `c`.

For types `α` with transitive subset relation, if `a ⊆ b` and `b ⊆ c`, then `a ⊆ c`.


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

This theorem, named `pow_one`, states that for any type M that has a monoid structure, the monoid operation applied to any element "a" of that type and the number 1 is equal to the element "a" itself.

In other words, for any monoid (a mathematical structure with an associative binary operation and an identity element), raising any element to the power of 1 keeps the element unchanged. This is a basic property of powers in mathematics, and here it's confirmed to hold in the context of abstract algebraic structures called monoids.

For any monoid M and its identity element 1, for all a in M, a ^ 1 = a holds. (Here, ^ represents the monoid operation.)


theorem neg_zero : ∀ {G : Type u_1} [inst : NegZeroClass G], -0 = 0 := by sorry

This theorem, `neg_zero`, states that for any type `G` that is a member of the `NegZeroClass`, the negation of zero equals zero. In mathematical terms, it means that if `G` has a negation operation and a zero element, then the negation of the zero element is equal to the zero element itself.

For any type `G` in the `NegZeroClass`, the negation of its zero element is equal to the zero element itself.


theorem exists_prop_congr' :
    ∀ {p p' : Prop} {q q' : p → Prop}, (∀ (h : p), q h ↔ q' h) → ∀ (hp : p ↔ p'), Exists q = ∃ (h : p'), q' ⋯ := by
  sorry

This theorem states that for any propositions `p` and `p'`, and for any properties `q` and `q'` that depend on `p`, if for all `h` in `p`, `q h` is equivalent to `q' h`, and if `p` is equivalent to `p'`, then there exists an `h` in `p` such that `q h` is true if and only if there exists an `h` in `p'` such that `q' h` is true. The theorem thus establishes a congruence relationship for existential quantifiers under certain conditions of proposition and property equivalence.

If propositions `p` and `p'` are equivalent, and for all `h` in `p`, properties `q(h)` and `q'(h)` are equivalent, then there exists a common element `h` in `p` and `p'` such that `q(h)` if and only if `q'(h)` is true.


LinearMap.ext

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

This theorem, `LinearMap.ext`, states that for any two linear maps `f` and `g` from a module `M` over a semiring `R` to a module `M₃` over a semiring `S` (with a ring homomorphism `σ` from `R` to `S`), if for every element `x` in `M` the mappings `f x` and `g x` are equal, then the two linear maps `f` and `g` are themselves equal. This is a statement about the uniqueness of linear maps in mathematical structure.

If two linear maps from one module over a semiring to another module over a semiring, with a given ring homomorphism between the semirings, map every element to the same image, then the linear maps are equal.


theorem ite_cond_eq_true : ∀ {α : Sort u} {c : Prop} {x : Decidable c} (a b : α), c = True → (if c then a else b) = a :=
  by sorry

This theorem states that for any type `α`, proposition `c`, and decidable instance `x` of `c`, along with two variables `a` and `b` of type `α`, if `c` is equivalent to `True`, then the `if` expression evaluates to `a`. In other words, when a condition of an if-then-else expression is true, the expression evaluates to the value in the 'then' branch.

For any type `α`, decidable proposition `c`, and values `a`, `b` of type `α`, if `c` is true and `x` is an instance of `decidable c`, then `if c then a else b` equals `a`.


theorem DFunLike.coe_injective :
    ∀ {F : Sort u_1} {α : Sort u_2} {β : α → Sort u_3} [i : DFunLike F α β], Function.Injective fun f => ⇑f := by sorry

The theorem `DFunLike.coe_injective` states that for any sort `F`, any sort `α`, any function `β : α → Sort u_3`, and any instance `i` of `DFunLike F α β`, the function that sends `f` to its coercion to a function `⇑f` is injective. In other words, if the function-application results of two different instances of `DFunLike F α β` are the same for all inputs, then the two instances are the same. This theorem guarantees that we cannot have two distinct `DFunLike` instances that behave identically when used as functions.

If two functions `β : α -> Sort u_3` have the same coercions to functions for all `f : α` under the same `DFunLike F α β` instance, then those instances are equal.


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

This theorem states that for any two integer variables, `a` and `b`, if `a` is less than `b`, then the sum of `a` and 1 is less than or equal to `b`. In mathematical terms, if \(a < b\), then \(a + 1 \leq b\).

For all integers a and b, if a < b then a + 1 <= b.


congrFun

/-- Congruence in the function part of an application: If `f = g` then `f a = g a`.  -/
theorem congrFun : ∀ {α : Sort u} {β : α → Sort v} {f g : (x : α) → β x}, f = g → ∀ (a : α), f a = g a := by sorry

This theorem, named `congrFun`, states that if two functions `f` and `g` are equal (denoted as `f = g`), then the result of applying these functions to the same argument `a` will also be equal (denoted as `f a = g a`). These functions `f` and `g` are from a sort `α` to a sort `β`, where `β` itself is a function of `α`. This theorem holds for any sort `α` and `β` and any functions `f` and `g` of the specified type, and any element `a` of sort `α`.

If two functions `f` and `g` from sort `α` to a function of `α` `β` are equal, then `f x = g x` for all `x` in `α`.


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

This theorem, `Filter.eventually_of_forall`, states that for any type `α`, any predicate `p` of type `α → Prop`, and any filter `f` of type `Filter α`, if `p` is true for all `x` of type `α`, then `p` is eventually true for `x` under the filter `f`. In other words, if a statement holds for all elements in a set, it will hold for elements 'eventually' in any filter applied to that set.

For any type `α`, filter `f` of type `Filter α`, and predicate `p` of type `α → Prop`, if `p` holds for all elements in the underlying set, then there exists a finite subset whose elements have `p` holding under the filter `f`.


theorem and_false : ∀ (p : Prop), (p ∧ False) = False := by sorry

This theorem states that for any proposition `p`, the logical conjunction of `p` and `False` is equivalent to `False`. In terms of logical operations, this means that `False` combined with any other statement using an "and" operation results in `False`, regardless of the truth value of the other statement.

For all propositions p, p AND False equals False.


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

This theorem, `le_top`, states that for any given type `α` that has a less than or equal to (`LE`) relation and a greatest element (`OrderTop`), any element `a` of type `α` is less than or equal to the greatest element (`⊤`). In other words, it's asserting that for any element in a partially ordered set with a top element, that element is always less than or equal to the top.

For any type `α` equipped with a `LE` relation and an `OrderTop`, every element `a` in `α` satisfies `a ≤ ⊤`.


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

This theorem, `Nat.lt_of_not_le`, states that for any two natural numbers `a` and `b`, if it is not the case that `a` is less than or equal to `b` (`¬a ≤ b`), then we can infer that `b` is strictly less than `a` (`b < a`). This is a fundamental property of ordering on the natural numbers.

If `a` is not less than or equal to `b` (`a > b` or `a = b`), then `b` is strictly less than `a` (`b < a`).


theorem continuous_id : ∀ {X : Type u_1} [inst : TopologicalSpace X], Continuous id := by sorry

This theorem states that the identity function is continuous for any topological space. In more formal terms, given any type `X` equipped with a topology (indicated by `TopologicalSpace X`), the identity function (denoted by `id`) on this space is always continuous. Recall that a function is continuous if the preimage of any open set is also an open set. Here, since the identity function just returns its input, it clearly satisfies this property.

The identity function is continuous on any topological space.


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

This theorem states that for any type `α` that has a Preorder structure, if `a`, `b`, and `c` are elements of `α`, then if `a` is less than or equal to `b`, and `b` is strictly less than `c`, it follows that `a` is strictly less than `c`. In other words, if `a` is not greater than `b`, and `b` is less than `c`, then `a` is less than `c`. This is a fundamental property of ordered sets or fields.

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


theorem inv_inv : ∀ {G : Type u_1} [inst : InvolutiveInv G] (a : G), a⁻¹⁻¹ = a := by sorry

This theorem states that for any type `G` that has an involutive inverse property (that is, the inverse operation is its own inverse), the double inverse of any element `a` of `G` is equal to `a` itself. In mathematical terms, for all `a` in `G`, (a⁻¹)⁻¹ = a.

For any type `G` with involutive inverses, the double inverse of any element `a` equals `a` itself: (a⁻¹)⁻¹ = a.


theorem Mathlib.Data.Set.Basic._auxLemma.45 :
    ∀ {α : Sort u_1} {p : α → Prop} {b : Prop}, (∃ x, b ∧ p x) = (b ∧ ∃ x, p x) := by sorry

This theorem states that for any type `α`, any predicate `p` applied to `α`, and any proposition `b`, the existence of an element `x` such that both `b` and `p x` hold is equivalent to the conjunction `b` and the existence of an element `x` for which `p x` holds. In other words, the order of the conjunction and the existential quantifier does not matter in this context.

For any type `α`, predicate `p` on `α`, and proposition `b`, the existence of an `x` such that `p x` and `b` hold is equivalent to the existence of an `x` satisfying `p x` and `b` together.


Eq.ge

/-- If `x = y` then `y ≤ x`. Note: this lemma uses `y ≤ x` instead of `x ≥ y`, because `le` is used
almost exclusively in mathlib.  -/
theorem Eq.ge : ∀ {α : Type u} [inst : Preorder α] {x y : α}, x = y → y ≤ x := by sorry

This theorem, `Eq.ge`, states that for any given type `α` that has a preorder relationship, if `x` is equal to `y` then `y` is less than or equal to `x`. Preorder is a binary relation that is reflexive and transitive. It's important to note that in the Lean mathlib, the `≤` (is less than or equal to) operator is used almost exclusively, hence `y ≤ x` is used here instead of `x ≥ y` (is greater than or equal to).

For all types `α` with a preorder relation and all `x y` of type `α`, if `x = y`, then `y ≤ x`.


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

This theorem states that for all types α and β, if there exists an equivalence between α and β (denoted as "e : α ≃ β"), then applying the equivalence to an element of α (denoted as "x : α") and then applying the inverse of the equivalence (denoted as "e.symm") to the result, we get back the original element. In simpler terms, this theorem supports the idea that the inverse of an equivalence undoes the effect of the original equivalence.

For all types α and β and equivalences e : α ≃ β, for all x : α, e.symm (e x) = x.


theorem pow_succ : ∀ {M : Type u_2} [inst : Monoid M] (a : M) (n : ℕ), a ^ (n + 1) = a ^ n * a := by sorry

This theorem, named `pow_succ`, is a statement about the power operation in the context of a monoid. The theorem holds for any type `M` that has a `Monoid` structure. Given an element `a` of type `M` and an natural number `n`, the theorem states that raising `a` to the power of `n + 1` is equivalent to multiplying `a` raised to the power of `n` by `a`. This corresponds to the well-known property of exponentiation that `a` to the power of `n+1` is just `a` to the power of `n` times `a`.

For any monoid `M` and element `a` in `M` and natural number `n`, `a^(n + 1)` equals `a^n * a`.


Iff.not

/-- **Alias** of `not_congr`. -/
theorem Iff.not : ∀ {a b : Prop}, (a ↔ b) → (¬a ↔ ¬b) := by sorry

This theorem, referred to as "Iff.not", asserts that for any two propositions `a` and `b`, if `a` is equivalent to `b` (denoted by `a ↔ b`), then the negation of `a` is equivalent to the negation of `b` (denoted by `¬a ↔ ¬b`). Essentially, it is stating that the equivalence of two propositions remains unchanged when both propositions are negated. This theorem serves as an alias for the `not_congr` theorem in Lean.

For all propositions `a` and `b`, if `a ↔ b`, then `¬a ↔ ¬b`.


theorem ite_cond_eq_false :
    ∀ {α : Sort u} {c : Prop} {x : Decidable c} (a b : α), c = False → (if c then a else b) = b := by sorry

This theorem, `ite_cond_eq_false`, states that for any type `α` and propositions `c` and `x`, where `x` can decide `c`, and any two instances `a` and `b` of `α`, if `c` is equivalent to `False`, then the "if-then-else" expression `(if c then a else b)` will always result in `b`. In other words, if the condition in an "if-then-else" clause is False, then the part following "else" will always be executed.

If `c` is equivalent to `False` and `x` decides `c`, then `(if c then a else b)` equals `b` for all `α`, `a`, and `b` of type `α`.


Equiv.injective

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

The theorem `Equiv.injective` states that for all types `α` and `β`, if there exists a bijective function `e` from `α` to `β` (denoted as `α ≃ β`), then the function `e` is injective. In other words, for every two elements `a₁` and `a₂` in `α`, if `e` of `a₁` equals `e` of `a₂`, it implies that `a₁` equals `a₂`. This is the defining property of an injective function.

If `α` and `β` are types with a bijective function `e : α ≃ β`, then `e` is injective (i.e., for all `a₁ a₂ : α`, if `e a₁ = e a₂`, then `a₁ = a₂`).


theorem bot_le : ∀ {α : Type u} [inst : LE α] [inst_1 : OrderBot α] {a : α}, ⊥ ≤ a := by sorry

This theorem states that for any type `α` that has a `≤` (less than or equal to) operation and a bottom element `⊥` (which is the least element in the type), the bottom element is less than or equal to any element `a` of type `α`. In other words, in any ordered set with a smallest element (the bottom element), that smallest element is always less than or equal to any other element in the set.

For any type `α` equipped with a `≤` relation and a bottom element `⊥`, we have `⊥ ≤ a` for all `a : α`.


Filter.Tendsto.comp

theorem Filter.Tendsto.comp :
    ∀ {α : Type u} {β : Type v} {γ : Type w} {f : α → β} {g : β → γ} {x : Filter α} {y : Filter β} {z : Filter γ},
      Filter.Tendsto g y z → Filter.Tendsto f x y → Filter.Tendsto (g ∘ f) x z :=
  by sorry

The theorem `Filter.Tendsto.comp` asserts that for all types `α`, `β`, and `γ`, and for all functions `f : α → β` and `g : β → γ`, and all filters `x : Filter α`, `y : Filter β` and `z : Filter γ`, if function `g` tends towards filter `z` when starting from filter `y`, and function `f` tends towards filter `y` when started from filter `x`, then the composition of `g` and `f` (i.e., `g ∘ f`) also tends towards `z` when started from `x`. This theorem essentially establishes the property of composition for the limit of a function in the context of filters.

If functions `f : α → β` and `g : β → γ` tend towards filters `z : Filter γ` and `y : Filter β`, respectively, when started from filters `x : Filter α` and `y`, then the composition `g ∘ f` tends towards `z` when started from `x`.


theorem Mathlib.Logic.Basic._auxLemma.44 : ∀ (p : True → Prop), (∀ (x : True), p x) = p True.intro := by sorry

This theorem states that for any property `p` that depends on a truth value, asserting that this property holds for all truth values is equivalent to asserting that it holds for `True.intro`, the only instance of truth. Here, `True.intro` is Lean's way of representing the concept of 'true'. Essentially, this theorem is pointing out that if a property is always true, then it is specifically true for the value of 'true'.

For any property `p`, `∀ (b : Bool), p b ≃ p True.intro`.


theorem Filter.mem_of_superset : ∀ {α : Type u} {f : Filter α} {x y : Set α}, x ∈ f → x ⊆ y → y ∈ f := by sorry

This theorem states that for any type 'α', any filter 'f' of 'α', and any two sets 'x' and 'y' of 'α', if 'x' is a member of 'f' and 'x' is a subset of 'y', then 'y' is also a member of 'f'. In other words, if a set 'x' belongs to a filter and another set 'y' includes all elements of 'x', then 'y' also belongs to the same filter.

If a filter 'f' of type 'α' contains a set 'x' and 'x' is a subset of another set 'y' in 'α', then 'y' is also in 'f'.


theorem continuous_const :
    ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {y : Y},
      Continuous fun x => y :=
  by sorry

This theorem states that for any two types `X` and `Y`, where `X` and `Y` are endowed with a topological structure (i.e., `X` and `Y` are topological spaces), any function that maps every element of `X` to a specific constant element `y` of `Y` is continuous. In the language of mathematics, it means a constant function between two topological spaces is always continuous.

Given any two topological spaces `X` and `Y`, and any constant function `f : X → Y`, the function `f` is continuous.


LE.le.antisymm

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

This theorem, which is an alias of `le_antisymm`, states that for any partially ordered set `α`, if an element `a` is less than or equal to another element `b`, and `b` is also less than or equal to `a`, then `a` and `b` are actually equal. This is a fundamental property of partial orders, reflecting the antisymmetry characteristic of such structures.

In a partially ordered set, if x <= y and y <= x, then x = y.


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

This theorem states that for any proposition 'p', the logical disjunction (denoted by '∨') of 'p' and 'True' is always 'True'. In other words, regardless of whether 'p' is true or false, since one of the components of the disjunction is 'True', the overall outcome will always be 'True'. This aligns with the rules of Boolean logic where anything OR'd with 'True' results in 'True'.

For any proposition p, p ∨ True is true.


theorem false_and : ∀ (p : Prop), (False ∧ p) = False := by sorry

This theorem states that for any proposition `p`, the logical conjunction (i.e., "and") of `False` and `p` is always `False`. This is due to the property of logical conjunctions where if any of the propositions is `False`, the whole conjunction is `False` regardless of the truth value of the other propositions.

The logical conjunction of False and any proposition p is equal to False.


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

This theorem states that for any proposition `p`, the disjunction of `True` and `p` is always `True`. In other words, no matter what `p` is, `True` OR `p` will always be `True`. In terms of symbolic logic, if you have "True OR anything", it's always guaranteed to be `True`.

For all propositions p, True \|\ p holds true. (In the context of Lean 4 logic, where \|\ represents disjunction.)


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

This theorem states that for any type `α` which forms a semilattice with respect to an infimum operation `⊓`, the infimum of any two elements `a` and `b` of `α` is less than or equal to `a`. In terms of set theory, this means that the greatest lower bound of `a` and `b` is always less than or equal to `a`.

For any semilattice `α` with infimum operation `⊓`, for all `a, b ∈ α`, we have `a ⊓ b ≤ a`.


CategoryTheory.NatTrans.ext'

theorem CategoryTheory.NatTrans.ext' :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂}
      [inst_1 : CategoryTheory.Category.{v₂, u₂} D] {F G : CategoryTheory.Functor C D} {α β : F ⟶ G},
      α.app = β.app → α = β :=
  by sorry

The theorem `CategoryTheory.NatTrans.ext'` states that for any two categories `C` and `D` (of types `u₁` and `u₂`, and with category structures `inst` and `inst_1`, respectively) and any two functors `F` and `G` from `C` to `D`, and for natural transformations `α` and `β` from `F` to `G`, if the application of `α` and `β` are equal, then `α` is equal to `β`. This is a result in category theory that says that natural transformations are completely determined by their action on objects.

Given categories `C` and `D` with functors `F` and `G` from `C` to `D`, and natural transformations `α` and `β` from `F` to `G`, if `α.app (x) = β.app (x)` for all objects `x` in `C`, then `α = β`.


theorem one_ne_zero : ∀ {α : Type u_2} [inst : Zero α] [inst_1 : One α] [inst_2 : NeZero 1], 1 ≠ 0 := by sorry

This theorem simply states that one is not equal to zero. It is generalized to any type `α` that has defined zero and one values, under the condition that `α` also has the property `NeZero 1`, meaning that one as defined in `α` is not zero. In mathematical terms, this can be expressed as ∀α. 1_α ≠ 0_α.

For all types `α` with defined zero and one values, and where `α` has the property `NeZero 1`, one (1\_α) is not equal to zero (0\_α).


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

This theorem, `le_of_eq`, states that for any type `α` that has a Preorder relation, given any two elements `a` and `b` of this type, if `a` is equal to `b`, then `a` is less than or equal to `b`. This theorem is quite intuitive as it's clear that any element is less than or equal to itself, but it's nonetheless important in establishing the basic properties of a Preorder relation in a type.

For any type `α` with a Preorder relation, if `a` is equal to `b`, then `a ≤ b` (where `≤` denotes the Preorder relation).


Prod.ext

theorem Prod.ext : ∀ {α : Type u_1} {β : Type u_2} {x y : α × β}, x.1 = y.1 → x.2 = y.2 → x = y := by sorry

This theorem states that for any two pairs of types `α` and `β`, represented as `x` and `y`, if the first elements (accessed by `x.1` and `y.1`) of the pairs are equal and the second elements (accessed by `x.2` and `y.2`) of the pairs are also equal, then the pairs themselves (`x` and `y`) are equal.

If `x` and `y` are pairs such that `x.1 = y.1` and `x.2 = y.2`, then `x = y`.


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

This theorem states that for any type `E` which forms a seminormed add group, the norm of any element `a` of `E` is always non-negative. In mathematical terms, this means that for every element `a` in a seminormed add group `E`, the inequality 0 ≤ ‖a‖ always holds.

In a seminormed add group, the norm of any element is non-negative.


theorem zero_le : ∀ {α : Type u} [inst : CanonicallyOrderedAddCommMonoid α] (a : α), 0 ≤ a := by sorry

This theorem declares that for every instance `a` of a type `α`, where `α` is a Canonically Ordered Additive Commutative Monoid, the value `0` is less than or equal to `a`. In simpler terms, it is stating that zero is always less than or equal to any element in a given canonically ordered additive commutative monoid. This aligns with our intuitive understanding of numbers where zero is the smallest number in the set of non-negative numbers.

For every element `a` in a canonically ordered, additive commutative monoid `α`, we have `0 ≤ a`.


Exists.imp

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

This theorem, `Exists.imp`, states that for any sort `α` and any two properties `p` and `q` of `α`, if for every element `a` of `α`, `p a` implies `q a`, then if there exists an element `a` such that `p a` is true, there must also exist an element `a` such that `q a` is true. In simpler terms, if every element that satisfies property `p` also satisfies property `q`, then any existence of an element satisfying `p` guarantees the existence of an element satisfying `q`.

If for all `a` in `α`, `p(a)` implies `q(a)`, then the existence of an `a` such that `p(a)` holds implies the existence of an `a` such that `q(a)` holds.


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

This theorem, called `mul_add`, is an alias of `left_distrib`. It states that for any type `R` that has multiplication and addition operations, and for which the left distribution law holds, the product of `a` with the sum of `b` and `c` (`a * (b + c)`) is equal to the sum of the product of `a` and `b` and the product of `a` and `c` (`a * b + a * c`). This corresponds to the left distributive property in algebra, often given as $a \cdot (b + c) = a \cdot b + a \cdot c$.

For any type `R` with multiplication and addition operations satisfying the left distribution law, `a * (b + c)` equals `a * b + a * c`.


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

This theorem, `LT.lt.not_le`, states that for any type `α` with a `Preorder` instance and any two elements `a` and `b` of that type, if `a` is strictly less than `b` (`a < b`), then it is not the case that `b` is less than or equal to `a` (`¬b ≤ a`). This is a fundamental property in order theory which holds for all preordered sets, and serves as an alias of the `not_le_of_lt` theorem.

For any preordered type `α` and elements `a` and `b` of type `α`, if `a` is strictly less than `b`, then `b` is not less than or equal to `a`.


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

The theorem `CategoryTheory.cancel_mono` states that for any category `C` and any objects `X`, `Y`, and `Z` within `C`, if `f` is a monomorphism from `X` to `Y`, then for any morphisms `g` and `h` from `Z` to `X`, the composition of `g` with `f` is equal to the composition of `h` with `f` if and only if `g` is equal to `h`. In simpler terms, this theorem expresses the property of monomorphisms (or "mono") in category theory, which are morphisms that can be cancelled on the right.

Given any category C and morphisms f: X → Y, g, h: Z → X in C, if f is a monomorphism and g = h, then g ∘ f = h ∘ f.


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

This theorem, named `_auxLemma.4` in the `Mathlib.Algebra.NeZero` module, states that for any type `α` where `α` has the properties of zero and one and `1` is not equal to `0`, it is always false that `1` equals `0`. In other words, in any algebraic system where `1` and `0` are distinct, `1` cannot be equal to `0`.

In any algebraic system where `1` and `0` are distinct objects, `1` is not equal to `0`.


theorem Set.mem_image_of_mem : ∀ {α : Type u} {β : Type v} (f : α → β) {x : α} {a : Set α}, x ∈ a → f x ∈ f '' a := by
  sorry

The theorem `Set.mem_image_of_mem` states that for any types `α` and `β`, and any function `f` from `α` to `β`, if an element `x` of type `α` belongs to a set `a` of `α`, then the image of `x` under `f` belongs to the image of set `a` under `f`. In other words, if a certain `x` is an element of a set `a`, then `f(x)` is an element of the set formed by applying function `f` to each element in `a`.

For any function `f` and sets `a` and `X`, if `x ∈ a` and `x ∈ X`, then `f(x) ∈ f(a)`.


theorem Mathlib.Logic.IsEmpty._auxLemma.1 :
    ∀ {α : Sort u_1} [inst : IsEmpty α] {p : α → Prop}, (∀ (a : α), p a) = True := by sorry

This theorem states that for any sort `α` which is empty (i.e., there are no elements of type `α`), and for any property `p` that elements of `α` might have, the statement "for all `a` in `α`, `p(a)` holds" is always true. This is a manifestation of the principle of vacuous truth in logic: statements about all elements of an empty set are trivially true because there are no elements to contradict them.

If `α` is an empty sort, then the proposition `∀a:α, p(a)` is true for any property `p`.


Subtype.eq

theorem Subtype.eq : ∀ {α : Type u} {p : α → Prop} {a1 a2 : { x // p x }}, ↑a1 = ↑a2 → a1 = a2 := by sorry

This theorem, named `Subtype.eq`, states that for any type `α` and any predicate `p` applying to `α`, given two subtypes `a1` and `a2` (i.e., elements of type `α` that satisfy predicate `p`), if the underlying elements of `a1` and `a2` (obtained by applying the coercion function `↑` to `a1` and `a2`) are equal, then `a1` and `a2` themselves are equal. Essentially, it says that if two subtypes have the same underlying value, they are the same subtype.

If two subtypes of a type with a given predicate have equal underlying elements, then they are equal as subtypes.


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

This theorem, `Or.resolve_left`, states that for any two propositions `a` and `b`, if the disjunction of `a` and `b` (`a ∨ b`) is true and the negation of `a` (`¬a`) is also true, then `b` must be true. In other words, if `a` or `b` is true and we know that `a` is not true, then `b` has to be true. This is a fundamental rule in logic, often used in logical reasoning and proofs.

If `a ∨ b` is true and `¬a` is true, then `b` is true.


/-- `zero_le_one` with the type argument implicit.  -/
theorem zero_le_one :
    ∀ {α : Type u_1} [inst : Zero α] [inst_1 : One α] [inst_2 : LE α] [inst_3 : ZeroLEOneClass α], 0 ≤ 1 := by sorry

The theorem `zero_le_one` asserts that for any type `α` which has definitions for zero and one and an order relation (`LE`), and for which zero is less than or equal to one (`ZeroLEOneClass`), the value zero is always less than or equal to the value one.

For any type with zero, one, and a total order where zero is less than or equal to one, zero is less than or equal to one.


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

The theorem `le_total` states that for any type `α` that has a linear order, for any two elements `a` and `b` of type `α`, either `a` is less than or equal to `b` or `b` is less than or equal to `a`. This property signifies total order, where any two elements are comparable.

For any type `α` with a linear order, for all `a, b` in `α`, either `a ≤ b` or `b ≤ a`.


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

This theorem, `neg_mul`, states that for all types `α` equipped with a multiplication operation (`Mul α`) and a distributive negation operation (`HasDistribNeg α`), the product of the negation of `a` and `b` is equal to the negation of the product of `a` and `b`. In mathematical terms, this can be expressed as `-a * b = -(a * b)`. This essentially captures the property of the number system where multiplying a negative number with a positive number yields the same result as negating the product of the positive counterparts.

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


em

/-- **Alias** of `Classical.em`.

---

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

This theorem, also known as Diaconescu's theorem, states that for any proposition 'p', either 'p' is true or 'p' is not true. This is an instance of the principle of the excluded middle, derived from the axiom of choice, function extensionality, and propositional extensionality. In mathematical notation, for any proposition `p`, the result is `p ∨ ¬p`, meaning 'p' or not 'p'.

For any proposition `p`, the negation of `p` exists and is equivalent to `p`'s negation, thus `p ∨ ¬p` holds. (This statement represents the principle of excluded middle derived from given axioms in Lean 4.)