theorem Finset.coe_insert :
    ∀ {α : Type u_1} [inst : DecidableEq α] (a : α) (s : Finset α), ↑(insert a s) = insert a ↑s := by sorry

This theorem, `Finset.coe_insert`, states that for any type `α` with decidable equality and for any element `a` of type `α` and set `s` of type `Finset α`, the coercion (or type conversion) of the set obtained by inserting `a` into `s` is equal to the set obtained by inserting `a` into the coerced `s`. In other words, adding an element to a finite set and then converting the type is the same as converting the type of the set and then adding the element.

For any type `α` with decidable equality, the coerced result of inserting an element `a` into a finite set `s` is equal to the result of inserting `a` into the coerced set `s`.


IsOpen.measurableSet

theorem IsOpen.measurableSet :
    ∀ {α : Type u_1} {s : Set α} [inst : TopologicalSpace α] [inst_1 : MeasurableSpace α]
      [inst_2 : OpensMeasurableSpace α], IsOpen s → MeasurableSet s :=
  by sorry

This theorem states that for any set `s` of a certain type `α`, given that `α` is equipped with a topological space structure, a measurable space structure, and the condition that every open set in the topological space is measurable (`OpensMeasurableSpace α`), if `s` is an open set in the topological space, then `s` is also a measurable set in the measurable space. In other words, open sets in the topological space are also measurable sets in the measurable space when the space has the property that all open sets are measurable.

If `α` is a topological space where every open set is measurable, then every open set in `α` is a measurable set.


theorem Multiset.mem_map :
    ∀ {α : Type u_1} {β : Type v} {f : α → β} {b : β} {s : Multiset α}, b ∈ Multiset.map f s ↔ ∃ a ∈ s, f a = b := by
  sorry

The theorem `Multiset.mem_map` states that for any types `α` and `β`, a function `f` from `α` to `β`, an element `b` of type `β`, and a multiset `s` of type `α`, `b` is an element of the multiset obtained by mapping `f` over `s` if and only if there exists an element `a` in multiset `s` such that `f(a) = b`. In other words, an element is in the image of a multiset under a function if and only if it is the image of some element in the original multiset under that function.

For any function $f:\alpha \to \beta$ and multiset $s:\mathit{Multiset}\ \alpha$, $b \in \mathit{map}\ f\ s$ if and only if there exists $a \in s$ such that $f(a) = b$.


Contravariant.AddLECancellable

theorem Contravariant.AddLECancellable :
    ∀ {α : Type u_1} [inst : Add α] [inst_1 : LE α]
      [inst_2 : ContravariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] {a : α}, AddLECancellable a :=
  by sorry

The theorem `Contravariant.AddLECancellable` states that for any type `α` equipped with addition and an order relation, if the type is a contravariant class, i.e., for all `x`, `y`, `z` in `α`, if `x + z ≤ y + z` implies `x ≤ y`, then every element `a` of the type `α` is 'AddLECancellable'. By 'AddLECancellable', it means that for any two elements `b` and `c` from the type `α`, if `a + b ≤ a + c` then `b ≤ c`. This is essentially saying that adding `a` to both sides of an inequality won't change the ordering of `b` and `c`.

If `α` is a type equipped with addition and an order relation such that `α` is contravariant, then every element `a` in `α` satisfies `x ≤ y` whenever `a + x ≤ a + y`.


/-- Prove `Set.Countable` from a `Countable` instance on the subtype.  -/
theorem Set.to_countable : ∀ {α : Type u} (s : Set α) [inst : Countable ↑s], Set.Countable s := by sorry

The theorem `Set.to_countable` states that for any type `α` and any set `s` of this type, if the subtype corresponding to this set has an instance of being `Countable` (that is, there exists an injective map from the subtype to the natural numbers), then the set `s` itself is `Countable`. In other words, if we can count the elements of the subtype associated with a set, then we can count the elements of the set itself.

If a subtype of a type has a countable instance, then the type itself is countable.


OpenEmbedding.isOpenMap

theorem OpenEmbedding.isOpenMap :
    ∀ {X : Type u_1} {Y : Type u_2} {f : X → Y} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y],
      OpenEmbedding f → IsOpenMap f :=
  by sorry

The theorem `OpenEmbedding.isOpenMap` states that for any given types `X` and `Y` and a function `f` from `X` to `Y`, if both `X` and `Y` have a `TopologicalSpace` instance, then if `f` is an open embedding, `f` is also an open map. In other words, if `f` is an open embedding, which means it is a function that is both injective and continuous, and the image of any open set in `X` is open in `Y`, then the image of any open set under `f` is still open in `Y`.

If `f` is an open embedding from a topological space `X` to a topological space `Y`, then the image of every open set in `X` under `f` is an open set in `Y`.


theorem Function.funext_iff :
    ∀ {α : Sort u_1} {β : α → Sort u_4} {f₁ f₂ : (x : α) → β x}, f₁ = f₂ ↔ ∀ (a : α), f₁ a = f₂ a := by sorry

This theorem, referred to as `Function.funext_iff`, states that for any two functions `f₁` and `f₂` that map elements from a certain type `α` to another dependent type `β`, these functions are considered equal if and only if they produce the same result for every element in `α`. This theorem is a formalization of the principle of function extensionality in the Lean theorem prover. This principle is fundamental in mathematics, expressing the idea that two functions are the same if they give the same output for every input.

Two functions from type `α` to a dependent type `β` are equal if and only if they agree on all elements of `α`.


HasDerivAt.differentiableAt

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

This theorem states that for every function `f` from a field `𝕜` to a normed add commutative group `F`, if the derivative of `f` at a point `x` in `𝕜` exists and is equal to `f'`, then `f` is differentiable at `x`. In mathematical terms, if `f(x') = f(x) + (x' - x) • f' + o(x' - x)` when `x'` converges to `x`, then there exists a derivative for `f` at `x`. This derivative may not be unique.

If a function `f` from a field to a normed add commutative group has an exponentially convergent derivative at a point, then `f` is differentiable at that point. (Note: Lean's statement assumes the derivative is unique, but this is not always the case in general.)


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

The theorem `Submodule.span_le` states that for any semiring `R`, any additively commutative monoid `M`, and any `R`-module structure on `M`, given a set `s` of elements from `M` and a submodule `p` of `M`, the span of the set `s` is a subset of the submodule `p` if and only if the set `s` is a subset of the elements of the submodule `p`. In other words, the smallest submodule of `M` that contains `s` is a subset of `p` precisely when `s` is a subset of `p`.

The smallest R-module subgenerated by a set s in an R-module M is contained in a submodule p if and only if s is contained in p.


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

This theorem states that for any two natural numbers `n` and `m`, if `n` is strictly less than `m` (expressed as `n < m`), then `n` is also less than or equal to `m` (expressed as `n ≤ m`). This is a fundamental property of order relations in mathematics.

If `n` is less than `m`, then `n` is also less than or equal to `m` (`n < m` implies `n ≤ m`).


theorem Part.bind_some : ∀ {α : Type u_1} {β : Type u_2} (a : α) (f : α → Part β), Part.bind (Part.some a) f = f a := by
  sorry

The theorem `Part.bind_some` states that for any two types `α` and `β`, an element `a` of type `α`, and a function `f` from `α` to `Part β`, binding the function `f` to the `Part.some a` (which is a `Part` type object with a `True` domain and a function returning `a`) is equivalent to applying the function `f` to `a`. In other words, when we bind `Part.some a` with any function `f`, it behaves just like applying `f` directly to `a`. This theorem is about the behavior of the `bind` operation in the `Part` monad.

For any types α and β, function f from α to Part β, and element a of α, the application of f to Part.some a is equivalent to binding Part.some a with f.


theorem Finset.eq_of_veq : ∀ {α : Type u_1} {s t : Finset α}, s.val = t.val → s = t := by sorry

This theorem states that for any two finite sets `s` and `t` of an arbitrary type `α`, if the underlying value sequences of `s` and `t` are equal, then `s` and `t` must also be equal. The type `α` is not necessarily a number type, but can be any type. This theorem provides a method of equality comparison between two finite sets based on their value sequences.

If two finite sets `s` and `t` over an arbitrary type `α` have equal value sequences, then `s` and `t` are equal.


theorem Finset.coe_empty : ∀ {α : Type u_1}, ↑∅ = ∅ := by sorry

This theorem states that for any type 'α', the coercion of an empty `Finset` (finite set) to a set in Lean 4 is an empty set. In other words, when we transform an empty finite set into a regular set, we still get an empty set.

For any type 'α', the coercion of an empty Finset to a set in Lean 4 is the empty set.


StrictMono.injective

theorem StrictMono.injective :
    ∀ {α : Type u} {β : Type v} [inst : LinearOrder α] [inst_1 : Preorder β] {f : α → β},
      StrictMono f → Function.Injective f :=
  by sorry

The theorem `StrictMono.injective` states that for all types `α` and `β`, where `α` has a linear order structure and `β` has a preorder structure, any function `f` from `α` to `β` that is strictly monotone is also injective. In other words, if a function `f` strictly increases or decreases (as dictated by strict monotonicity) for all elements in `α`, then it will never map distinct elements in `α` to the same element in `β`, which is the definition of injectivity.

A strictly monotone function between linearly ordered and preordered types is injective.


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

This theorem, `div_nonneg`, asserts that for any type `α` that has a structure of `LinearOrderedSemifield`, if `a` and `b` are two elements of `α` such that both `a` and `b` are nonnegative (i.e., greater than or equal to zero), then the division of `a` by `b` is also nonnegative. That is, in the context of a linearly ordered semifield, if you divide a nonnegative number by another nonnegative number, the result will be nonnegative.

In a linearly ordered semifield, if both dividend and divisor are nonnegative, then the quotient is nonnegative.


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

This theorem, named `add_right_comm`, states that for any type `G` that is an additive commutative semigroup, for any three elements `a`, `b`, and `c` of type `G`, the sum of `a`, `b`, and `c` remains the same even if the order of `b` and `c` is switched in the right-hand side of the sum. In mathematical notation, this is saying that for all `a`, `b`, and `c` in the semigroup `G`, `a + b + c = a + c + b`.

For any additive commutative semigroup `G` and elements `a`, `b`, `c` in `G`, `a + b + c = a + c + b`.


theorem Set.preimage_image_eq :
    ∀ {α : Type u_1} {β : Type u_2} {f : α → β} (s : Set α), Function.Injective f → f ⁻¹' (f '' s) = s := by sorry

The theorem `Set.preimage_image_eq` asserts that for any set `s` of type `α` and an injective function `f` from `α` to another type `β`, the preimage of the image of `s` under `f` equals to the set `s` itself. In other words, if you apply `f` to each element of `s`, and then find all the elements in the domain that map to these image elements under `f`, you get back the original set `s`. Note that this is true only because `f` is injective, meaning that each element in the domain `α` maps to a unique element in the codomain `β`. In terms of sets, this can be written as $f^{-1}(f(s)) = s$ for injective `f`.

For an injective function $f$ from a set $S$ to another set, the preimage of the image of $S$ under $f$ equals $S$. In symbols, $f^{-1}(f(S)) = S$.


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

The theorem `Antitone.dual_right` states that for any types `α` and `β` with preorders, and any function `f` from `α` to `β`, if `f` is antitone (i.e., if `a ≤ b` then `f b ≤ f a`), then the composition of `f` with the `toDual` function from the `OrderDual` of `α` is monotone (i.e., if `a ≤ b` then `f a ≤ f b`). In other words, reversing the direction of an antitone function results in a monotone function.

If `f : α → β` is an antitone function between pre ordered types `α` and `β`, then the composition `f ∘ toDual : OrderDual α → OrderDual β` is a monotone function.


Set.Nonempty.mono

theorem Set.Nonempty.mono : ∀ {α : Type u} {s t : Set α}, s ⊆ t → Set.Nonempty s → Set.Nonempty t := by sorry

The theorem `Set.Nonempty.mono` states that for any type `α` and any two sets `s` and `t` of this type, if `s` is a subset of `t`, then the non-emptiness of `s` implies the non-emptiness of `t`. In other words, if a set `s` has at least one element and all elements of `s` are also in `t`, then `t` must also have at least one element.

If `s` is a subset of `t` and `s` is non-empty, then `t` is non-empty.


Set.OrdConnected.out

theorem Set.OrdConnected.out :
    ∀ {α : Type u_1} [inst : Preorder α] {s : Set α},
      Set.OrdConnected s → ∀ ⦃x : α⦄, x ∈ s → ∀ ⦃y : α⦄, y ∈ s → Set.Icc x y ⊆ s :=
  by sorry

This theorem states that for any type `α` with a preorder relation, if a set `s` of type `α` is ordered-connected, then for any elements `x` and `y` in the set `s`, the closed interval from `x` to `y` (both `x` and `y` included) is a subset of `s`. In other words, if a set is ordered-connected, then every element between two elements of the set (inclusive) also belongs to the set.

In a preordered type `α`, if `s` is an ordered-connected subset, then for all `x, y ∈ s`, the interval `[x, y] ⊆ s`.


Disjoint.mono

theorem Disjoint.mono :
    ∀ {α : Type u_1} [inst : PartialOrder α] [inst_1 : OrderBot α] {a b c d : α},
      a ≤ b → c ≤ d → Disjoint b d → Disjoint a c :=
  by sorry

The theorem `Disjoint.mono` states that for any type `α` that is a partial order and has a bottom element (`OrderBot α`), given four elements `a`, `b`, `c`, `d` of `α`, if `a` is less than or equal to `b` and `c` is less than or equal to `d`, and if `b` and `d` are disjoint (i.e., their greatest lower bound is the bottom element of the order), then `a` and `c` are also disjoint. This is a monotonicity property of the notion of disjointness in lattices.

If `α` is a partial order with bottom element, `a` and `b`, and `c` and `d` in `α` are such that `a ≤ b`, `c ≤ d`, and `b` and `d` are disjoint, then `a` and `c` are disjoint.


theorem Cardinal.mk_congr : ∀ {α β : Type u}, α ≃ β → Cardinal.mk α = Cardinal.mk β := by sorry

This theorem, named `Cardinal.mk_congr`, states that for any two types `α` and `β` in the same universe `u`, if there exists a bijective mapping (an equivalence) between `α` and `β`, then the cardinality of `α` is equal to the cardinality of `β`. In mathematical terms, given any two sets `α` and `β` such that there exists a bijection between them, their cardinal numbers are equal.

If there exists a bijection between sets `α` and `β`, then `α` and `β` have equal cardinality.


Commute.refl

/-- Any element commutes with itself.  -/
theorem Commute.refl : ∀ {S : Type u_2} [inst : Mul S] (a : S), Commute a a := by sorry

This theorem states that for any type `S` that has a multiplication operation, any element `a` in `S` commutes with itself. In other words, for any `a` in `S`, the multiplication of `a` with itself results in the same output as the multiplication of itself with `a`. In mathematical terms, it is expressing that `a * a = a * a` for all `a` in `S`.

For all types `S` with a multiplication operation and for all elements `a` in `S`, `a * a` equals `a * a`. In mathematical notation, `∀ (S : Type) [Mul S], ∀ (a : S), a * a = a * a`.


theorem SetLike.ext_iff :
    ∀ {A : Type u_1} {B : Type u_2} [i : SetLike A B] {p q : A}, p = q ↔ ∀ (x : B), x ∈ p ↔ x ∈ q := by sorry

This theorem states that for any types `A` and `B`, given a `SetLike` instance `i` between `A` and `B`, and any two elements `p` and `q` of type `A`, `p` is equal to `q` if and only if for every element `x` of type `B`, `x` is an element of `p` if and only if `x` is an element of `q`. In other words, two sets are equal if and only if they contain exactly the same elements.

Two sets `A` and `B` are equal if and only if for all elements `x`, `x` is in `A` if and only if `x` is in `B`.


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

The theorem `MeasureTheory.AEStronglyMeasurable.ae_eq_mk` states that for any function `f` from `α` to `β` that is almost everywhere strongly measurable with respect to a measure `μ`, `f` is almost everywhere equal to its associated `MeasureTheory.AEStronglyMeasurable.mk f hf`. Here, `α` is a type with a `MeasurableSpace` structure, `β` is a type with a `TopologicalSpace` structure, and `μ` is a measure on `α`. The "almost everywhere" condition means that the set of points in `α` where `f` and `MeasureTheory.AEStronglyMeasurable.mk f hf` differ is a null set with respect to the measure `μ`. In other words, `f` and `MeasureTheory.AEStronglyMeasurable.mk f hf` are identical except possibly on a set of measure zero.

A strongly almost everywhere measurable function from a measurable space to a topological space is almost everywhere equal to its associated measurable function constructed from its measurability hypothesis.


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

This theorem, named `bot_unique`, states that for any type `α` that has a partial order and a least element (`⊥`), if any element `a` of type `α` is less than or equal to `⊥`, then `a` must be equal to `⊥`. In other words, `⊥` is the unique minimal element in the partially ordered set.

In a partially ordered type with a least element, any element less than or equal to the least element is equal to it.


ContinuousAt.continuousWithinAt

theorem ContinuousAt.continuousWithinAt :
    ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] {f : α → β} {s : Set α}
      {x : α}, ContinuousAt f x → ContinuousWithinAt f s x :=
  by sorry

This theorem states that for any given types `α` and `β`, two topological spaces `α` and `β`, a function `f` from `α` to `β`, a set `s` of `α` and a point `x` of `α`, if the function `f` is continuous at the point `x`, then the function `f` is also continuous at the point `x` within the set `s`. In other words, if the function values approach `f(x)` as the function argument approaches `x` in the whole space, they also approach `f(x)` as the argument approaches `x` while remaining within the subset `s` of the space.

If `f` is a continuous function from topological spaces `α` to `β` and `x` is a point in `α` where `f` is continuous, then `f` is continuous at `x` within any subset `s` of `α`.


theorem MeasureTheory.memℒp_one_iff_integrable :
    ∀ {α : Type u_1} {β : Type u_2} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} [inst : NormedAddCommGroup β]
      {f : α → β}, MeasureTheory.Memℒp f 1 μ ↔ MeasureTheory.Integrable f μ :=
  by sorry

The theorem `MeasureTheory.memℒp_one_iff_integrable` states that for any measurable space `α`, any normed add commutative group `β`, any measure `μ` on `α`, and any function `f` from `α` to `β`, the function `f` belongs to the space `ℒp` for `p = 1` with respect to the measure `μ` if and only if `f` is integrable with respect to `μ`. In mathematical terms, this is saying that $\langle f, 1, \mu \rangle \in \mathcal{L}^{p}$ if and only if $f$ is $\mu$-integrable. This links the concept of being in the `ℒp` space for `p = 1` with the concept of integrability.

A measurable function from a measurable space to a normed add commutative group is integrable with respect to a measure if and only if it belongs to the Lebesgue space with p=1 with respect to that measure.


Ne.isUnit

/-- **Alias** of the reverse direction of `isUnit_iff_ne_zero`. -/
theorem Ne.isUnit : ∀ {G₀ : Type u_3} [inst : GroupWithZero G₀] {a : G₀}, a ≠ 0 → IsUnit a := by sorry

This theorem, referred to as `Ne.isUnit`, states that for any type `G₀` that is equipped with a `GroupWithZero` structure, if an element `a` of `G₀` is not equal to zero, then `a` is a unit. In terms of algebra, this means that for any element in a group with a distinguished zero element, if the element is not the zero element, then it has a multiplicative inverse, or in other words, it is "invertible" or a "unit".

In a group with zero, if an element is non-zero, then it is a unit (has a multiplicative inverse).


Commute.symm

/-- If `a` commutes with `b`, then `b` commutes with `a`.  -/
theorem Commute.symm : ∀ {S : Type u_2} [inst : Mul S] {a b : S}, Commute a b → Commute b a := by sorry

The theorem `Commute.symm` states that for any type `S` that has a multiplication operation, if two elements `a` and `b` of `S` commute with each other (that is, `a * b = b * a`), then `b` and `a` also commute with each other (i.e., `b * a = a * b`). This theorem expresses the symmetry of the commutation relation in a multiplicative structure.

If `a` and `b` in a multiplicative type `S` commute (i.e., `a * b = b * a`), then they symmetically commute (`b * a = a * b`).


SMulCommClass.symm

/-- Commutativity of actions is a symmetric relation. This lemma can't be an instance because this
would cause a loop in the instance search graph.  -/
theorem SMulCommClass.symm :
    ∀ (M : Type u_10) (N : Type u_11) (α : Type u_12) [inst : SMul M α] [inst_1 : SMul N α]
      [inst_2 : SMulCommClass M N α], SMulCommClass N M α :=
  by sorry

This theorem states that the commutativity of actions, defined by the `SMulCommClass`, is a symmetric relation. This means that for any types `M`, `N`, and `α` where `M` and `N` are both types of actions on `α` and there exists a `SMulCommClass` instance for `M`, `N` and `α`, there will also exist a `SMulCommClass` instance for `N`, `M` and `α`. Note that this theorem cannot be an instance, as it would cause a loop in the instance search graph.

For any types `M`, `N`, and `α` where `M` and `N` are actions on `α`, the `SMulCommClass` relation between `M` and `N` implies the `SMulCommClass` relation between `N` and `M`.


LinearEquiv.ext

theorem LinearEquiv.ext :
    ∀ {R : Type u_1} {S : Type u_6} {M : Type u_7} {M₂ : Type u_9} [inst : Semiring R] [inst_1 : Semiring S]
      [inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid M₂] {module_M : Module R M} {module_S_M₂ : Module S M₂}
      {σ : R →+* S} {σ' : S →+* R} {re₁ : RingHomInvPair σ σ'} {re₂ : RingHomInvPair σ' σ} {e e' : M ≃ₛₗ[σ] M₂},
      (∀ (x : M), e x = e' x) → e = e' :=
  by sorry

This theorem, `LinearEquiv.ext`, states that for any two semirings `R` and `S`, two additive commutative monoids `M` and `M₂`, given `M` is a module over `R` and `M₂` is a module over `S`, two ring homomorphisms `σ` and `σ'` that form a pair of inverse ring homomorphisms `re₁` and `re₂`, and any two linear equivalences `e` and `e'` from `M` to `M₂` over the ring homomorphism `σ`, if for every element `x` in `M`, `e` of `x` equals `e'` of `x`, then `e` is identical to `e'`. In other words, two linear equivalences are considered the same if they map every element of `M` to the same element in `M₂` under the given ring homomorphism.

Given two additive commutative semigroups `M` and `M₂`, two semigroup homomorphisms `σ: R → S` and `σ': S → R` forming a ring isomorphism, and two linear equivalences `e: M ≅ M₂` and `e': M ≅ M₂` over `σ`, if `e(x) = e'(x)` for all `x` in `M`, then `e = e'`.


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

This theorem states that for any type `G` that is a group, for any element `a` of `G`, the product of the inverse of `a` and `a` itself equals the identity element of the group. This is a fundamental property of groups, expressing that multiplying any element by its inverse results in the group's identity element.

For any group `G` and element `a` in `G`, `a`'s inverse multiplied by `a` equals the identity element of `G`. In Lean notation: `∀ (G : Type) [group G], ∃ (ha : is_group G), ∀ (a : G), inv a * a = id G`.


theorem Cardinal.nat_lt_aleph0 : ∀ (n : ℕ), ↑n < Cardinal.aleph0 := by sorry

The theorem `Cardinal.nat_lt_aleph0` states that for every natural number `n`, the cardinality of `n` is less than `ℵ₀` (aleph null), which is the smallest infinite cardinal. In other words, the size of any finite set of natural numbers is always smaller than the size of the set of all natural numbers.

The theorem `Cardinal.nat_lt_aleph0` asserts that for all natural numbers `n`, the cardinality of `Finset.nat n` is strictly less than the cardinality of `Nat`.


theorem Set.range_nonempty : ∀ {α : Type u_1} {ι : Sort u_4} [h : Nonempty ι] (f : ι → α), Set.Nonempty (Set.range f) :=
  by sorry

The theorem `Set.range_nonempty` states that for all types `α` and any sort `ι`, given that `ι` is nonempty (i.e., there exists at least one element of type `ι`), for any function `f` from `ι` to `α`, the range of the function `f` is a nonempty set. In other words, there exists at least one element in the set that is an image of some element of `ι` under the function `f`.

For any nonempty type `ι` and function `f` from `ι` to a type `α`, the range of `f` is a nonempty set.


CategoryTheory.Limits.kernel.condition

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

The theorem `CategoryTheory.Limits.kernel.condition` states that for any category `C` with zero morphisms, given any morphisms `f` from object `X` to object `Y` in `C` which has a kernel, the composition of the morphism from the kernel of `f` to `X` with `f` is a zero morphism. In mathematical terms, if `f : X -> Y` is a morphism in a category with zero morphisms and it has a kernel, then the following equation is satisfied: `(kernel.ι f) ∘ f = 0`, where `kernel.ι f` is the morphism from the kernel of `f` to `X`, and `0` represents the zero morphism.

If `f : X -> Y` is a morphism in a category with zero morphisms and has a kernel, then the composition of the kernel's inclusion morphism `kernel.ι f` with `f` is the zero morphism.


List.cons.injEq

theorem List.cons.injEq :
    ∀ {α : Type u} (head : α) (tail : List α) (head_1 : α) (tail_1 : List α),
      (head :: tail = head_1 :: tail_1) = (head = head_1 ∧ tail = tail_1) :=
  by sorry

This theorem, `List.cons.injEq`, states that for any type `α`, given two heads `head` and `head_1` of this type, and two lists `tail` and `tail_1` of this type, the equality of the lists formed by prepending these heads to these tails (i.e., `head :: tail` and `head_1 :: tail_1`) is equivalent to the conjunction of the equality of the heads and the equality of the tails. In other words, two lists are equal if and only if their heads are equal and their tails are equal.

For any type `α`, the list `cons x xs` equals the list `cons y ys` if and only if `x = y` and `xs = ys`.


theorem zpow_one : ∀ {G : Type w} [inst : DivInvMonoid G] (a : G), a ^ 1 = a := by sorry

This theorem, `zpow_one`, states that for any type `G` that has an instance of the `DivInvMonoid` typeclass, the first power of any element `a` of `G` is equal to `a` itself. In mathematical terms, this corresponds to the common rule a^1 = a for any a in some division-inverse monoid.

For any type `G` with `DivInvMonoid` instance, the power operation raises any element `a` in `G` to the first power, yielding `a` itself. (In mathematical notation: ∀ (G : Type) [DivInvMonoid G], ∀ (a : G), a ^ 1 = a)


theorem Order.lt_succ :
    ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : SuccOrder α] [inst_2 : NoMaxOrder α] (a : α), a < Order.succ a := by
  sorry

This theorem, `Order.lt_succ`, states that for any type `α` equipped with a preorder and a successor relation, and assuming that `α` does not have a maximal element, any element `a` of type `α` is strictly less than its successor. In other words, for any given element `a`, the successor of `a`, denoted as `Order.succ a`, is always greater than `a`.

For any type `α` with a preorder and successor relation having no maximal element, every element `a` satisfies `a < Order.succ a`.


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

This theorem states that for any two natural numbers `a` and `b`, if `b` is less than `a`, then `a` is not equal to `b`. In other words, if one natural number is strictly greater than another, they cannot be the same number.

For all natural numbers `a` and `b`, if `b` < `a`, then `a` ≠ `b`.


theorem Polynomial.coeff_map :
    ∀ {R : Type u} {S : Type v} [inst : Semiring R] {p : Polynomial R} [inst_1 : Semiring S] (f : R →+* S) (n : ℕ),
      Polynomial.coeff (Polynomial.map f p) n = f (Polynomial.coeff p n) :=
  by sorry

The theorem `Polynomial.coeff_map` states that for any semirings `R` and `S`, any polynomial `p` of type `Polynomial R`, any ring homomorphism `f` from `R` to `S`, and any natural number `n`, the coefficient of `X^n` in the polynomial obtained by mapping `p` across `f` is equal to the result of applying `f` to the coefficient of `X^n` in `p`. In other words, if you map a polynomial to another ring using a ring hom, the coefficients of the resulting polynomial are just the images under the hom of the coefficients of the original polynomial.

For any semirings R and S, ring homomorphism f from R to S, polynomial p of type Polynomial R over X, and natural number n, the coefficient of X^n in the polynomial f(p) obtained by mapping p across f is equal to f(coeff p X^n).


theorem Mathlib.Algebra.CharZero.Defs._auxLemma.3 :
    ∀ {R : Type u_1} [inst : AddMonoidWithOne R] [inst_1 : CharZero R] {n : ℕ}, (↑n = 0) = (n = 0) := by sorry

This theorem, `Mathlib.Algebra.CharZero.Defs._auxLemma.3`, states that for any given type `R`, if `R` is an additive monoid with an identity element (one) and `R` is characteristic zero, then for any natural number `n`, the statement that the characteristic of `n` being equal to zero is equivalent to `n` itself being zero. In other words, in such a type `R`, a natural number `n` has a characteristic of zero if and only if `n` equals zero. The characteristic of an element in a ring is the smallest positive integer such that the element times this integer equals zero, or it's zero if no such integer exists.

In an additive monoid with identity and characteristic zero, the characteristic of a natural number equals zero if and only if the number is zero.


theorem Set.mem_range : ∀ {α : Type u} {ι : Sort u_1} {f : ι → α} {x : α}, x ∈ Set.range f ↔ ∃ y, f y = x := by sorry

The theorem `Set.mem_range` says that for any type `α` and any sort `ι`, and for any function `f` from `ι` to `α`, and any element `x` of `α`, `x` is in the range of function `f` if and only if there exists an element `y` such that `f(y)` equals `x`. In other words, an element `x` is in the range of a function `f` precisely when `x` is the image of some element under the function `f`.

For any function between types, an element is in the range if and only if it is the image of some element under the function.


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

This theorem states that for any type `α` with a preorder structure (a set equipped with a reflexive and transitive binary relation), and for any two elements `a` and `b` of type `α`, if `a` is equal to `b` then `a` is greater than or equal to `b`. This is an intuitive result given the reflexivity of preorders, which states that every element should be at least 'as big as' itself.

In a preorder, if `a` is related (equivalent) to `b`, then `a` is greater than or equal to `b`.


Filter.ext

theorem Filter.ext : ∀ {α : Type u} {f g : Filter α}, (∀ (s : Set α), s ∈ f ↔ s ∈ g) → f = g := by sorry

This theorem, known as `Filter.ext`, states that for any type `α` and any two filters `f` and `g` on `α`, if every set `s` of elements of type `α` is a member of the filter `f` if and only if `s` is a member of the filter `g`, then `f` and `g` are equal. In other words, two filters are considered equal if they contain the same sets.

Two filters on a type `α` are equal if and only if they contain the same sets.


theorem Finsupp.mem_support_iff :
    ∀ {α : Type u_1} {M : Type u_5} [inst : Zero M] {f : α →₀ M} {a : α}, a ∈ f.support ↔ f a ≠ 0 := by sorry

This theorem states that for any types `α` and `M` with `M` being a structure with a zero element, and for any function `f` from `α` to `M` and any element `a` of `α`, `a` is in the support of `f` if and only if the result of applying `f` to `a` is not zero. In other words, the support of `f` is the set of all elements `a` from `α` such that when `f` is applied to `a`, the result is nonzero.

The support of a function `f` from type `α` to a structure `M` with zero element is equal to the set of elements `a` in `α` such that `f a ≠ 0`.


CategoryTheory.Limits.image.fac

theorem CategoryTheory.Limits.image.fac :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} (f : X ⟶ Y)
      [inst_1 : CategoryTheory.Limits.HasImage f],
      CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.factorThruImage f) (CategoryTheory.Limits.image.ι f) =
        f :=
  by sorry

The theorem `CategoryTheory.Limits.image.fac` states that for any category `C` with objects `X` and `Y`, and a morphism `f` from `X` to `Y` (denoted `f : X ⟶ Y`) for which an image exists (formally, `[inst_1 : CategoryTheory.Limits.HasImage f]`), the composition of the morphism from `X` to the image of `f` (denoted `CategoryTheory.Limits.factorThruImage f`) followed by the inclusion of the image of `f` into `Y` (denoted `CategoryTheory.Limits.image.ι f`) is equal to the original morphism `f`. In other words, this theorem confirms the fundamental property of the image of a morphism in category theory that compositing the morphism to the image and the inclusion from the image gives back the original morphism.

The theorem asserts that for any morphism `f : X ⟶ Y` in a category `C` with an image, the composition of `f` with the inclusion of the image of `f` is equal to the morphism to the image of `f`.


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

This theorem states that for every natural number `n`, the successor of `n` is always greater than zero. In other words, it's saying that if you add 1 to any natural number, the result will always be greater than zero. This is a basic property of natural numbers in the system of Peano axioms, which is the basis for the standard theory of natural numbers in mathematics.

For every natural number `n`, `n + 1` is positive. (Or, equivalently, `0 < Suc n`, where `Suc` is the successor function.)


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

This theorem, `inv_mul_cancel_left`, states that for any type `G` that forms a Group, for any elements `a` and `b` of that Group, multiplying the inverse of `a` with the result of `a` multiplied by `b` will yield `b`. In mathematical terms, it expresses the property that for any element `a` of a group, its inverse `a⁻¹` cancels out `a` on the left side of a multiplication.

For any group `G` and elements `a, b` in `G`, `a⁻¹ * a * b = b`.


theorem Real.rpow_zero : ∀ (x : ℝ), x ^ 0 = 1 := by sorry

This theorem states that for any real number `x`, it raised to the power of 0 is equal to 1. This is a property of exponentiation in mathematics, where any non-zero number to the power of zero is defined as 1.


theorem Mathlib.Algebra.Order.Monoid.Lemmas._auxLemma.15 :
    ∀ {α : Type u_1} [inst : AddZeroClass α] [inst_1 : LE α]
      [inst_2 : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1]
      [inst_3 : ContravariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] (a : α) {b : α},
      (a ≤ a + b) = (0 ≤ b) :=
  by sorry

This theorem is a lemma in the domain of algebraic order theory about monoids. It states that for all types 'α' that are instances of 'AddZeroClass' and 'LE', and satisfy both the 'CovariantClass' and 'ContravariantClass' for addition and less-than-or-equal-to operators, a given element 'a' of type 'α' is less than or equal to 'a' plus another element 'b' if and only if zero is less than or equal to 'b'. In other words, 'a' is less than or equal to its increment by 'b' exactly when 'b' is non-negative.

For all types 'α' that are AddMonoids with respect to 'LE' and '+' operations, and are covariant and contravariant classes for '+' and "<=", we have a <= a + b if and only if 0 <= b.


theorem norm_pos_iff : ∀ {E : Type u_6} [inst : NormedAddGroup E] {a : E}, 0 < ‖a‖ ↔ a ≠ 0 := by sorry

This theorem states that for any type `E` that is a normed additive group and any element `a` of `E`, the norm of `a` is positive if and only if `a` is not the zero element. In other words, in the context of normed additive groups, a nonzero element always has a positive norm, and an element has a positive norm if and only if it's not the zero element.

In a normed additive group, an element has a positive norm if and only if it is nonzero.


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

This theorem, `Nat.le_trans`, is a statement about the transitivity of the "less than or equal to" relation in the context of natural numbers. It states that for any three natural numbers `n`, `m`, and `k`, if `n` is less than or equal to `m` and `m` is less than or equal to `k`, then `n` is less than or equal to `k`. This is a fundamental property of order relations.

If `n` is less than or equal to `m` and `m` is less than or equal to `k`, then `n` is less than or equal to `k` (`n ≤ m` and `m ≤ k` imply `n ≤ k`).


theorem inf_assoc : ∀ {α : Type u} [inst : SemilatticeInf α] (a b c : α), a ⊓ b ⊓ c = a ⊓ (b ⊓ c) := by sorry

This theorem, `inf_assoc`, states that for any type `α` that is a semilattice under the infimum operation (denoted as `⊓`), the operation is associative. In other words, for any three elements `a`, `b`, and `c` of this type, the infimum of `a` and the infimum of `b` and `c` equals the infimum of `a` and `b` and `c`. This is the same as saying, in the context of set theory, that intersection of three sets (i.e., `a`, `b`, `c`) is associative: `(a ∩ b) ∩ c = a ∩ (b ∩ c)`.

For any semilattice `α` with respect to infimum (⊓), the infimum is associative: `a ⊓ (b ⊓ c) = (a ⊓ b) ⊓ c`.


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

The theorem `add_lt_add_right` states that for any type `α` that supports addition and a `<` operation (strictly less than), and satisfies the `CovariantClass` property (which essentially means that if `x` is less than `y`, then `x + z` is less than `y + z` for all `z`), if `b` is less than `c`, then for all `a`, the result of adding `a` to `b` is less than the result of adding `a` to `c`. In other words, for all real numbers `a`, `b` and `c`, if `b < c`, then `b + a < c + a`.

For types `α` with addition and a covariant `<` relation, if `b < c`, then for all `a`, `b + a < c + a`.


theorem nhdsWithin_univ : ∀ {α : Type u_1} [inst : TopologicalSpace α] (a : α), nhdsWithin a Set.univ = nhds a := by
  sorry

This theorem states that for any type `α` which has a topological space structure and for any element `a` of type `α`, the neighborhood within the universal set `Set.univ` at the point `a` is equivalent to the neighborhood of `a`. In mathematical terms, if we take the intersection of the universal set and a neighborhood of `a`, it is just the neighborhood of `a` itself. This is because the universal set contains all elements of `α`, including all points in any neighborhood of `a`.

For any topological space `(α, τ)` and point `a ∈ α`, the neighborhood filter of `a` is equal to the subset filter of `Set.univ` restricted to the neighborhoods of `a`.


theorem Nat.Prime.ne_one : ∀ {p : ℕ}, Nat.Prime p → p ≠ 1 := by sorry

The theorem `Nat.Prime.ne_one` states that for every natural number `p`, if `p` is a prime number, then `p` cannot be equal to 1. In other words, no prime number can be 1. This is consistent with the definition of a prime number as a natural number at least 2 whose only divisors are itself and 1.

A prime number in Lean 4 cannot be equal to 1.


theorem continuous_add :
    ∀ {M : Type u_3} [inst : TopologicalSpace M] [inst_1 : Add M] [inst_2 : ContinuousAdd M],
      Continuous fun p => p.1 + p.2 :=
  by sorry

This theorem states that for any type `M` which has a defined topological space, an addition operation, and satisfies the property of continuous addition, the addition operation `p.1 + p.2` is continuous. In more mathematical terms, if we consider `M` as a topological space and the addition as a binary operation, then the function that takes a pair of elements (`p.1`, `p.2`) and returns their sum is a continuous function in the topological sense.

Given a type `M` with a topological space structure, an addition operation, and continuous addition, the addition operation is a continuous function.


OrderHom.mono

theorem OrderHom.mono :
    ∀ {α : Type u_2} {β : Type u_3} [inst : Preorder α] [inst_1 : Preorder β] (f : α →o β), Monotone ⇑f := by sorry

This theorem, `OrderHom.mono`, states that for any two types `α` and `β` that are equipped with a preorder structure, any order-preserving function (an `OrderHom`) `f` from `α` to `β` is monotone. In other words, if `a ≤ b` in `α` then `f(a) ≤ f(b)` in `β`, where `a` and `b` are elements of type `α`, and `f` is a function from `α` to `β`.

For any type-preserving function between preordered types, if it respects the preorder relation then it is monotone.


irrefl

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

This theorem, named `irrefl`, declares that for any type `α` and a relation `r` defined on `α`, if `r` is an irreflexive relation (as defined by the `IsIrrefl` typeclass), then for any element `a` of type `α`, `r a a` (i.e., `a` is related to itself by `r`) is not true. In other words, no element of an irreflexive relation is related to itself.

For any type `α` and irreflexive relation `r` on `α`, there is no element `a` in `α` such that `r a a` holds.


theorem MeasureTheory.AEStronglyMeasurable.stronglyMeasurable_mk :
    ∀ {α : Type u_1} {β : Type u_2} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} [inst : TopologicalSpace β]
      {f : α → β} (hf : MeasureTheory.AEStronglyMeasurable f μ),
      MeasureTheory.StronglyMeasurable (MeasureTheory.AEStronglyMeasurable.mk f hf) :=
  by sorry

The theorem `MeasureTheory.AEStronglyMeasurable.stronglyMeasurable_mk` states that for any function `f` from a measure space `α` to a topological space `β`, and for any measure `μ` on `α`, if `f` is almost everywhere strongly measurable with respect to `μ` (meaning that it is almost everywhere equal to the limit of a sequence of simple functions), then the function `MeasureTheory.AEStronglyMeasurable.mk f hf` is strongly measurable. In other words, `MeasureTheory.AEStronglyMeasurable.mk f hf` can also be represented as the limit point of a sequence of simple functions.

If a function from a measure space to a topological space is almost everywhere equal to the limit of a sequence of simple functions with respect to a given measure, then it is strongly measurable.


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

This theorem states that for any three natural numbers `n`, `m`, and `k`, if `n` is less than or equal to `m` and `m` is strictly less than `k`, then `n` is strictly less than `k`. In mathematical terms, it defines a property of the ordering of natural numbers, specifically: if \(n \leq m\) and \(m < k\), then \(n < k\).

If \(n \leq m\) and \(m < k\), then \(n < k\).


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

This theorem states that for any type `α` that forms a canonically ordered additive commutative monoid, and for any elements `a` and `c` of that type, `a` is less than or equal to the sum of `a` and `c`. In other words, in such a monoid, any element is always less than or equal to itself plus another element.

For any additive commutative monoid with a canonical order, every element is less than or equal to the sum of itself and any other element.


theorem Finset.sum_add_distrib :
    ∀ {α : Type u_3} {β : Type u_4} {s : Finset α} {f g : α → β} [inst : AddCommMonoid β],
      (Finset.sum s fun x => f x + g x) = (Finset.sum s fun x => f x) + Finset.sum s fun x => g x :=
  by sorry

The theorem `Finset.sum_add_distrib` states that for any finite set `s` of any type `α`, and any two functions `f` and `g` from `α` to another type `β` where `β` is an additive commutative monoid, the sum over `s` of `f(x) + g(x)` equals the sum of `f(x)` over `s` plus the sum of `g(x)` over `s`. This is the distributive property of summation over a finite set in the context of additive commutative monoids. In terms of mathematical notation, this can be represented as $\sum_{x \in s} (f(x) + g(x)) = \sum_{x \in s} f(x) + \sum_{x \in s} g(x)$.

For any finite set `s` and additive commutative monoid-valued functions `f` and `g` on a type `α`, the sum of `f(x) + g(x)` over `s` equals the sum of `f(x)` over `s` plus the sum of `g(x)` over `s`. (Mathematically: $\sum\_{x \in s} (f(x) + g(x)) = \sum\_{x \in s} f(x) + \sum\_{x \in s} g(x)$)


theorem not_imp_not : ∀ {a b : Prop}, ¬a → ¬b ↔ b → a := by sorry

This theorem states that for any two propositions 'a' and 'b', the statement "not 'a' implies not 'b'" is equivalent to "if 'b' then 'a'". In other words, if the truth of 'b' implies the truth of 'a', then the negation of 'a' must imply the negation of 'b' and vice versa. This is a fundamental theorem in propositional logic that shows the relationship between implications and their negations.

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


theorem GaloisConnection.monotone_u :
    ∀ {α : Type u} {β : Type v} [inst : Preorder α] [inst_1 : Preorder β] {l : α → β} {u : β → α},
      GaloisConnection l u → Monotone u :=
  by sorry

The theorem `GaloisConnection.monotone_u` states that for any types `α` and `β` that have a preorder, and for any functions `l : α → β` and `u : β → α` that form a Galois connection, the function `u` is monotone. In other words, if `l` and `u` satisfy the property that for all `a` in `α` and `b` in `β`, `l a` is less than or equal to `b` if and only if `a` is less than or equal to `u b`, then whenever `b1` is less than or equal to `b2` for any `b1, b2` in `β`, we have `u b1` is less than or equal to `u b2`.

If `l : α → β` and `u : β → α` form a Galois connection on preordered types `α` and `β`, then the function `u` is monotone, i.e., `u (b1) ≤ u (b2)` for all `b1 ≤ b2` in `β`.


Subtype.mk.injEq

theorem Subtype.mk.injEq :
    ∀ {α : Sort u} {p : α → Prop} (val : α) (property : p val) (val_1 : α) (property_1 : p val_1),
      ({ val := val, property := property } = { val := val_1, property := property_1 }) = (val = val_1) :=
  by sorry

This theorem, named `Subtype.mk.injEq`, states that for any type `α` and any property `p` pertaining to `α`, two subtypes created with the same value and property are equal if and only if their values are equal. Here, a subtype is created by providing a value of type `α` and a proof that the value satisfies property `p` (`{ val := val, property := property }`). The theorem formalizes the idea that the equality of these subtypes hinges purely on the equality of their contained values, irrespective of the properties associated with them.

For any type `α` and property `p`, two subtypes `{ val := a, property := p }` and `{ val := b, property := p }` of `α` are equal if and only if `a = b`.


Nonempty.map

/-- Given `f : α → β`, if `α` is nonempty then `β` is also nonempty.
`Nonempty` cannot be a `functor`, because `Functor` is restricted to `Type`.  -/
theorem Nonempty.map : ∀ {α : Sort u_2} {β : Sort u_3}, (α → β) → Nonempty α → Nonempty β := by sorry

This theorem, referred to as "Nonempty.map", states that for any two types `α` and `β`, if there exists a function `f` that maps from `α` to `β`, and if `α` is nonempty (i.e., there exists at least one value of type `α`), then `β` is also nonempty. The comment also notes that `Nonempty` cannot be a `functor`, a concept in functional programming which maps between types, because in Lean, `Functor` is restricted to the `Type` sort.

If `α` is a nonempty type and `f : α -> β` is a function, then `β` is a nonempty type.


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

The theorem `neg_nonneg` states that for all elements `a` of an additive group `α`, which also have a less-than-or-equal-to operation and satisfy a certain covariance property, `0` is less than or equal to the negation of `a` if and only if `a` is less than or equal to `0`. In other words, an element `a` of the group is non-positive if and only if its negation is non-negative.

For all elements `a` in an additive group with a covariance property, `a` is non-positive if and only if -`a` is non-negative.


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

This theorem states that for any two propositions `a` and `b`, if `a` is not true and `b` is not true, then `a` is logically equivalent to `b`. In other words, if both `a` and `b` are false, then they are interchangeable in a logical sense.

If `a` and `b` are propositions, then `a ⊬puisilon b ∧ b ⊬puisilon a` implies `a ↔ b`. (Here, `↔` denotes logical equivalence, and `⊬puisilon` denotes the negation of the implication.)


Ideal.ext

theorem Ideal.ext : ∀ {α : Type u} [inst : Semiring α] {I J : Ideal α}, (∀ (x : α), x ∈ I ↔ x ∈ J) → I = J := by sorry

The theorem `Ideal.ext` states that for any type `α`, which is assumed to be a semiring, and for any two ideals `I` and `J` of `α`, if every element `x` of `α` has the property that it belongs to `I` if and only if it belongs to `J`, then `I` and `J` are equal. Essentially, it asserts the equality of two ideals in a semiring if they contain exactly the same elements.

If two ideals in a semiring have the same elements, then they are equal.


TopologicalSpace.Opens.ext

theorem TopologicalSpace.Opens.ext :
    ∀ {α : Type u_2} [inst : TopologicalSpace α] {U V : TopologicalSpace.Opens α}, ↑U = ↑V → U = V := by sorry

This theorem states that for any type `α` equipped with a topological space structure, and for any two open subsets `U` and `V` of this topological space, if the underlying set of `U` is equal to the underlying set of `V`, then `U` is equal to `V`. In simpler terms, two open subsets of a topological space are the same if they consist of the same set of points.

In a topological space, two open sets with equal underlying sets are equal.


ENNReal.summable

theorem ENNReal.summable : ∀ {α : Type u_1} {f : α → ENNReal}, Summable f := by sorry

The theorem states that for any type `α` and any function `f` from `α` to the extended nonnegative real numbers `ENNReal`, the function `f` is summable. This means there exists some (possibly infinite) sum of the series generated by `f`. The type `ENNReal` represents the set of nonnegative real numbers including infinity, used typically as the codomain of a measure.

For any type `α` and function `f` from `α` to the extended nonnegative real numbers `ENNReal`, there exists a sum of the series generated by `f`.


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

The theorem `AEMeasurable.measurable_mk` states that for any types `α` and `β`, given a measurable space structure on `α`, a measurable space on `β`, a function `f` from `α` to `β`, and a measure `μ` on `α`, if `f` is almost everywhere measurable with respect to `μ`, then the function associated to `f`, which coincides with `f` almost everywhere, is measurable. This means that the preimage of any measurable set under this associated function is also a measurable set.

If a function between measurable spaces is almost everywhere defined by a measurable function and a measure is given, then the function is measurable.


theorem ENNReal.mul_lt_top : ∀ {a b : ENNReal}, a ≠ ⊤ → b ≠ ⊤ → a * b < ⊤ := by sorry

The theorem `ENNReal.mul_lt_top` states that for all extended nonnegative real numbers `a` and `b`, if neither `a` nor `b` is equal to positive infinity (denoted by `⊤`), then the product of `a` and `b` is strictly less than positive infinity. This is relevant in the context of measures, where the codomain of a measure is the set of extended nonnegative real numbers, which includes positive infinity. Hence, this theorem guarantees that as long as neither of the factors is infinity, the product will also not be infinity.

For all extended nonnegative real numbers `a` and `b` not equal to positive infinity, `a * b < ⊤`.


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

This theorem, `min_le_left`, states that for any given type `α` which has a linear order, and for any two elements `a` and `b` of that type, the minimum of `a` and `b` is less than or equal to `a`. This is a generalization of the well-known principle from mathematics that, for any two numbers, the smaller number (or the minimum) is always less than or equal to either of the two numbers.

For any type `α` with a linear order and any elements `a` and `b` of `α`, `min a b ≤ a` holds.


AddUnits.ext

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

The theorem `AddUnits.ext` states that for any type `α` which forms an additive monoid, the function `AddUnits.val` is injective. In other words, if `α` is a type with an additive monoid structure, and we have two elements of the type `AddUnits α` that map to the same element in `α` under the `AddUnits.val` function, they must have been the same element in `AddUnits α` to begin with.

If `α` is an additive monoid, then the function `AddUnits.val` from `AddUnits α` to `α` is an injection.


theorem Nat.gcd_dvd_left : ∀ (m n : ℕ), Nat.gcd m n ∣ m := by sorry

The theorem `Nat.gcd_dvd_left` states that for all natural numbers `m` and `n`, the greatest common divisor (gcd) of `m` and `n` divides `m`. In other words, `m` is a multiple of the gcd of `m` and `n`. This is a fundamental property of the gcd in number theory.

The greatest common divisor of natural numbers `m` and `n` (gcd `m` `n`) divides `m` (`gcd` `m` `n` | `m`).


theorem ENNReal.coe_le_coe : ∀ {r q : NNReal}, ↑r ≤ ↑q ↔ r ≤ q := by sorry

This theorem states that for all nonnegative real numbers `r` and `q`, the coercion of `r` to extended nonnegative real numbers is less than or equal to the coercion of `q` to extended nonnegative real numbers if and only if `r` is less than or equal to `q`. In mathematical terms, it's establishing that the order of `r` and `q` is preserved when they are embedded into the space of extended nonnegative real numbers.

For all nonnegative real numbers `r` and `q`, `r ≤ q` if and only if the coercion of `r` to extended nonnegative real numbers is less than or equal to the coercion of `q` to extended nonnegative real numbers.


theorem iSup₂_le :
    ∀ {α : Type u_1} {ι : Sort u_5} {κ : ι → Sort u_7} [inst : CompleteLattice α] {a : α} {f : (i : ι) → κ i → α},
      (∀ (i : ι) (j : κ i), f i j ≤ a) → ⨆ i, ⨆ j, f i j ≤ a :=
  by sorry

This theorem states that, for any type `α` that forms a complete lattice, any element `a` of `α`, and any function `f` mapping elements of type `ι` and `κ i` to `α`, if for all `i` and `j`, `f(i, j)` is less than or equal to `a`, then the supremum over all `i` and `j` of `f(i, j)` is also less than or equal to `a`. In mathematical terms, if each element in a set is less than or equal to `a`, then the least upper bound (supremum) of the set is also less than or equal to `a`.

For any complete lattice `α`, any element `a` in `α`, and any function `f` from a set into `α`, if `f(i) ≤ a` for all `i`, then `⨆ i. f(i) ≤ a`. (Here, `⨆` denotes the supremum or least upper bound over the index set `i`.)


theorem MeasureTheory.Measure.restrict_univ :
    ∀ {α : Type u_2} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α}, μ.restrict Set.univ = μ := by sorry

The `MeasureTheory.Measure.restrict_univ` theorem is a statement about measure theory in the context of a measurable space. For any given type `α`, if `m0` is a measurable space on `α` and `μ` is a measure on that measurable space, the theorem postulates that restricting the measure `μ` to the universal set of `α` (which includes all elements of `α`) is equivalent to the original measure `μ`. In other words, restricting a measure to the entire set doesn't change the measure.

For any measurable space (α, M, m0) and measure μ on m0, the restriction of μ to the universal set of α is equal to μ itself.


theorem Finset.mem_Ico :
    ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : LocallyFiniteOrder α] {a b x : α},
      x ∈ Finset.Ico a b ↔ a ≤ x ∧ x < b :=
  by sorry

The theorem `Finset.mem_Ico` states that for any type `α` which has a preorder and a locally finite order, and for any elements `a`, `b`, and `x` of type `α`, `x` is in the finset `Ico` from `a` to `b` if and only if `x` is greater than or equal to `a` and less than `b`. In other words, an element `x` belongs to the finset of elements between `a` and `b` (inclusive of `a` and exclusive of `b`) if and only if `a ≤ x < b`.

For any type `α` with a preorder and locally finite order, an element `x` lies in the finset `Ico` from `a` to `b` if and only if `a ≤ x < b`.


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

The theorem `CategoryTheory.Preadditive.neg_comp` states that in any preadditive category `C`, for any three objects `P`, `Q`, and `R` in `C`, and for any two morphisms `f` from `P` to `Q` and `g` from `Q` to `R`, the composition of the negation of `f` and `g` is equal to the negation of the composition of `f` and `g`. In mathematical expressions, this can be written as `(-f) ⋅ g = -(f ⋅ g)`. A preadditive category is a category where every homset is an abelian group and the composition of morphisms distributes over the group operation.

In a preadditive category, the negation of the composition of two morphisms is equal to the composition of their negations.


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

This theorem states that for any set `a` of any type `α`, the union of `a` with the empty set is equal to `a` itself. In other words, adding an empty set to any other set doesn't change the original set. In mathematical terms, if `α` is any type and `a` is a set of type `α`, then `a ∪ ∅ = a`.

For any set `a` of type `α`, the union of `a` with the empty set `∅` equals `a`: `a ∪ ∅ = a`.


theorem Polynomial.C_mul_X_pow_eq_monomial :
    ∀ {R : Type u} {a : R} [inst : Semiring R] {n : ℕ}, Polynomial.C a * Polynomial.X ^ n = (Polynomial.monomial n) a :=
  by sorry

This theorem establishes a correspondence between the multiplication of a constant polynomial and a power of the polynomial variable, and a monomial, in the context of semirings. Specifically, it states that for any semiring `R`, given a constant `a` from `R` and a natural number `n`, the multiplication of the constant polynomial `a` and the `n`-th power of the polynomial variable is equivalent to the monomial constituted by `a` and `n`. This effectively means that `Polynomial.C a * Polynomial.X ^ n` gives the same polynomial as `(Polynomial.monomial n) a` does.

For any semiring `R` and constant `a` from `R` and natural number `n`, the product of the constant polynomial `a` and the `n`-th power of the polynomial variable is equal to the monomial `(a :: R) * X ^ n`.


theorem mul_left_cancel₀ :
    ∀ {M₀ : Type u_1} [inst : Mul M₀] [inst_1 : Zero M₀] [inst_2 : IsLeftCancelMulZero M₀] {a b c : M₀},
      a ≠ 0 → a * b = a * c → b = c :=
  by sorry

This theorem states that in a given type `M₀` equipped with multiplication and zero, and also satisfies the left cancellation law for multiplication with zero, if a certain element `a` is not zero, then for any elements `b` and `c`, if the product of `a` and `b` equals the product of `a` and `c`, then `b` must be equal to `c`. This essentially means multiplication by a non-zero element `a` is injective, and hence allows the cancellation of `a` from both sides of the equation `a * b = a * c`.

If `a` is a non-zero element in a type `M₀` with multiplication and zero, and `a * b = a * c`, then `b = c`.


theorem List.map_id : ∀ {α : Type u_1} (l : List α), List.map id l = l := by sorry

The theorem `List.map_id` states that for all types `α` and for any list `l` of type `α`, applying the `List.map` function with the identity function `id` to `l` leaves the list unchanged. In other words, mapping the identity function over any list is equivalent to the original list itself. This can be interpreted as the property of `List.map` function to preserve identity – which is a fundamental property in many mathematical structures.

For all types `α` and lists `l` of type `α`, `List.map id l` equals `l`.


IsCompact.isClosed

/-- In a `T2Space`, every compact set is closed.  -/
theorem IsCompact.isClosed :
    ∀ {X : Type u_1} [inst : TopologicalSpace X] [inst_1 : T2Space X] {s : Set X}, IsCompact s → IsClosed s := by sorry

The theorem states that in a T2 Space (also known as a Hausdorff space), any set that is compact is also closed. In other words, given a topological space that satisfies the T2 separation axiom, if a set within that space has the property of compactness (meaning, for any nontrivial filter that contains the set, there exists a point in the set such that every set of the filter intersects every neighborhood of the point), then this set also has the property of being closed (its complement is an open set).

In a T2 (Hausdorff) space, every compact set is closed.


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

This theorem, `sup_eq_right`, states that for any type `α` that forms a semilattice with a supremum operation (denoted as `⊔`), and for any two elements `a` and `b` of this type, `a ⊔ b` being equal to `b` is equivalent to `a` being less than or equal to `b`. Essentially, it captures the intuition that in a semilattice, if the supremum of two elements is one of them, then the other element must not exceed it.

For any semilattice type `α` with supremum operation `⊔`, and any `a, b` in `α`, `a ⊔ b = b` if and only if `a ≤ b`.


theorem Set.mem_image : ∀ {α : Type u} {β : Type v} (f : α → β) (s : Set α) (y : β), y ∈ f '' s ↔ ∃ x ∈ s, f x = y := by
  sorry

This theorem, `Set.mem_image`, states that for all types `α` and `β`, a function `f` mapping from `α` to `β`, a set `s` of type `α`, and an element `y` of type `β`, `y` is in the image of `s` under `f` if and only if there exists an element `x` in `s` such that `f(x)` equals `y`. In other words, an element is in the image of a set under a function if and only if it is the function's output when applied to some element in the set.

For any function `f:` X → Y and set `s` ⊆ X, an element `y` ∈ Y is in the image of `s` under `f` if and only if there exists `x` ∈ s such that `f(x) = y`.


/-- A variant of `image_id`  -/
theorem Set.image_id' : ∀ {α : Type u_1} (s : Set α), (fun x => x) '' s = s := by sorry

This theorem, `Set.image_id'`, states that for any set `s` of type `α`, the image of `s` under the identity function (i.e., the function that returns each element `x` as it is) is `s` itself. In other words, applying the identity function to each element of a set doesn't change the set. This theorem is a variant of `image_id`.

For any set `s`, the image of `s` under the identity function is equal to `s`.


theorem Set.image_id : ∀ {α : Type u_1} (s : Set α), id '' s = s := by sorry

This theorem states that for every set `s` of elements of some type `α`, the image of `s` under the identity function (`id`) is equal to `s` itself. In other words, if we apply the identity function to each element of a set, we get back the same set. This aligns with the mathematical principle that the identity function leaves all elements unchanged.

For every set `s` and all `x` in `s`, `id x ∈ s`. (In Lean, this would be expressed as `∀ s : Set α, ∀ x : α, id x ∈ s → s`)


theorem Set.image_subset_range : ∀ {α : Type u_1} {β : Type u_2} (f : α → β) (s : Set α), f '' s ⊆ Set.range f := by
  sorry

The theorem `Set.image_subset_range` states that for all types `α` and `β`, and for any function `f` from `α` to `β` and any set `s` of type `α`, the image of `s` under `f` is a subset of the range of `f`. In other words, any element of `β` that can be obtained by applying `f` to an element of `s`, can also be obtained by applying `f` to some element of `α`. This theorem formalizes the idea that the image of a set under a function is always contained within the range of the function.

For any function between types and any set, the image of the set under the function is contained in the range of the function.


theorem not_exists : ∀ {α : Sort u_1} {p : α → Prop}, (¬∃ x, p x) ↔ ∀ (x : α), ¬p x := by sorry

This theorem, `not_exists`, states that for any type `α` and any proposition `p` that depends on `α`, the negation of the existence of an element of `α` that makes `p` true is equivalent to saying that for all elements of `α`, `p` is not true. In other words, there is no `x` in `α` for which `p` is true if and only if for every `x` in `α`, `p` is not true.

For any type `α` and proposition `p` depending on `α`, `∀x ∈ α, ¬p x` is equivalent to `∃x ∈ α. ¬p x`.


theorem by_contradiction : ∀ {p : Prop}, (¬p → False) → p := by sorry

This theorem, referred to as `by_contradiction`, states that for any proposition `p`, if the negation of `p` (expressed as `¬p`) leads to a contradiction (expressed as `→ False`), then `p` must be true. In other words, it captures the principle of proof by contradiction: if assuming the opposite of a proposition results in a contradiction, then the proposition itself must be true.

If the negation of a proposition leads to a contradiction, then the proposition is true.


CategoryTheory.Limits.Cone.w

theorem CategoryTheory.Limits.Cone.w :
    ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃}
      [inst_1 : CategoryTheory.Category.{v₃, u₃} C] {F : CategoryTheory.Functor J C} (c : CategoryTheory.Limits.Cone F)
      {j j' : J} (f : j ⟶ j'), CategoryTheory.CategoryStruct.comp (c.π.app j) (F.map f) = c.π.app j' :=
  by sorry

This theorem is a statement about categories, limits, cones, and functors in category theory. The theorem states that for any type `J` and type `C` (both categories), and a functor `F` from `J` to `C`, given a cone `c` over the functor `F`, for any two objects `j` and `j'` in `J` and a morphism `f` from `j` to `j'`, the composition of the morphism `c.π.app j` (the projection of the cone at `j`) and the functor's action on the morphism `f` (represented by `F.map f`) is equal to the projection of the cone at `j'` (represented by `c.π.app j'`). This is a fundamental property of cones in the context of category theory and it is often used to define the limiting property of cones.

For any functor F from category J to C and cone c over F, the composition of the projection of the cone at object j in J and the functor's action on a morphism from j to j' equals the projection of the cone at j'.


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

The theorem `Polynomial.coeff_add` states that for any semiring `R`, any polynomials `p` and `q` over `R`, and any natural number `n`, the coefficient of `X^n` in the sum of `p` and `q` is equal to the sum of the coefficients of `X^n` in `p` and in `q`. In other words, the coefficient of a given term in the sum of two polynomials is just the sum of the coefficients of that term in each of the two polynomials. This theorem corresponds to the distributive property in algebra.

For any semiring R, polynomials p and q over R, and natural number n, the coefficient of X^n in the sum of p and q is equal to the sum of the coefficients of X^n in p and in q.


theorem Mathlib.Data.Set.Intervals.Basic._auxLemma.4 :
    ∀ {α : Type u_1} [inst : Preorder α] {a b x : α}, (x ∈ Set.Icc a b) = (a ≤ x ∧ x ≤ b) := by sorry

This theorem states that for any type `α` that has a preorder (a set with a reflexive and transitive binary relation), and for any three elements `a`, `b`, and `x` of this type, `x` is in the interval from `a` to `b` (where the interval is closed on both ends) if and only if `a` is less than or equal to `x` and `x` is less than or equal to `b`.

For any preorder type `α`, and elements `a`, `b`, and `x` of `α`, `x` lies between `a` and `b` (inclusively) if and only if `a <= x <= b`.


theorem Ne.lt_top : ∀ {α : Type u} [inst : PartialOrder α] [inst_1 : OrderTop α] {a : α}, a ≠ ⊤ → a < ⊤ := by sorry

This theorem states that for any type `α` that has a partial order (`PartialOrder α`) and a designated top element (`OrderTop α`), any element `a` of type `α` that is not equal to the top element (`a ≠ ⊤`) is less than the top element (`a < ⊤`). In mathematical terms, it means that in a partially ordered set with a greatest element, any element not equal to this greatest element is strictly less than the greatest element.

In a partially ordered set with a top element, every element not equal to the top is strictly less than it.


theorem Real.norm_eq_abs : ∀ (r : ℝ), ‖r‖ = |r| := by sorry

This theorem states that for any real number `r`, the norm of `r` is equal to the absolute value of `r`. In other words, the magnitude of any real number, when considered in the context of a normed field, is the same as its absolute value. The norm and absolute value both measure "size" in their respective contexts.

For any real number `r`, the norm of `r` equals its absolute value. (i.e., `‖r‖ = |r|`)


theorem uniformContinuous_id : ∀ {α : Type ua} [inst : UniformSpace α], UniformContinuous id := by sorry

This theorem states that the identity function is uniformly continuous for any uniform space. In other words, for any type `α` that is a uniform space, the function `id`, which maps each element of `α` to itself, is uniformly continuous. In mathematical terms, this means that as `(x, y)` tends to the diagonal in the space `α`, `(id x, id y)` also tends to the diagonal, meaning that the identity function preserves closeness no matter where `x` and `y` are in `α`.

The identity function is uniformly continuous on any uniform space.


theorem CategoryTheory.Limits.kernel.lift_ι :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
      {X Y : C} (f : X ⟶ Y) [inst_2 : CategoryTheory.Limits.HasKernel f] {W : C} (k : W ⟶ X)
      (h : CategoryTheory.CategoryStruct.comp k f = 0),
      CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.kernel.lift f k h) (CategoryTheory.Limits.kernel.ι f) =
        k :=
  by sorry

This theorem states that for any category C with zero morphisms, given objects X, Y and W in the category, and a morphism `f` from X to Y that has a kernel, if another morphism `k` from W to X when composed with `f` results in a zero morphism (`k` composed with `f` is `0`), then the composition of the morphism obtained by lifting `k` to the kernel of `f` and the morphism from the kernel of `f` to X is equal to `k`. This essentially says that lifting `k` to the kernel of `f` correctly "undoes" the effect of mapping into the kernel.

Given a category with zero morphisms, if a morphism has a kernel and composing it with another morphism results in the zero morphism, then lifting the second morphism to the kernel of the first morphism equals the second morphism.


theorem continuous_mul :
    ∀ {M : Type u_3} [inst : TopologicalSpace M] [inst_1 : Mul M] [inst_2 : ContinuousMul M],
      Continuous fun p => p.1 * p.2 :=
  by sorry

This theorem states that for any type `M` that is a topological space, equipped with a multiplication operation and for which the multiplication operation is continuous, the function that multiplies a pair of elements of `M` is a continuous function. In terms of mathematical language, given a topological space `M` with a continuous multiplication operation, the map `(x, y) ↦ x * y` is a continuous function.

If `M` is a topological space equipped with a continuous multiplication operation, then the function `(x, y) mapsto x * y` is a continuous function on `M x M`.


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

The theorem `iInf_le_of_le` states that for every type `α` that is a complete lattice, and any function `f` that maps from an arbitrary type `ι` to `α`, if there exists an index `i` such that the value `f(i)` is less than or equal to a given member `a` of `α`, then the infimum (`iInf`) of the entire set range of `f` is less than or equal to `a`. In other words, if any member of the set produced by `f` is less than or equal to `a`, then the greatest lower bound (infimum) of the entire set is less than or equal to `a`.

If `f` maps an index `i` from a complete lattice `ι` to a complete lattice `α` such that `f(i) ≤ a` for some `a ∈ α`, then `iInf (range f) ≤ a`.


theorem Equiv.symm_apply_eq : ∀ {α : Sort u_1} {β : Sort u_2} (e : α ≃ β) {x : β} {y : α}, e.symm x = y ↔ x = e y := by
  sorry

This theorem, "Equiv.symm_apply_eq", states that for any two types `α` and `β` and any equivalence `e` between these types, for all `x` of type `β` and `y` of type `α`, the inverse of `e` applied to `x` is equal to `y` if and only if `x` is equal to `e` applied to `y`. In simpler terms, if you have an equivalence between two types, you can apply the equivalence to a value and then apply the inverse equivalence to get back the original value, and vice versa.

For any equivalence relation `e` on types `α` and `β`, `e(x) = y` if and only if `x = e⁻¹(y)`.


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

This theorem states that for any type `G` that is a commutative group, for any elements `a` and `b` of this group, the product of `a` and the division of `b` by `a` equals `b`. It implies that the operations of multiplication and division in this group cancel out each other. This is a generalization of the familiar property in arithmetic where multiplying a number by another number's division by the first number gives back the second number (i.e., `a * (b / a) = b`).

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


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

This theorem states that for any type `G` that forms an additive group, the additive inverse (`-a`) of any element `a` in `G` added to `a` itself equals zero. In other words, it encapsulates the property of groups where the sum of an element and its negative (or additive inverse) is the zero element. This is one of the basic properties of all additive groups, and in mathematical notation, it would be simply written as `-a + a = 0` for any `a` in the group `G`.

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


/-- The distance equals the norm of subtracting two points. In this
lemma, it is necessary to have `V` as an explicit argument; otherwise
`rw dist_eq_norm_vsub` sometimes doesn't work.  -/
theorem dist_eq_norm_vsub :
    ∀ (V : Type u_2) {P : Type u_3} [inst : SeminormedAddCommGroup V] [inst_1 : PseudoMetricSpace P]
      [inst_2 : NormedAddTorsor V P] (x y : P), dist x y = ‖x -ᵥ y‖ :=
  by sorry

This theorem states that the distance between two points is equal to the norm of the vector obtained by subtracting the two points. Here, `V` represents a seminormed additive commutative group, `P` represents a pseudo metric space, and the relation between `V` and `P` is that `P` is a torsor (or a translated space) over `V`. In other words, it's saying that in a space where you can both measure distances (a pseudo metric space) and have a compatible way of "subtracting" points (a normed add torsor), the distance between two points `x` and `y` is the same as the "length" (`norm`) of the "difference" (`vsub`) between `x` and `y`. This theorem requires `V` to be explicitly given as an argument to ensure correct functioning of the rewrite rule based on this theorem.

In a seminormed additive commutative group `V` making up a torsor over a pseudo metric space `P`, the distance between two points `x` and `y` equals the norm of their difference `x - y`.


/-- Express `edist` in terms of `nndist` -/
theorem edist_nndist : ∀ {α : Type u} [inst : PseudoMetricSpace α] (x y : α), edist x y = ↑(nndist x y) := by sorry

This theorem states that for any pseudometric space `α` and any two elements `x` and `y` in this space, the extended distance `edist` between `x` and `y` equals the non-negative real number equivalent (`↑`) of the non-negative distance `nndist` between `x` and `y`. In other words, in any pseudometric space, the `edist` function is essentially the same as the `nndist` function, but expressed in the extended real number system.

 In any pseudometric space, the extended distance between two elements equals the non-negative distance's non-negative real number equivalent.

Or, using Lean's notation:
`for any α : Type, (α => ℝ) => is_pseudometric α → ∀ x y : α, edist x y = ⇑(nndist x y)`


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

This theorem states that for any type `α` which has a linear order structure, the maximum of two values `a` and `b` of this type is commutative. In other words, `max a b` is equal to `max b a` for any `a` and `b` from a type with a linear order. This mirrors the familiar property from mathematics that the maximum of two real numbers `a` and `b` is the same whether you write "max(a, b)" or "max(b, a)".

For any type `α` with a linear order, the maximum of two elements `a` and `b` is commutative, i.e., `max a b = max b a`.


theorem Eq.mpr_not : ∀ {p q : Prop}, p = q → ¬q → ¬p := by sorry

This theorem states that for any two propositions `p` and `q`, if `p` is equal to `q` and `q` is not true (denoted by `¬q`), then `p` is also not true (denoted by `¬p`). In other words, it provides a means to propagate the falsity of a proposition to another equal proposition.

If `p` equals `q` and `q` is false, then `p` is false.


Primrec.fst

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

The theorem `Primrec.fst` states that for all types `α` and `β` which have a primitive recursive encoding (i.e., they are instances of the `Primcodable` class), the first projection function `Prod.fst` is a primitive recursive function. In other words, given a pair of elements `(a, b)` where `a` is from type `α` and `b` is from type `β`, the function that retrieves the first element `a` from the pair is a primitive recursive function.

For types `α` and `β` that are primitive recursively encodable, the first projection function `Prod.fst` on pairs of elements from types `α` and `β` is a primitive recursive function.


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

The theorem `CategoryTheory.Limits.CokernelCofork.condition` states that for any category `C` that has zero morphisms, and for any objects `X` and `Y` in `C` with a morphism `f` from `X` to `Y`, if `s` is a cokernel cofork of `f`, then the composition of `f` and the cofork projection (`π`) of `s` equals the zero morphism. In other words, in such a category, cokernel coforks have the property that when you follow the morphism `f` and then the morphism `π s`, you end up at the same place as if you had followed the zero morphism.

In a category with zero morphisms, the composition of a morphism and its cokernel cofork projection is equal to the zero morphism.


theorem Prod.ext_iff : ∀ {α : Type u_1} {β : Type u_2} {p q : α × β}, p = q ↔ p.1 = q.1 ∧ p.2 = q.2 := by sorry

The theorem `Prod.ext_iff` states that for any two pairs `p` and `q`, from any two types `α` and `β`, `p` is equal to `q` if and only if the first element of `p` is equal to the first element of `q` and the second element of `p` is equal to the second element of `q`. Essentially, it provides the condition for equality of two pairs in a product type.

For any pairs p and q of types α × β, p = q if and only if p.1 = q.1 and p.2 = q.2.


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

The theorem `add_le_add_iff_right` states that for all types `α` equipped with addition, a less-than-or-equal-to order that obeys both the covariant and contravariant properties, and any elements `a`, `b`, and `c` of type `α`, the inequality `b + a ≤ c + a` holds if and only if `b ≤ c`. In other words, in this ordered additive structure, adding the same element `a` to both sides of an inequality does not change the inequality's validity.

For all types `α` with covariant and contravariant additions and order `≤`, if `a`, `b`, and `c` are elements of `α`, then `b + a ≤ c + a` if and only if `b ≤ c`.


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

This theorem states that, for any type `R` that has multiplication (`Mul R`), addition (`Add R`), and satisfies the right distribution property (`RightDistribClass R`), the multiplication of the sum of two elements `a` and `b` with a third element `c` is equal to the sum of the products of `a` and `c` and `b` and `c`. In mathematical notation, it states that `(a + b) * c = a * c + b * c` for all `a`, `b`, `c` in `R`. This is known as the right distributive property of multiplication over addition.

For any type `R` with multiplication and addition, and right distributive property, `(a + b) * c = a * c + b * c` for all `a, b, c` in `R`.


theorem Quotient.out_eq' : ∀ {α : Sort u_1} {s₁ : Setoid α} (q : Quotient s₁), Quotient.mk'' (Quotient.out' q) = q := by
  sorry

The theorem `Quotient.out_eq'` states that for any sort `α` and any Setoid `s₁` on `α`, and for any quotient `q` of `s₁`, if you apply the function `Quotient.out'` to `q` to get an element of `α`, and then apply `Quotient.mk''` to that element, you will get back the original quotient `q`. Essentially, this theorem is saying that `Quotient.mk''` and `Quotient.out'` are inverse processes for any given quotient.

For any quotient `q` of a Setoid `s` on sort `α`, `Quotient.mk'' (Quotient.out' q) = q`.


theorem exists_ne : ∀ {α : Type u_1} [inst : Nontrivial α] (x : α), ∃ y, y ≠ x := by sorry

This theorem states that for all types `α` that are nontrivial (i.e., there are at least two distinct elements in `α`), given any element `x` from `α`, there exists another element `y` in `α` such that `y` is not equal to `x`. In other words, in any nontrivial type, for every element, there is always another distinct element.

In any nontrivial type, every element has a distinct element.


theorem Filter.mem_map :
    ∀ {α : Type u} {β : Type v} {f : Filter α} {m : α → β} {t : Set β}, t ∈ Filter.map m f ↔ m ⁻¹' t ∈ f := by sorry

The theorem `Filter.mem_map` states that for any types `α` and `β`, any filter `f` over `α`, any function `m` from `α` to `β`, and any set `t` of `β`, the set `t` is in the filter produced by mapping `f` through `m` if and only if the preimage of `t` under `m` is in `f`. This essentially means that applying the function `m` to the filter `f` and then checking for the presence of the set `t` is equivalent to first applying the function `m` to the set `t` to get its preimage, and then checking if this preimage is in the filter `f`.

For any filter `f` on type `α`, function `m` from `α` to `β`, and set `t` of `β`, `t ∈ map f m` if and only if `m⁻¹("t") ∈ f`.


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

This theorem, titled `Mathlib.Data.Finset.Basic._auxLemma.80`, states that for any type `α` with decidable equality and for any two finite sets `s` and `t` of this type, and any element `a` of this type, the proposition that `a` is an element of the union of `s` and `t` is equivalent to the proposition that `a` is either an element of `s` or an element of `t`. In other words, it provides a formalization of the basic set theory fact that an element belongs to the union of two sets if and only if it belongs to at least one of the sets.

For any type `α` with decidable equality, the union of two finite sets `s` and `t` of `α` equals the set of elements that are in `s` or in `t`.


theorem Polynomial.map_X :
    ∀ {R : Type u} {S : Type v} [inst : Semiring R] [inst_1 : Semiring S] (f : R →+* S),
      Polynomial.map f Polynomial.X = Polynomial.X :=
  by sorry

The theorem `Polynomial.map_X` states that for any two types `R` and `S` that are semirings, and any ring homomorphism `f` from `R` to `S`, applying the map function to the polynomial variable `Polynomial.X` in `R` results in the polynomial variable `Polynomial.X` in `S`. In other words, the variable (indeterminate) of the polynomial remains the same even when the coefficients are mapped across a ring homomorphism.

For any semirings R and S and ring homomorphism f from R to S, the map function applied to Polynomial.X in R is equal to Polynomial.X in S.


theorem Primrec₂.comp :
    ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {σ : Type u_5} [inst : Primcodable α] [inst_1 : Primcodable β]
      [inst_2 : Primcodable γ] [inst_3 : Primcodable σ] {f : β → γ → σ} {g : α → β} {h : α → γ},
      Primrec₂ f → Primrec g → Primrec h → Primrec fun a => f (g a) (h a) :=
  by sorry

The theorem `Primrec₂.comp` states that for all types `α`, `β`, `γ`, and `σ`, if `f` is a binary primitive recursive function that maps values from type `β` and `γ` to type `σ`, `g` is a primitive recursive function that maps values from type `α` to `β`, and `h` is a primitive recursive function that maps values from type `α` to `γ`, then the function that takes an input of type `α` and maps it to `f(g(a), h(a))` is also a primitive recursive function. This means that the composition of primitive recursive functions is again primitive recursive.

If `f` is a binary primitive recursive function and `g` and `h` are primitive recursive functions, then the composition `x ↦ f(g(x), h(x))` is a primitive recursive function.


theorem Set.MapsTo.image_subset :
    ∀ {α : Type u_1} {β : Type u_2} {s : Set α} {t : Set β} {f : α → β}, Set.MapsTo f s t → f '' s ⊆ t := by sorry

The theorem `Set.MapsTo.image_subset` states that for any two types `α` and `β`, and for any two sets `s` (which is a set of elements of type `α`) and `t` (which is a set of elements of type `β`), along with a function `f` from `α` to `β`, if `f` maps every element of `s` to an element of `t` (expressed as `Set.MapsTo f s t`), then the image of set `s` under function `f` (denoted by `f '' s`) is a subset of set `t`. This means every element of `f '' s` is also an element of `t`.

If `f` maps every element of set `s` to an element in set `t`, then `f(s) ⊆ t`. (The image of set `s` under function `f` is a subset of set `t`. )


/-- Two morphisms into a limit are equal if their compositions with
each cone morphism are equal.  -/
theorem CategoryTheory.Limits.IsLimit.hom_ext :
    ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃}
      [inst_1 : CategoryTheory.Category.{v₃, u₃} C] {F : CategoryTheory.Functor J C} {t : CategoryTheory.Limits.Cone F},
      CategoryTheory.Limits.IsLimit t →
        ∀ {W : C} {f f' : W ⟶ t.pt},
          (∀ (j : J),
              CategoryTheory.CategoryStruct.comp f (t.π.app j) = CategoryTheory.CategoryStruct.comp f' (t.π.app j)) →
            f = f' :=
  by sorry

This theorem, `CategoryTheory.Limits.IsLimit.hom_ext`, states that in the category theory, given any category `J`, any category `C`, any functor `F` from `J` to `C`, and any cone `t` over `F`, if `t` is a limit cone, then for any object `W` in `C` and any two morphisms `f` and `f'` from `W` to the apex of the cone `t`, if for each object `j` in `J`, the composition of `f` with the morphism from the cone `t` to `j` is equal to the composition of `f'` with the same morphism, then `f` and `f'` are equal.

In other terms, two morphisms into a limit are the same if they yield the same result when composed with each cone morphism. This theorem is a fundamental property of limit cones in category theory.

In any category, if a cone over a functor is a limit cone and two morphisms from an object to the apex of the cone have equal compositions with all cone morphisms, then they are equal.


theorem norm_mul_le : ∀ {α : Type u_1} [inst : NonUnitalSeminormedRing α] (a b : α), ‖a * b‖ ≤ ‖a‖ * ‖b‖ := by sorry

This theorem states that for any non-unital semi-normed ring of type `α`, the norm of the product of any two elements `a` and `b` is less than or equal to the product of their norms. In mathematical notation, this can be written as `‖a * b‖ ≤ ‖a‖ * ‖b‖` for all `a, b` in the ring `α`. This theorem is a reflection of the sub-multiplicative property of norms in semi-normed rings.

In any semi-normed ring, the product of two elements satisfies the norm inequality: $\|a \cdot b\| \leq \|a\| \cdot \|b\|$.


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`. Here, logical equivalence is denoted by the double arrow (`↔`), and it means that `a` implies `b` and `b` implies `a`. In other words, `a` and `b` either both hold true or both hold false.

For all propositions `a` and `b`, `a = b` if and only if `a ↔ b`.


/-- An element of the unit group of a nonzero monoid with zero represented as an element
of the monoid is nonzero.  -/
theorem Units.ne_zero : ∀ {M₀ : Type u_2} [inst : MonoidWithZero M₀] [inst_1 : Nontrivial M₀] (u : M₀ˣ), ↑u ≠ 0 := by
  sorry

This theorem states that in any nontrivial monoid with zero (a mathematical structure with a binary operation, an identity element, and a distinguished element called zero), any element of the unit group (elements with multiplicative inverses) is not equal to zero. Therefore, if `u` is an element of the unit group in this monoid, it is guaranteed that `u` is not the zero element.

In any nontrivial monoid with a zero element, every unit (invertible element) is distinct from zero.


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

The theorem `CategoryTheory.Preadditive.sub_comp` states that for any category `C` that is also a preadditive category, and any three objects `P`, `Q`, `R` in `C`, with morphisms `f`, `f'` from `P` to `Q` and a morphism `g` from `Q` to `R`, the composition of the difference of the morphisms `f` and `f'` with `g` is equal to the difference of the compositions of `f` and `g`, and `f'` and `g` respectively. In mathematical terms, for all `(f-f')` and `g`, `(f - f') ≫ g = f ≫ g - f' ≫ g`, where `≫` denotes the composition of morphisms. This theorem essentially states the distributive property of composition over subtraction in the context of preadditive categories.

In a preadditive category, for morphisms `f, f', g`, the composition `(f - f') ≫ g` equals `f ≫ g - f' ≫ g`.


Filter.EventuallyEq.le

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

This theorem states that for any types `α` and `β`, with `β` being a Preorder, and any filter `l` on `α`, if two functions `f` and `g` from `α` to `β` are eventually equal at `l`, then `f` is eventually less than or equal to `g` at `l`. In other words, if `f` and `g` are the same for all inputs beyond a certain point in the domain defined by the filter `l`, then `f` is also less than or equal to `g` for all inputs beyond that point.

Given types `α` and a preorder `β`, if functions `f` and `g` from `α` to `β` agree on a filter `l`'s elements, then `f ≤ g` holds for all `x ∈ ∃ (l)`.


theorem Function.iterate_succ' : ∀ {α : Type u} (f : α → α) (n : ℕ), f^[Nat.succ n] = f ∘ f^[n] := by sorry

This theorem states that for any function `f` mapping a type `α` to itself and any natural number `n`, the `(n+1)`-th iteration of the function `f` is equivalent to the function `f` composed with the `n`-th iteration of `f`. In mathematical terms, given a function $f: \alpha \to \alpha$ and a natural number $n$, we have $f^{(n+1)} = f \circ f^{(n)}$, where $f^{(n)}$ denotes the `n`-th iteration of the function `f`, and $\circ$ denotes function composition.

For any function $f: \alpha \to \alpha$ and natural number $n$, the $(n+1)$-th iteration of $f$ equals the composition of $f$ with the $n$-th iteration of $f$: $f^{(n+1)} = f \circ f^{(n)}$.


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

This theorem, `abs_of_pos`, states that for any type `α` which is a lattice, an add group, and satisfies the covariant class property, if `a` is an element of this type such that `a` is greater than zero, then the absolute value of `a` equals `a` itself. The purpose of this is to state a general property of absolute values: for any positive element, its absolute value simply equals the element itself. This theorem can be applied to any type that meets the constraints, making it a versatile and powerful statement in abstract algebraic environments.

For any lattice, add group type `α` satisfying the covariant class property, if `a` is a positive element of `α`, then `|a| = a`.


theorem Set.subset_preimage_image : ∀ {α : Type u_1} {β : Type u_2} (f : α → β) (s : Set α), s ⊆ f ⁻¹' (f '' s) := by
  sorry

The theorem `Set.subset_preimage_image` states that for all types `α` and `β`, and for any function `f` from `α` to `β`, and for any set `s` of type `α`, the set `s` is a subset of the preimage under `f` of the image of `s` under `f`. In mathematical terms, this can be written as $s \subseteq f^{-1}(f(s))$.

This theorem is about the relationship between a set and its image under a function: it says that every element of the original set is mapped to an element in the image, hence, the preimage of the image contains the original set.

For any function `f` and sets `s` of types `α` and `β`, `s` is a subset of the preimage of `f(s)` under `f`. In mathematical notation, `s ↪ f⁻¹(f(s))`.


/-- Subtracting a point from itself produces 0.  -/
theorem vsub_self : ∀ {G : Type u_1} {P : Type u_2} [inst : AddGroup G] [T : AddTorsor G P] (p : P), p -ᵥ p = 0 := by
  sorry

This theorem states that for any point `p` in a given add torsor `P` over an add group `G`, subtracting `p` from itself yields the zero element of the add group `G`. This is a property of torsors in vector spaces: the difference between a point and itself is always the zero vector.

For any point `p` in an add torsor `P` over an add group `G`, `p - p` equals the zero element of `G`.