theorem Polynomial.eval₂_eq_sum :
    ∀ {R : Type u} {S : Type v} [inst : Semiring R] {p : Polynomial R} [inst_1 : Semiring S] {f : R →+* S} {x : S},
      Polynomial.eval₂ f x p = Polynomial.sum p fun e a => f a * x ^ e :=
  by sorry

The theorem `Polynomial.eval₂_eq_sum` states that for all semirings `R` and `S`, a polynomial `p` of type `R`, a ring homomorphism `f` from `R` to `S`, and a value `x` of type `S`, the evaluation of the polynomial `p` using the ring homomorphism `f` and variable value `x` (through the function `Polynomial.eval₂`) is equal to the sum (through the function `Polynomial.sum`) of the values obtained by applying a function to the coefficients of the polynomial, where this function multiplies the image of the coefficient under `f` with the variable `x` raised to the power of the coefficient's degree (`f a * x ^ e`). In other words, this theorem provides a specific method to compute the evaluation of a polynomial by summing over its coefficients.

For all semirings R and S, polynomial p of type R, ring homomorphism f from R to S, and value x of type S, the evaluation of p using f and x is equal to the sum of the products of the images of the polynomial coefficients under f and x raised to their degrees.


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

The theorem `Nat.find_min'` states that for any decidable predicate `p` on natural numbers, if there exists a natural number `n` such that `p n` holds, then for any natural number `m` where `p m` also holds, the smallest natural number satisfying `p` (found by `Nat.find`) is less than or equal to `m`. In other words, `Nat.find` will always return the minimum natural number satisfying the predicate `p`.

If `p` is a decidable predicate on natural numbers such that there exists an `n` with `p(n)` holding, then for any other `m` with `p(m)` holding, `Nat.find p` is less than or equal to `m`.


theorem MeasureTheory.measure_lt_top :
    ∀ {α : Type u_1} {m0 : MeasurableSpace α} (μ : MeasureTheory.Measure α) [inst : MeasureTheory.IsFiniteMeasure μ]
      (s : Set α), ↑↑μ s < ⊤ :=
  by sorry

This theorem states that for any type `α` and a given measurable space `m0` over `α`, any set `s` in this space, and a measure `μ` which is finite, the measure `μ` of set `s` is always less than infinity (`⊤`). Essentially, it ensures that, within a finite measure, the measure of any particular set is also finite.

For any measurable space `(α, m0)`, finite measure `μ` over `α`, and measurable set `s` in `α`, we have `μ(s) < ⊤`.


/-- We can evaluate the pushforward on measurable sets. For non-measurable sets, see
`MeasureTheory.Measure.le_map_apply` and `MeasurableEquiv.map_apply`.  -/
theorem MeasureTheory.Measure.map_apply_of_aemeasurable :
    ∀ {α : Type u_1} {β : Type u_2} {m0 : MeasurableSpace α} [inst : MeasurableSpace β] {μ : MeasureTheory.Measure α}
      {f : α → β},
      AEMeasurable f μ → ∀ {s : Set β}, MeasurableSet s → ↑↑(MeasureTheory.Measure.map f μ) s = ↑↑μ (f ⁻¹' s) :=
  by sorry

This theorem, `MeasureTheory.Measure.map_apply_of_aemeasurable`, states that for any two types `α` and `β` with measure spaces `m0` and `inst` respectively, given a measure `μ` on type `α` and a function `f` that maps from `α` to `β` and is almost everywhere measurable relative to `μ`, if we have a set `s` of `β` that is measurable, then the measure of `s` under the pushforward of `μ` by `f` is equal to the measure of the preimage of `s` under `f` with respect to `μ`. In simpler terms, it explains how to measure a set in the target space of a function in terms of the measure of its preimage in the original space.

For any measurable functions f from a measurable space (α, m0) to a measurable space (β, m), and any measurable set s in (β), the measure of s under the pushforward measure m \* f is equal to the measure of the preimage of s under f with respect to m0.


theorem Finset.prod_singleton :
    ∀ {α : Type u_3} {β : Type u_4} [inst : CommMonoid β] (f : α → β) (a : α), (Finset.prod {a} fun x => f x) = f a :=
  by sorry

The theorem `Finset.prod_singleton` asserts that for every type `α` and `β`, given `β` forms a commutative monoid, and given a function `f` from `α` to `β`, as well as an element `a` of type `α`, the product of the function `f` over the singleton finite set containing only `a` (notated as `Finset.prod {a} f`) is equal to the function `f` applied to `a` (notated as `f a`). In other words, the product of a single-element set under any function is just the function applied to that element.

For any type `α` and commutative monoid `β`, and given a function `f` from `α` to `β` and an element `a` of type `α`, the product of `f` over the singleton finite set `{a}` is equal to the application of `f` to `a`, i.e., `Finset.prod {a} f = f a`.


/-- The oriented angle between three points equals the unoriented angle if the sign is
positive.  -/
theorem EuclideanGeometry.oangle_eq_angle_of_sign_eq_one :
    ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V]
      [inst_2 : MetricSpace P] [inst_3 : NormedAddTorsor V P] [hd2 : Fact (FiniteDimensional.finrank ℝ V = 2)]
      [inst_4 : Module.Oriented ℝ V (Fin 2)] {p₁ p₂ p₃ : P},
      Real.Angle.sign (EuclideanGeometry.oangle p₁ p₂ p₃) = 1 →
        EuclideanGeometry.oangle p₁ p₂ p₃ = ↑(EuclideanGeometry.angle p₁ p₂ p₃) :=
  by sorry

The theorem `EuclideanGeometry.oangle_eq_angle_of_sign_eq_one` states that for a vector space `V` with a finite rank of 2 over the real numbers `ℝ` and a set of points `P` in `V`, if the oriented angle (denoted by `EuclideanGeometry.oangle`) between three points `p₁`, `p₂` and `p₃` has a sign of 1 (indicating that the angle is strictly between `0` and `π`), then this oriented angle is equal to the unoriented angle (denoted by `EuclideanGeometry.angle`) between the same three points.

If the oriented angle between three points in a 2-dimensional real vector space has a positive sign, then it is equal to the unoriented angle between the same three points.


theorem Mathlib.Data.Multiset.Basic._auxLemma.6 :
    ∀ {α : Type u_1} {a b : α} {s : Multiset α}, (a ∈ b ::ₘ s) = (a = b ∨ a ∈ s) := by sorry

This theorem states that for any type `α`, and any elements `a` and `b` of `α`, and any multiset `s` of `α`, the condition of `a` being an element of the multiset formed by adjoining `b` to `s` is equivalent to the disjunction of `a` being equal to `b` or `a` being an element of `s`. In other words, an element `a` is in a multiset formed by adding an element `b` to another multiset `s` if and only if `a` equals `b` or `a` is in `s`.

For any type `α`, and any elements `a`, `b` of `α`, and multiset `s` of `α`, `a` is in the multiset `s ∪ {b}` if and only if `a = b` or `a` is in `s`.


theorem Mathlib.Data.Multiset.Basic._auxLemma.55 :
    ∀ {α : Type u_1} {β : Type v} {f : α → β} {b : β} {s : Multiset α}, (b ∈ Multiset.map f s) = ∃ a ∈ s, f a = b := by
  sorry

This theorem states that for any types `α` and `β`, a function `f` from `α` to `β`, a value `b` of type `β`, and a multiset `s` of type `α`, `b` is in the multiset obtained by mapping `f` over `s` if and only if there exists a value `a` in `s` such that `f(a)` equals `b`. In mathematical terms, this means that if $b \in \text{map}(f, s)$ then there exists an $a \in s$ such that $f(a) = b$, and vice versa.

For any function $f$ from type $\alpha$ to type $\beta$, value $b$ of type $\beta$, and multiset $s$ of type $\alpha$, $b$ is in the image of $f$ under $s$ if and only if there exists an element $a$ in $s$ such that $f(a) = b$. In symbols, $\exists a \in s.\, f(a) = b \iff b \in \text{map}(f, s)$.


theorem Int.emod_nonneg : ∀ (a : ℤ) {b : ℤ}, b ≠ 0 → 0 ≤ a % b := by sorry

This theorem states that for any integer `a` and any non-zero integer `b`, the modulus of `a` with respect to `b` (`a % b`) is always greater than or equal to 0. In other words, when `a` is divided by `b`, the remainder (which is what the modulus operation calculates) is never negative. This is a standard property of the modulus operation in mathematics.

For all integers `a` and non-zero `b`, `a % b` is a non-negative integer.


GaloisConnection.dual

theorem GaloisConnection.dual :
    ∀ {α : Type u} {β : Type v} [inst : Preorder α] [inst_1 : Preorder β] {l : α → β} {u : β → α},
      GaloisConnection l u →
        GaloisConnection (⇑OrderDual.toDual ∘ u ∘ ⇑OrderDual.ofDual) (⇑OrderDual.toDual ∘ l ∘ ⇑OrderDual.ofDual) :=
  by sorry

The `GaloisConnection.dual` theorem states that for any two types `α` and `β` that are preordered, and two functions `l : α → β` and `u : β → α` that form a Galois Connection, the composition of these functions with the `OrderDual.toDual` and `OrderDual.ofDual` (which are identity functions on the dual orders) also forms a Galois Connection. In other words, it states that the concept of a Galois Connection is preserved under the operation of taking duals of the orders.

Given types `α` and `β` preordered with functions `l : α → β` and `u : β → α` forming a Galois connection, their compositions with the order dual functions form another Galois connection. That is, `OrderDual.toDual ∘ l` and `OrderDual.ofDual ∘ u` constitute a Galois connection.


theorem sdiff_self : ∀ {α : Type u_2} [inst : GeneralizedCoheytingAlgebra α] {a : α}, a \ a = ⊥ := by sorry

This theorem states that for any type `α` which forms a Generalized Coheyting Algebra, the set difference of any element `a` with itself is always the bottom element, represented by `⊥`. In the context of a Generalized Coheyting Algebra, the bottom element typically represents the "empty" or "zero" element. Therefore, the theorem essentially says that subtracting any element from itself results in an "empty" or "zero" element in the algebraic structure.

In a Generalized Coheting Algebra, for all types `α` and elements `a` of type `α`, `a \ a = ⊥`.


theorem Nat.unpair_pair : ∀ (a b : ℕ), Nat.unpair (Nat.pair a b) = (a, b) := by sorry

The theorem `Nat.unpair_pair` states that for all natural numbers `a` and `b`, if you first pair them using the `Nat.pair` function and then unpair the result using the `Nat.unpair` function, you will get back the original pair `(a, b)`. In other words, the `Nat.unpair` function is the inverse of the `Nat.pair` function when applied to the result of the `Nat.pair` function. This is essentially a property of bijectiveness stating that every pair of natural numbers can be uniquely mapped to a single natural number and can be recovered from it.

For all natural numbers `a` and `b`, `Nat.unpair (Nat.pair a b) = (a, b)`.


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

The theorem `Set.Ioo_subset_Ioc_self` states that for all types `α` with a preorder (an order relation that is reflexive and transitive), and for all elements `a` and `b` of type `α`, the set of elements `x` such that `a` is less than `x` and `x` is less than `b` (denoted as `Set.Ioo a b`, or the open interval (a, b)) is a subset of the set of elements `x` such that `a` is less than `x` and `x` is less than or equal to `b` (denoted as `Set.Ioc a b`, or the half-open interval (a, b]). This means that every element in the open interval (a, b) is also present in the half-open interval (a, b].

The open interval (a, b) is a subset of the half-open interval (a, b] for all elements a and b of a preordered type α.


theorem star_one : ∀ (R : Type u) [inst : MulOneClass R] [inst_1 : StarMul R], star 1 = 1 := by sorry

This theorem states that for any type `R` that has a multiplication and a unit element (as specified by the `MulOneClass` typeclass) and also supports the star multiplication operation (as specified by the `StarMul` typeclass), the star of the unit element `1` is equal to `1`. In mathematical terms, it says that the star operation is a unital operation on `R`, i.e., the identity element remains unchanged under the star operation.

For any type `R` with multiplication and a unit element, and having a star multiplication operation, the star of the unit element is equal to the unit element (i.e., 1 * is = 1).


theorem Complex.continuous_re : Continuous Complex.re := by sorry

This theorem states that the real part of a complex number is a continuous function. In other words, for every sequence of complex numbers that converges to a certain complex number, the sequence of their real parts also converges to the real part of the limit. This is a basic property in the field of complex analysis.

The real part function is continuous on the complex numbers.


theorem Real.log_zero : Real.log 0 = 0 := by sorry

This theorem states that the real logarithm of zero is equal to zero. More specifically, when the `Real.log` function, which is defined as the real logarithm function (with a particular extension to `(-∞, 0]` to maintain the property `log(x * y) = log(x) + log(y)` for all nonzero `x` and `y` and the derivative of `log` being `1/x` away from `0`), is applied to `0`, the result is `0`.

The real logarithm of 0 is equal to 0. (log(0) = 0)


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

This theorem, named "Eq.trans_lt", states that for any type `α` with a less-than relationship (`LT`), if an element `a` is equal to an element `b` (`a = b`), and `b` is less than another element `c` (`b < c`), then `a` is less than `c` (`a < c`). Essentially, it transmits the less-than relationship through an equality: equality and a 'less-than' relationship together imply another 'less-than' relationship.


/-- Rotating the points in an oriented angle does not change the sign of that angle.  -/
theorem EuclideanGeometry.oangle_rotate_sign :
    ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V]
      [inst_2 : MetricSpace P] [inst_3 : NormedAddTorsor V P] [hd2 : Fact (FiniteDimensional.finrank ℝ V = 2)]
      [inst_4 : Module.Oriented ℝ V (Fin 2)] (p₁ p₂ p₃ : P),
      Real.Angle.sign (EuclideanGeometry.oangle p₂ p₃ p₁) = Real.Angle.sign (EuclideanGeometry.oangle p₁ p₂ p₃) :=
  by sorry

This theorem states that rotating the points in an oriented angle doesn't alter the sign of that angle. More precisely, given a vector space `V` over the real numbers `ℝ` that is a normed add commutative group, an inner product space, and a metric space `P` that is a normed additive group with a translation action by `V`, and assuming `V` is two-dimensional and oriented, for any three points `p₁`, `p₂`, and `p₃` in `P`, the sign of the oriented angle from `p₂` to `p₃` around `p₁` will be the same as the sign of the oriented angle from `p₁` to `p₂` around `p₃`. The sign of an angle is defined as `0` if the angle is `0` or `π`, `1` if the angle is strictly between `0` and `π`, and `-1` if the angle is strictly between `-π` and `0`. This sign is determined by the sign of the sine of the angle.

Given two-dimensional oriented vector spaces over the real numbers with the given properties, the sign of the angle between any two vectors remains constant under rotation around a third vector.


theorem List.tfae_of_cycle :
    ∀ {a b : Prop} {l : List Prop},
      List.Chain (fun x x_1 => x → x_1) a (b :: l) → (List.getLastD l b → a) → List.TFAE (a :: b :: l) :=
  by sorry

The theorem `List.tfae_of_cycle` states that for any two propositions `a` and `b`, and a list of propositions `l`, if `a` logically implies each proposition in the list `b :: l` in sequence (`List.Chain`), and the last proposition in the list `l` with a default of `b` (`List.getLastD l b`) implies `a`, then all propositions in the list `a :: b :: l` are logically equivalent (`List.TFAE`). In other words, this theorem provides a way to show that a cyclic chain of implications among a list of propositions implies the logical equivalence of these propositions.

If `a` implies every `b : l` and the last `b` (or `a` if `l` is empty) implies `a`, then `a` is logically equivalent to each `b` in the list `a :: b :: l`.


CategoryTheory.Limits.limit.w

theorem CategoryTheory.Limits.limit.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) [inst_2 : CategoryTheory.Limits.HasLimit F] {j j' : J} (f : j ⟶ j'),
      CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.limit.π F j) (F.map f) =
        CategoryTheory.Limits.limit.π F j' :=
  by sorry

The theorem `CategoryTheory.Limits.limit.w` is a statement in category theory about limits in a category. Specifically, for any category `J`, any category `C`, any functor `F` from `J` to `C`, and any morphism `f` from `j` to `j'` in `J`, the composition of the projection from the limit of `F` to `F.obj j` and the image of `f` under `F` is equal to the projection from the limit of `F` to `F.obj j'`. In other words, this theorem states that in a category with limits, the limit behaves functorially with respect to morphisms in the indexing category: the diagram formed by the limit, the projections, and the map `F` commutes.

For any functor F from a small category J to a category C and any morphism f in J, the diagram commutes for the limit of F, that is, the composition of the limit projection to F(j) and the image of f under F equals the limit projection to F(j').


theorem isOpen_discrete :
    ∀ {α : Type u_1} [inst : TopologicalSpace α] [inst_1 : DiscreteTopology α] (s : Set α), IsOpen s := by sorry

The theorem `isOpen_discrete` states that for any type `α` that has a topological space structure and a discrete topology structure, any set `s` of type `α` is open in this topological space. In other words, in a discrete topological space, every set is an open set.

In a discrete topological space, every subset is open.


theorem ENNReal.ofReal_toReal : ∀ {a : ENNReal}, a ≠ ⊤ → ENNReal.ofReal a.toReal = a := by sorry

This theorem states that for every extended nonnegative real number `a` that is not equal to positive infinity, the function `ENNReal.ofReal` applied to the real part of `a` (obtained by `a.toReal`) is equal to `a` itself. In simple terms, this means that if we convert a non-infinite extended nonnegative real number to a real number and then back to an extended nonnegative real number, we get the original number back. This implies the "consistency" between the conversion functions `toReal` and `ofReal` in the context of extended nonnegative real numbers.

For every finite extended non-negative real number `a`, `ENNReal.ofReal (a.toReal) = a`.


theorem Continuous.comp_continuousOn :
    ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β]
      [inst_2 : TopologicalSpace γ] {g : β → γ} {f : α → β} {s : Set α},
      Continuous g → ContinuousOn f s → ContinuousOn (g ∘ f) s :=
  by sorry

The theorem `Continuous.comp_continuousOn` states that for any three topological spaces `α`, `β`, and `γ`, if a function `g` from `β` to `γ` is continuous, and a function `f` from `α` to `β` is continuous on a set `s` in `α`, then the composition of `g` and `f` (denoted as `g ∘ f`) is also continuous on the set `s`. In other words, the continuity of the individual functions ensures the continuity of their composition on the specified set.

If a function from `α` to `β` is continuous on a set `s` in `α`, and a function from `β` to `γ` is continuous, then their composition is continuous on `s`.


/-- An `AddSubmonoid` contains the monoid's 0. -/
theorem AddSubmonoid.zero_mem : ∀ {M : Type u_1} [inst : AddZeroClass M] (S : AddSubmonoid M), 0 ∈ S := by sorry

This theorem states that for any `AddSubmonoid` `S` of a type `M`, which is an instance of the `AddZeroClass`, the additive identity element `0` is a member of `S`. In other words, the set `S` always includes the element 0. Here, `AddZeroClass` is a class that combines addition and a zero element in the context of algebraic structures.

For any AddSubmonoid S of type M that is an instance of AddZeroClass, the additive identity 0 is an element of S.


theorem List.forall_mem_cons :
    ∀ {α : Type u_1} {p : α → Prop} {a : α} {l : List α}, (∀ x ∈ a :: l, p x) ↔ p a ∧ ∀ x ∈ l, p x := by sorry

This theorem, `List.forall_mem_cons`, states that for all types `α`, predicates `p` over `α`, elements `a` of type `α`, and lists `l` of type `α`, the predicate `p` holds for all elements in the list created by prepending `a` to `l` if and only if `p` holds for `a` and `p` holds for all elements in `l`. In mathematical terms, it's expressing that ∀x ∈ (a :: l), p(x) is equivalent to p(a) ∧ ∀x ∈ l, p(x).

For any type `α`, predicate `p` over `α`, element `a` of type `α`, and list `l` of type `α`, the list `a :: l` has all elements satisfying `p` if and only if `a` satisfies `p` and the list `l` has all elements satisfying `p`. In symbols, `(∀x ∈ a :: l) p(x) ↔ (p(a) ∧ ∀x ∈ l) p(x)`.


theorem Matrix.diagonal_apply_ne :
    ∀ {n : Type u_3} {α : Type v} [inst : DecidableEq n] [inst_1 : Zero α] (d : n → α) {i j : n},
      i ≠ j → Matrix.diagonal d i j = 0 :=
  by sorry

This theorem states that for any types `n` and `α`, where `n` has a decidable equality and `α` has an element identified as zero, and any function `d` mapping `n` to `α`, and any elements `i` and `j` of `n` such that `i` is not equal to `j`, the value at the `i,j` position in the matrix created by the `Matrix.diagonal` function using `d` is zero. In simple terms, in a square matrix created by the function `Matrix.diagonal`, all the off-diagonal elements are zero.

For any type `n` with decidable equality and any type `α` with an identified zero element, if we define an `n × n` matrix `M` using `Matrix.diagonal` with a function mapping `n` to `α`, then all off-diagonal entries of `M` equal zero.


theorem Option.some_ne_none : ∀ {α : Type u_1} (x : α), some x ≠ none := by sorry

This theorem, `Option.some_ne_none`, asserts that for any type `α` and any value `x` of type `α`, the option `some x` is not equal to `none`. In other words, an option wrapping a specific value is always distinct from an option that contains no value, irrespective of the type and the value that is wrapped.

For all types `α` and values `x` of type `α`, `Option.some x ≠ Option.none`.


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

The theorem `tsum_eq_zero_of_not_summable` states that for any types `α` and `β`, any additive commutative monoid structure on `α`, any topological space structure on `α`, and any function `f` from `β` to `α`, if the function `f` is not summable (i.e., it doesn't have an infinite sum), then the total sum of the series created by `f` is zero. In mathematical notation, we write this as: if ∃ a, such that ∑ f(n) does not converge to a (i.e., f is not summable), then ∑ f(n) = 0.

If a function from a type to an additive commutative monoid with a topology, where the sum over the image of any non-convergent sequence does not exist, equals the additive identity of the monoid.


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

This theorem, `sup_le_iff`, states that for any three elements `a`, `b`, and `c` in a semilattice (with supremum operation), the supremum of `a` and `b` is less than or equal to `c` if and only if both `a` is less than or equal to `c` and `b` is less than or equal to `c`. In other words, the largest of `a` and `b` (which is what `a ⊔ b` represents) is less than or equal to `c` precisely when each of `a` and `b` individually is less than or equal to `c`. This theorem is a fundamental property in order theory and lattice theory.

In a semilattice, the supremum of two elements is less than or equal to a third element if and only if the first two elements are less than or equal to that element.


theorem Set.not_mem_empty : ∀ {α : Type u} (x : α), x ∉ ∅ := by sorry

This theorem states that for any type `α` and any element `x` of type `α`, `x` is not a member of the empty set. In other words, it formalizes the intuitive idea that the empty set, denoted by `∅`, contains no elements, regardless of the type of the elements we are considering.

The theorem asserts that for any type `α` and any element `x : α`, `x ∉ ∅`.


Measurable.mul

theorem Measurable.mul :
    ∀ {M : Type u_2} {α : Type u_3} [inst : MeasurableSpace M] [inst_1 : Mul M] {m : MeasurableSpace α} {f g : α → M}
      [inst_2 : MeasurableMul₂ M], Measurable f → Measurable g → Measurable fun a => f a * g a :=
  by sorry

The theorem `Measurable.mul` states that given any two functions `f` and `g` from a measurable space `α` to a space `M` equipped with a multiplication operation and a measure, if both `f` and `g` are measurable functions, then the function that maps an element of `α` to the product of `f` and `g` at that element (i.e., `(a => f a * g a)`) is also a measurable function. This is under the condition that `M` also supports the `MeasurableMul₂` operation, which is a typeclass indicating that the multiplication operation is measurable.

If `α` is a measurable space, `M` is a measurable space equipped with a measurable multiplication operation, and `f` and `g` are measurable functions from `α` to `M`, then the function mapping `α` to the product of `f` and `g` is measurable.


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

This theorem, `Int.le_of_lt`, states that for any two integer values `a` and `b`, if `a` is strictly less than `b`, then `a` is also less than or equal to `b`. In mathematical terms, if a < b, it implies that a ≤ b. This theorem is generally applicable in the field of integer numbers.

For all integers a and b, if a < b then a ≤ b.


/-- **Alias** of `Cardinal.mk_congr`. -/
theorem Equiv.cardinal_eq : ∀ {α β : Type u}, α ≃ β → Cardinal.mk α = Cardinal.mk β := by sorry

This theorem, referred to as `Equiv.cardinal_eq`, states that for any two types `α` and `β` at the same universe level `u`, if `α` is equivalent to `β` (denoted by `α ≃ β`), then the cardinality of `α` (denoted by `Cardinal.mk α`) is equal to the cardinality of `β` (denoted by `Cardinal.mk β`). In other words, equivalent types have the same cardinality. This is an alias of the theorem `Cardinal.mk_congr`.

If two types `α` and `β` are equivalent, then they have the same cardinality.


/-- The submonoid generated by a set includes the set.  -/
theorem Submonoid.subset_closure : ∀ {M : Type u_1} [inst : MulOneClass M] {s : Set M}, s ⊆ ↑(Submonoid.closure s) := by
  sorry

This theorem states that for any type `M` which has a multiplication and a one (i.e., it is an instance of `MulOneClass`), and any set `s` of elements in `M`, the set `s` is a subset of the submonoid generated by `s`. In other words, every element in the set `s` is also an element in the submonoid that is generated by `s`. The submonoid generated by `s` is the smallest submonoid that contains `s`, so this theorem essentially says all elements of `s` are also included in this smallest containing submonoid. This is expressed by the inclusion relation `s ⊆ ↑(Submonoid.closure s)`.

For any multiplicative monoid `M` and subset `s` of `M`, `s` is contained in the submonoid generated by `s` (i.e., `s ⊆ Submonoid.closure s`).


HasDerivAt.comp

/-- The chain rule.  -/
theorem HasDerivAt.comp :
    ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] (x : 𝕜) {𝕜' : Type u_1} [inst_1 : NontriviallyNormedField 𝕜']
      [inst_2 : NormedAlgebra 𝕜 𝕜'] {h : 𝕜 → 𝕜'} {h₂ : 𝕜' → 𝕜'} {h' h₂' : 𝕜'},
      HasDerivAt h₂ h₂' (h x) → HasDerivAt h h' x → HasDerivAt (h₂ ∘ h) (h₂' * h') x :=
  by sorry

This theorem is the chain rule from calculus, stated in the context of normed algebra. Specifically, it states that if a function `h₂` has derivative `h₂'` at the point `h(x)`, and a function `h` has derivative `h'` at the point `x`, then the derivative of the composition of `h₂` and `h` at the point `x` is `h₂' * h'`. This theorem holds for any nontrivially normed field `𝕜` and `𝕜'`, where `𝕜'` is a normed algebra over `𝕜`.

If `h : ℝ → 𝕜` and `h₂ : ℝ → 𝕜'` are differentiable at `x ∈ ℝ` with derivatives `h'` and `h₂'` respectively, then the derivative of `h₂ ∘ h` at `x` is `h₂' * h'`.


LE.le.antisymm'

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

This theorem, named `LE.le.antisymm'`, is essentially an alias of `ge_antisymm`. It states that for any type `α` that has a `PartialOrder` structure, if one element `a` is less than or equal to another element `b`, and `b` is also less than or equal to `a`, then `b` and `a` are equal. This is a fundamental property of partially ordered sets, reflecting the antisymmetry characteristic of these structures.

In a partially ordered set, if `a` is less than or equal to `b` and `b` is less than or equal to `a`, then `a` and `b` are equal.


theorem pow_orderOf_eq_one : ∀ {G : Type u_1} [inst : Monoid G] (x : G), x ^ orderOf x = 1 := by sorry

The theorem `pow_orderOf_eq_one` states that for any type `G` that is a monoid, and for every element `x` from this monoid, when `x` is raised to the power of its order (`orderOf x`), the result will be the identity element of the monoid, which is `1`. In other words, in any monoid, raising an element to the power of its order always yields the monoid's identity.

For any monoid `G` and element `x` in `G`, `x^(orderOf x) = 1`.


theorem WithBot.bot_lt_coe : ∀ {α : Type u_1} [inst : LT α] (a : α), ⊥ < ↑a := by sorry

This theorem states that, for any type `α` that has a less-than (`LT`) operation, and for any element `a` of type `α`, the bottom element (denoted as `⊥`) is less than the `a` element when `a` is lifted (coerced) into the "WithBot α" type. This is a formalization of the intuitive idea that the bottom element is less than any other element in the order.

For any type `α` with a `LT` operation and any `a : α`, `⊥ : WithBot α` holds `LT ⊥ a`.


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

The theorem `Set.mem_insert_of_mem` states that for any type `α`, any element `x` of type `α`, and any set `s` of type `Set α`, if `x` is an element of `s`, then `x` is also an element of the set obtained by inserting any element `y` of type `α` into `s`. In other words, if `x` belongs to a set `s`, then `x` will still belong to the set after we add another element to `s`.

If `x` is an element of set `s` and `y` is any element, then `x` is an element of the set obtained by inserting `y` into `s` (i.e., `s.insert y`).


theorem RingHom.comp_apply :
    ∀ {α : Type u_2} {β : Type u_3} {γ : Type u_4} {x : NonAssocSemiring α} {x_1 : NonAssocSemiring β}
      {x_2 : NonAssocSemiring γ} (hnp : β →+* γ) (hmn : α →+* β) (x_3 : α),
      (RingHom.comp hnp hmn) x_3 = hnp (hmn x_3) :=
  by sorry

The theorem `RingHom.comp_apply` states that for any three types `α`, `β`, and `γ` which are all non-associative semirings, and for any two ring homomorphisms (one from `α` to `β` and the other from `β` to `γ`), the composition of these two homomorphisms applied to an element of `α` is equal to applying the second homomorphism to the result of applying the first homomorphism to the element. In other words, if we have two function `hmn : α → β` and `hnp : β → γ` and an element `x_3 : α`, then applying the composed homomorphism `(RingHom.comp hnp hmn)` to `x_3` is the same as first applying `hmn` to `x_3` and then applying `hnp` to the result. This is a formalization of the usual property of function composition in the context of ring homomorphisms.

For any non-associative semirings α, β, and γ, and ring homomorphisms hmn : α → β and hnp : β → γ, (hnp ∘ hmn)(x) = hnp(hmn(x)) for all x ∈ α.


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

The theorem `Set.singleton_nonempty` states that for any type `α` and for any element `a` of type `α`, the singleton set containing `a` is not empty. In other words, it asserts that a set that contains at least one element is indeed nonempty. This serves as a fundamental property of singleton sets in the universe of sets in the type theory.

For any type `α` and element `a` of type `α`, the singleton set `{a : α}` is a nonempty set.


Subtype.mem

/-- See also `Subtype.prop`  -/
theorem Subtype.mem : ∀ {α : Type u_1} {s : Set α} (p : ↑s), ↑p ∈ s := by sorry

The theorem `Subtype.mem` states that for any type `α`, and any set `s` of type `α`, if we take an element `p` from the subtype induced by `s`, then `p` is indeed an element of the set `s`. Basically, this theorem is ensuring that the subtype construction correctly reflects the set membership relation.

Given a type `α` and a subset `s` of `α`, for any `p` in the subtype induced by `s`, we have `p ∈ s`.


theorem abs_sub_le_iff :
    ∀ {α : Type u_1} [inst : LinearOrderedAddCommGroup α] {a b c : α}, |a - b| ≤ c ↔ a - b ≤ c ∧ b - a ≤ c := by sorry

This theorem states that for any type `α` that forms a Linear Ordered Additive Commutative Group, for any three elements `a`, `b`, and `c` of this type, the absolute value of the difference between `a` and `b` is less than or equal to `c` if and only if both the difference `a - b` is less than or equal to `c` and the difference `b - a` is less than or equal to `c`. In mathematical terms, we can express this as: $|a - b| \leq c$ if and only if both $a - b \leq c$ and $b - a \leq c$.

For any type `α` forming a Linear Ordered Additive Commutative Group, $|a-b|\leq c$ if and only if $a-b\leq c$ and $b-a\leq c$.


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

The theorem `Part.map_some` states that for all types `α` and `β`, and for any function `f` from `α` to `β` and any element `a` of type `α`, the operation of mapping `f` over a `Part` that is `some a` (which means a `Part` whose domain is `True` and the function returns value `a`) is equivalent to the `Part` that is `some (f a)`. In simpler terms, applying a function to the value inside the `Part` and then creating a `Part` out of it is the same as first creating a `Part` out of the value and then applying the function to it. This theorem is a formal statement of the property that the map operation of the `Part` type respects the unit of the `Part` monad (which is `Part.some`).

For all types α and β, and for any function f from α to β, the mapping of f over a Part.some a is equivalent to Part.some (f a).


theorem Linarith.lt_of_lt_of_eq : ∀ {α : Type u_1} [inst : OrderedSemiring α] {a b : α}, a < 0 → b = 0 → a + b < 0 := by
  sorry

This theorem states that, for any ordered semiring `α` and any elements `a` and `b` in `α`, if `a` is less than zero and `b` is equal to zero, then the sum of `a` and `b` is less than zero. In other words, in an ordered semiring, adding zero to a negative number results in a negative number.

In an ordered semiring, the sum of a negative number and zero is still a negative number.


theorem Finset.coe_Ioc :
    ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : LocallyFiniteOrder α] (a b : α), ↑(Finset.Ioc a b) = Set.Ioc a b :=
  by sorry

This theorem states that for any type `α` which has a preorder and a locally finite order, and for any two elements `a` and `b` of this type, the set obtained by coercing the finite set of elements greater than `a` and less than or equal to `b` (denoted `Finset.Ioc a b`) is equal to the set of elements in the left-open right-closed interval between `a` and `b` (denoted `Set.Ioc a b`). In other words, the coercion of the finite set interval is the same as the set interval in the given order.

For any type with a preorder and locally finite order, the coercion of the finite set interval between two elements is equal to the set interval.


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

This theorem states that a function `f` from a normed add commutative group `E` to another normed add commutative group `F`, both over a nontrivially normed field `𝕜`, is continuously differentiable up to order `n` everywhere if and only if it is continuously differentiable up to order `n` at every point `x` in `E`. This result essentially means that global and pointwise continuous differentiability are equivalent for such functions.

A function `f` from a normed add commutative group `E` to another normed add commutative group `F` over a nontrivially normed field `𝕜` is continuously differentiable up to order `n` everywhere if and only if it is continuously differentiable up to order `n` at every point `x` in `E`.


theorem AddMonoidHom.map_nsmul :
    ∀ {M : Type u_4} {N : Type u_5} [inst : AddMonoid M] [inst_1 : AddMonoid N] (f : M →+ N) (a : M) (n : ℕ),
      f (n • a) = n • f a :=
  by sorry

This theorem states that for any two types `M` and `N` that are additive monoids, any additive monoid homomorphism `f` from `M` to `N`, any element `a` of `M`, and any natural number `n`, the result of applying `f` to `n` times `a` in `M` is equal to `n` times the result of applying `f` to `a`. In other words, the homomorphism preserves the operation of scalar multiplication by a natural number.

For any additive monoids M and N, any additive monoid homomorphism f from M to N, and any natural number n and element a in M, we have f(na) = n(fa).


/-- A compact subset has finite measure for a measure which is finite on compacts.  -/
theorem IsCompact.measure_lt_top :
    ∀ {α : Type u_1} {m0 : MeasurableSpace α} [inst : TopologicalSpace α] {μ : MeasureTheory.Measure α}
      [inst_1 : MeasureTheory.IsFiniteMeasureOnCompacts μ] ⦃K : Set α⦄, IsCompact K → ↑↑μ K < ⊤ :=
  by sorry

This theorem states that for any given type `α` that is a measurable space and a topological space, and any measure `μ` that is finite on compact subsets, if `K` is a compact subset of `α`, then the measure of `K` under `μ` is less than infinity. In simpler terms, it states that a compact subset always has a finite measure when the measure is finite on compact subsets. This highlights a fundamental property of measures in topological spaces, and is an important result in measure theory.

If `α` is a measurable and topological space, `μ` is a finite measure on compact subsets of `α`, and `K` is a compact subset of `α`, then the measure of `K` under `μ` is finite.


theorem Real.exp_log : ∀ {x : ℝ}, 0 < x → Real.exp (Real.log x) = x := by sorry

The theorem `Real.exp_log` states that for any real number `x` that is greater than zero, the exponential of the logarithm of `x` equals `x` itself. In mathematical notation, this is expressed as ∀x ∈ ℝ, x > 0 → exp(log(x)) = x. In simpler words, it states that the exponential function and the logarithm function are inverses of each other for positive real numbers.

For all real numbers x > 0, exp(log x) = x. (The exponential function and logarithm function are inverses for positive real numbers.)


theorem Finset.card_univ : ∀ {α : Type u_1} [inst : Fintype α], Finset.univ.card = Fintype.card α := by sorry

The theorem `Finset.card_univ` states that for any type `α` that is finite (i.e., it has a `Fintype α` instance), the cardinality (i.e., the number of elements) of the universal finite set `Finset.univ` of this type is equal to the cardinality of the type `α` itself. In other words, the total number of elements in the universal finite set of a certain type is equal to the total number of elements of that type.

For any finite type `α`, the cardinality of `Finset.univ (Fintype.of_size (card α))` equals the cardinality of `α`.


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

The theorem `DFunLike.congr_arg` states that for all types `F`, `α`, and `β`, where `F` is a type that behaves like a function from `α` to `β` (as defined by the `FunLike` class), for any function-like `f` of type `F` and for any two elements `x` and `y` of type `α`, if `x` equals `y`, then the result of applying `f` to `x` equals the result of applying `f` to `y`. This theorem essentially captures the property of a function that equal inputs yield equal outputs.

For any `FunLike F α β`, if `x = y : α`, then `F.app f x = F.app f y : β`.


theorem Int.natAbs_of_nonneg : ∀ {a : ℤ}, 0 ≤ a → ↑(Int.natAbs a) = a := by sorry

This theorem states that for every integer `a`, if `a` is nonnegative (i.e., `a` is greater than or equal to zero), then the absolute value of `a` as a natural number (i.e., `Int.natAbs a`) when converted back to an integer equals to `a` itself. The function `Int.natAbs` is used to find the absolute value of `a` and the upward arrow symbol (`↑`) is used for type coercion, converting the natural number back to an integer.

For every integer `a` greater than or equal to zero, `Int.natAbs a = ↑a`.


theorem OrderIso.map_sup :
    ∀ {α : Type u_2} {β : Type u_3} [inst : SemilatticeSup α] [inst_1 : SemilatticeSup β] (f : α ≃o β) (x y : α),
      f (x ⊔ y) = f x ⊔ f y :=
  by sorry

This theorem states that for any two types `α` and `β` that are both semilattices with a supremum operation (denoted by `⊔`), any order preserving isomorphism `f` between `α` and `β` preserves the supremum operation. That is, applying `f` to the supremum of `x` and `y` (where `x` and `y` are elements of `α`) is the same as taking the supremum of `f(x)` and `f(y)` (where `f(x)` and `f(y)` are elements of `β`).

For any order preserving isomorphism between two semilattices with supremum operation, the image of the supremum of two elements under the isomorphism is equal to the supremum of their images.


theorem Mathlib.Data.Set.Basic._auxLemma.15 : ∀ {α : Type u} (s : Set α), (s ⊆ Set.univ) = True := by sorry

The theorem `Mathlib.Data.Set.Basic._auxLemma.15` in Lean 4 states that for any type `α` and any set `s` of type `α`, the statement that `s` is a subset of the universal set `Set.univ` of type `α` is always true. This is an expression of the basic set-theoretic fact that every set is a subset of the universal set.

Every set is a subset of the universal set.


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

This theorem states that for all elements `a` and `b` of any commutative group `G`, the result of multiplying `a` and `b` together and then dividing by `a` is equal to `b`. In other words, it says that if you multiply any element by another, and then divide the result by the original element, you get back the second element. This is essentially expressing the cancellation law of division in the context of commutative groups.

For all commutative groups G and elements a, b in G, a \* b = b \* a implies a \* (b / a) = b.


LipschitzWith.continuous

/-- A Lipschitz function is continuous.  -/
theorem LipschitzWith.continuous :
    ∀ {α : Type u} {β : Type v} [inst : PseudoEMetricSpace α] [inst_1 : PseudoEMetricSpace β] {K : NNReal} {f : α → β},
      LipschitzWith K f → Continuous f :=
  by sorry

The theorem states that a Lipschitz function is always continuous. More specifically, for any two types `α` and `β` that are equipped with a pseudo emetric space structure, any function `f` from `α` to `β` that is Lipschitz continuous with a nonnegative real number `K`, is also a continuous function. In mathematical terms, if for all `x` and `y` in `α`, the extended distance between `f(x)` and `f(y)` is less than or equal to `K` times the extended distance between `x` and `y`, then `f` is a continuous function.

If a function between two metric spaces is Lipschitz continuous with a finite Lipschitz constant, then it is continuous.


theorem MeasureTheory.integral_undef :
    ∀ {α : Type u_1} {G : Type u_5} [inst : NormedAddCommGroup G] [inst_1 : NormedSpace ℝ G] {m : MeasurableSpace α}
      {μ : MeasureTheory.Measure α} {f : α → G}, ¬MeasureTheory.Integrable f μ → ∫ (a : α), f a ∂μ = 0 :=
  by sorry

The theorem `MeasureTheory.integral_undef` states that for any types `α` and `G`, where `G` is a normed additive commutative group and also a normed space over the real numbers `ℝ`, given a measurable space `m` on `α`, a measure `μ` on this measurable space, and a function `f` from `α` to `G`, if `f` is not integrable with respect to the measure `μ` (i.e., `f` is not measurable or the integral `∫⁻ a, ‖f a‖ ∂μ` is not finite), then the integral of `f` with respect to the measure `μ` is equal to zero. This theorem basically says that the integral of a function that is not integrable is defined to be zero.

If a function from a measurable space to a normed additive commutative group over the real numbers is not integrable with respect to a given measure, then its integral is equal to the zero element of the group.


theorem Set.disjoint_iff_inter_eq_empty : ∀ {α : Type u} {s t : Set α}, Disjoint s t ↔ s ∩ t = ∅ := by sorry

This theorem states that for any type `α` and any two sets `s` and `t` of type `α`, the two sets are disjoint if and only if their intersection is the empty set. Here, two sets are considered disjoint if their infimum (greatest lower bound) is the bottom element. In terms of set theory, the "bottom element" can be understood as the empty set, and the "infimum" of two sets corresponds to their intersection.

For sets `s` and `t` of type `α`, `s` and `t` are disjoint if and only if `s ∩ t = ⊥`, where `⊥` denotes the bottom element.


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

This theorem states that for all natural numbers `n` and `m`, the sum of `n` and the successor of `m` (which is `m + 1`) is equal to the successor of the sum of `n` and `m` (which is `n + m + 1`). In other words, adding `n` to `m + 1` is the same as adding `n + m` to `1`. This property is foundational to the definition of addition in the natural numbers.

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


/-- See `inv_le_inv_of_le` for the implication from right-to-left with one fewer assumption.  -/
theorem inv_le_inv :
    ∀ {α : Type u_2} [inst : LinearOrderedSemifield α] {a b : α}, 0 < a → 0 < b → (a⁻¹ ≤ b⁻¹ ↔ b ≤ a) := by sorry

This theorem, `inv_le_inv`, states that for any linearly ordered semifield `α` and any two elements `a` and `b` of `α` that are greater than zero, the reciprocal of `a` is less than or equal to the reciprocal of `b` if and only if `b` is less than or equal to `a`. This theorem, thus, provides a way to compare the reciprocals of two positive elements from a linearly ordered semifield. The theorem `inv_le_inv_of_le` provides a similar comparison but requires one less assumption.

For any linearly ordered semifield with positive elements `α`, `a` and `b` satisfying `a > 0` and `b > 0`, the condition `a >= b` is equivalent to `1/a <= 1/b`.


theorem AlternatingMap.map_eq_zero_of_eq :
    ∀ {R : Type u_1} [inst : Semiring R] {M : Type u_2} [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {N : Type u_3}
      [inst_3 : AddCommMonoid N] [inst_4 : Module R N] {ι : Type u_7} (f : M [⋀^ι]→ₗ[R] N) (v : ι → M) {i j : ι},
      v i = v j → i ≠ j → f v = 0 :=
  by sorry

This theorem states that for any semiring `R`, if `M` and `N` are both modules over `R`, and `f` is an alternating map from `M` to `N`, then if there exist indices `i` and `j` such that `i` is not equal to `j` and the `i`th and `j`th elements of a function `v` from `ι` to `M` are equal, then applying `f` to `v` yields zero. In other words, an alternating map applied to a function where at least two values are equal (and the indices of these values are not the same) gives zero.

For any semiring `R`, if `f` is an alternating map from a module `M` over `R` to another module `N` over `R`, then applying `f` to any function `v` from an indexed set to `M` with distinct indices `i` and `j` such that `v i = v j`, yields zero.


theorem Units.val_inv_eq_inv_val : ∀ {α : Type u} [inst : DivisionMonoid α] (u : αˣ), ↑u⁻¹ = (↑u)⁻¹ := by sorry

This theorem states that, for all types `α` that are division monoids, the inverse of the unit `u` in `α` is the same as the inverse of the value of `u`. More formally, for every `u` in the units of `α`, the embedding of the inverse of `u` (`↑u⁻¹`) equals the inverse of the embedding of `u` (`(↑u)⁻¹`). Essentially, this means that the operation of taking the inverse commutes with the operation of taking the value of a unit in a division monoid.

For all division monoids `α` and units `u` in `α`, the inverse of `u` equals the inverse of its embedding, i.e., `↑u⁻¹ = (↑u)⁻¹`.


/-- If `M` is finite, `finrank M = rank M`.  -/
theorem finrank_eq_rank :
    ∀ (R : Type u) (M : Type v) [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M]
      [inst_3 : StrongRankCondition R] [inst_4 : Module.Finite R M],
      ↑(FiniteDimensional.finrank R M) = Module.rank R M :=
  by sorry

The theorem `finrank_eq_rank` states that for any ring `R` and any module `M` over `R`, if `M` satisfies the strong rank condition (a certain condition about the rank of submodules) and `M` is finite, then the finite rank of `M` is equal to the rank of `M`. Here, the rank and finite rank of a module are concepts related to its dimension; the rank refers to the size of a maximal linearly independent subset of `M`, while the finite rank is a variant that is defined to be zero for modules of infinite rank.

For any ring `R` and finite module `M` over `R` satisfying the strong rank condition, the rank of `M` equals its finite rank.


theorem Set.iUnion_subset :
    ∀ {α : Type u_1} {ι : Sort u_4} {s : ι → Set α} {t : Set α}, (∀ (i : ι), s i ⊆ t) → ⋃ i, s i ⊆ t := by sorry

This theorem states that for any type `α` and any indexing type `ι`, if you have a family of sets `s` indexed by `ι`, and another set `t` of the same type, then if all sets in the family `s` are subsets of `t`, it follows that the union of all sets in the family `s` is also a subset of `t`. In mathematical terms, given a collection of sets $\{s_i\}_{i \in \iota}$ and a set $t$, if for every $i$ in $\iota$, $s_i \subseteq t$, then $\bigcup_{i} s_i \subseteq t$.

If for each index $i$ in $\iota$, set $s\_i$ is a subset of set $t$, then the union of all sets $s\_i$ is also a subset of $t$. (i.e., $\bigcup\_{i \in \iota} s\_i \subseteq t$).


Bornology.IsBounded.subset

theorem Bornology.IsBounded.subset :
    ∀ {α : Type u_2} {x : Bornology α} {s t : Set α}, Bornology.IsBounded t → s ⊆ t → Bornology.IsBounded s := by sorry

The theorem `Bornology.IsBounded.subset` states that for any type `α` and any bornology `x` on `α`, if `t` is a bounded set within this bornology, and `s` is a subset of `t`, then `s` is also bounded within the bornology. In other words, the property of being bounded is preserved under taking subsets.

If `α` is a type, `x` is a bornology on `α`, `t` is a bounded set in `x`, and `s` is a subset of `t`, then `s` is a bounded set in `x`.


theorem MeasureTheory.stronglyMeasurable_const :
    ∀ {α : Type u_5} {β : Type u_6} {x : MeasurableSpace α} [inst : TopologicalSpace β] {b : β},
      MeasureTheory.StronglyMeasurable fun x => b :=
  by sorry

The theorem `MeasureTheory.stronglyMeasurable_const` states that for any type `α` equipped with a measurable space structure `x`, any type `β` equipped with a topological space structure, and any element `b` of type `β`, the constant function that maps each element of type `α` to `b` is strongly measurable. Here, a function is considered strongly measurable if it is the limit of a sequence of simple functions.

For any measurable spaces (α, x) and (β, τ), and any topological space (β), the constant function from α to β, sending all elements to a fixed element b, is strongly measurable.


theorem Set.mem_iUnion₂ :
    ∀ {γ : Type u_3} {ι : Sort u_4} {κ : ι → Sort u_7} {x : γ} {s : (i : ι) → κ i → Set γ},
      x ∈ ⋃ i, ⋃ j, s i j ↔ ∃ i j, x ∈ s i j :=
  by sorry

This theorem states that for any type `γ`, any index type `ι`, any dependent type `κ` indexed by `ι`, any element `x` of type `γ`, and any family of sets `s` indexed by `ι` and `κ`, the element `x` belongs to the double union over `ι` and `κ` of the sets `s i j` if and only if there exist indices `i` and `j` such that `x` belongs to the set `s i j`. In other words, an element is in the union of multiple sets if it is in at least one of the sets.

Given types `γ`, index type `ι`, a dependent type `κ` indexed by `ι`, an element `x` of type `γ`, and a family of sets `s : ι → κ → Sort_, an element `x` is in the double union `⨄ i, j, s i j` if and only if there exist `i` and `j` such that `x` is in `s i j`.


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

This theorem states that for any type `α` and another type `M` equipped with a zero, if we construct a finitely supported function (also known as a `Finsupp`) that gives each element of type `α` the value zero, the result is equivalent to the zero finitely supported function. In other words, every singleton `Finsupp` that maps an element to zero is the zero `Finsupp`.

For any type `α` and any finitely supported function `f : α →₀ ℤ`, the singleton function mapping an element `x : α` to zero `0 : ℤ` is equal to the zero finitely supported function `0 : α →₀ ℤ`.


theorem smul_eq_zero :
    ∀ {R : Type u_2} {M : Type u_5} [inst : Zero R] [inst_1 : Zero M] [inst_2 : SMulWithZero R M]
      [inst_3 : NoZeroSMulDivisors R M] {c : R} {x : M}, c • x = 0 ↔ c = 0 ∨ x = 0 :=
  by sorry

The theorem `smul_eq_zero` states that for any types `R` and `M`, where `R` is a zero element type and `M` is also a zero element type, and `R` and `M` have scalar multiplication with zero, and there are no zero scalar multiplication divisors in `R` and `M`, if we have a scalar `c` of type `R` and a vector `x` of type `M`, then the scalar multiplication of `c` and `x` equals zero if and only if `c` equals zero or `x` equals zero. In other words, it provides a condition for scalar multiplication to result in a zero element in the context of scalar multiplication with zero.

For types `R` and `M` with scalar multiplication by zero and no zero divisors, the scalar multiplication of a zero scalar `c` in `R` and a vector `x` in `M` equals zero if and only if both `c` and `x` are zero.


theorem CategoryTheory.Limits.Sigma.hom_ext :
    ∀ {β : Type w} {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {f : β → C}
      [inst_1 : CategoryTheory.Limits.HasCoproduct f] {X : C} (g₁ g₂ : ∐ f ⟶ X),
      (∀ (b : β),
          CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.Sigma.ι f b) g₁ =
            CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.Sigma.ι f b) g₂) →
        g₁ = g₂ :=
  by sorry

This theorem, `CategoryTheory.Limits.Sigma.hom_ext`, states the following in the language of category theory:

Given a category `C`, a function `f` from some type `β` to objects of `C`, and an object `X` in `C`, if `f` has coproduct (denoted as `∐ f`) in the category `C`, then for any two morphisms `g₁` and `g₂` from the coproduct `∐ f` to `X`, if for every `b` in `β`, the composition of the `b`-th inclusion morphism from `f b` to `∐ f` and `g₁` equals the composition of the `b`-th inclusion morphism and `g₂`, then `g₁` equals `g₂`.

In simpler terms, it asserts the uniqueness of morphisms from the coproduct to another object, given certain conditions. If two morphisms coincide when composed with the inclusion morphisms into the coproduct for every element in the domain of `f`, then those two morphisms are equal.

Given a functor `f : C → C` from a category `C` with a coproduct `∐ f`, if for all objects `b` in the domain of `f` and morphisms `g₁, g₂ : ∐ f → X`, `g₁ ∘ i_b = g₂ ∘ i_b` implies `g₁ = g₂`, then `∐ f` has a unique coproduct morphism to `X`.


MeasurableSet.union

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

The theorem `MeasurableSet.union` states that for any type `α`, given a measurable space `m` over `α`, and two sets `s₁` and `s₂` of type `α`, if both `s₁` and `s₂` are measurable sets in the given measurable space, then the union of `s₁` and `s₂` is also a measurable set in the same measurable space. This means that measurability is preserved under the set union operation.

For any measurable space `m` over type `α`, if `s₁` and `s₂` are measurable sets in `m`, then their union `s₁ ∪ s₂` is also a measurable set in `m`.


theorem Submodule.add_mem :
    ∀ {R : Type u} {M : Type v} [inst : Semiring R] [inst_1 : AddCommMonoid M] {module_M : Module R M}
      (p : Submodule R M) {x y : M}, x ∈ p → y ∈ p → x + y ∈ p :=
  by sorry

This theorem, `Submodule.add_mem`, states that for any semiring `R` and any additively commutative monoid `M` that is also a module over `R`, and any submodule `p` of `M`, if `x` and `y` are elements of `p`, then their sum `x + y` is also in `p`. Essentially, this theorem guarantees that the sum of any two elements in a submodule remains within that submodule.

For any semiring R, additively commutative monoid M being an R-module, and submodule p of M, if x, y ∈ p then x + y ∈ p.


theorem List.not_mem_nil : ∀ {α : Type u_1} (a : α), a ∉ [] := by sorry

This theorem states that for any type `α` and any element `a` of type `α`, `a` is not in the empty list. In other words, no matter what type and element we have, it cannot be a member of an empty list. This is a general property of the empty list.

For any type `α` and any element `a`: `a ∉ [] : Prop` (In other words, no element is in the empty list.)


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

This theorem states that for any two types `α` and `β` and for any equivalence relation `e` between them, the composition of the inverse of `e` (`e.symm`) and `e` itself is the identity function. In other words, applying `e` and then its inverse `e.symm` to any element results in the original element. This is a formal statement of the property that an operation followed by its inverse results in no change, which is a fundamental property of all inverse operations.

For any equivalence relation `e` on types `α` and `β`, `e.symm ∘ e = id`.


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

This theorem states that for any two non-negative real numbers `r` and `q`, the inequality `r < q` holds if and only if the same inequality holds after applying the coercion operation to `r` and `q` (denoted by `↑r < ↑q`). In other words, the ordering between `r` and `q` is preserved under the coercion from non-negative real numbers to extended non-negative real numbers.

For any non-negative real numbers `r` and `q`, `r < q` if and only if `↑r < ↑q`.


theorem deriv_zero_of_not_differentiableAt :
    ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {F : Type v} [inst_1 : NormedAddCommGroup F]
      [inst_2 : NormedSpace 𝕜 F] {f : 𝕜 → F} {x : 𝕜}, ¬DifferentiableAt 𝕜 f x → deriv f x = 0 :=
  by sorry

The theorem `deriv_zero_of_not_differentiableAt` states that for any point `x` in the domain of a function `f` from the field `𝕜` to a normed additively commutative group `F`, if `f` is not differentiable at `x`, then the derivative of `f` at `x` is zero. In other words, for all `f : 𝕜 → F` and `x : 𝕜`, if `f` does not admit a derivative at `x`, then the value of the derivative function `deriv f` at `x` equals zero.

If a function `f` from a field to a normed additively commutative group is not differentiable at a point `x`, then its derivative at `x` is zero.


IsFractionRing.injective

theorem IsFractionRing.injective :
    ∀ (R : Type u_1) [inst : CommRing R] (K : Type u_5) [inst_1 : CommRing K] [inst_2 : Algebra R K]
      [inst_3 : IsFractionRing R K], Function.Injective ⇑(algebraMap R K) :=
  by sorry

The theorem `IsFractionRing.injective` states that for any integral domain `R` with a commutative ring structure, and any field of fractions `K` of `R` which also has a commutative ring structure and an algebra structure over `R`, the algebra map that embeds `R` into `K` is injective. In other words, if `R` is mapped to `K` via the algebra map and two elements in `R` have the same image, then those two elements must be the same. This means that no information is lost when `R` is embedded into its field of fractions `K` using the algebra map.

The algebra map embedding an integral domain `R` into its field of fractions `K` as an algebra over `R` is a injective ring homomorphism.


Setoid.symm

theorem Setoid.symm : ∀ {α : Sort u} [inst : Setoid α] {a b : α}, a ≈ b → b ≈ a := by sorry

This theorem, `Setoid.symm`, states that for any sort `α` that has a `Setoid` instance, if `a` and `b` are elements in `α` and `a` is equivalent to `b`, then `b` is equivalent to `a`. In other words, the equivalence relation (`≈`) in a Setoid is symmetric.

For any Setoid `α`, if `a ≈ b` then `b ≈ a`.


theorem Metric.ball_subset_closedBall :
    ∀ {α : Type u} [inst : PseudoMetricSpace α] {x : α} {ε : ℝ}, Metric.ball x ε ⊆ Metric.closedBall x ε := by sorry

This theorem states that for any pseudometric space (a generalization of the metric space concept that allows for points at zero distance from each other), and any point and real number in this space, the open ball centered at this point with radius equal to this real number is a subset of the closed ball centered at the same point with the same radius. In simpler terms, the set of all points with a distance less than a certain value from a given point is always contained within the set of all points with a distance less than or equal to that same value from the given point.

For any pseudometric space and point, the open ball is a subset of the closed ball with the same center and radius.


theorem Function.update_eq_self :
    ∀ {α : Sort u} {β : α → Sort v} [inst : DecidableEq α] (a : α) (f : (a : α) → β a), Function.update f a (f a) = f :=
  by sorry

This theorem, `Function.update_eq_self`, states that for any type `α` that has a decidable equality and a dependent type `β`, for any element `a` of type `α` and any function `f` from `α` to `β`, if we update the function `f` at the point `a` with its own value `f(a)`, we get the same function `f` back. In other words, replacing the value of a function at a certain point by the value that was already there doesn't change the function.

For any type `α` with decidable equality and any function `f` from `α` to a type `β`, `Function.update f a (f a) = f`.


theorem Complex.ofReal_cos : ∀ (x : ℝ), ↑(Real.cos x) = Complex.cos ↑x := by sorry

This theorem states that for all real numbers `x`, the complex number obtained by considering `Real.cos x` as a complex number is equal to the value of the complex cosine function evaluated at `x` considered as a complex number. In other words, when a real number is put into the real cosine function and then converted into a complex number, it gives the same result as if the real number was directly put into the complex cosine function.

The real and complex cosine functions agree for real arguments: for all `x` in `ℝ`, `Complex.cos (convert x toComplex) = Real.cos x`.


/-- **Alias** of the forward direction of `Filter.tendsto_iff_comap`. -/
theorem Filter.Tendsto.le_comap :
    ∀ {α : Type u} {β : Type v} {f : α → β} {l₁ : Filter α} {l₂ : Filter β},
      Filter.Tendsto f l₁ l₂ → l₁ ≤ Filter.comap f l₂ :=
  by sorry

The theorem `Filter.Tendsto.le_comap` is an alias for the forward direction of `Filter.tendsto_iff_comap`. This theorem states that for every type `α` and `β`, given a function `f` from `α` to `β`, and given two filters `l₁` over `α` and `l₂` over `β`, if `f` tends towards `l₂` as `l₁` approaches (as stated by `Filter.Tendsto f l₁ l₂`), then `l₁` is less than or equal to the filter `l₂` pre-composed with `f` (as stated by `l₁ ≤ Filter.comap f l₂`). Essentially, this means that any neighborhood in `l₁` is mapped into a neighborhood in `l₂` under the function `f`.

If a function `f` tends towards a filter `l₂` as a filter `l₁` approaches, then `l₁` is contained in the filter obtained by pre-composing `l₂` with `f`.


theorem Linarith.eq_of_not_lt_of_not_gt : ∀ {α : Type u_1} [inst : LinearOrder α] (a b : α), ¬a < b → ¬b < a → a = b :=
  by sorry

This theorem, `Linarith.eq_of_not_lt_of_not_gt`, states that for any type `α` that has a linear ordering, given any two elements `a` and `b` of type `α`, if `a` is not less than `b` and `b` is not less than `a`, then `a` must be equal to `b`. This is a basic property of total orderings, where two elements are either equal or one is less than the other.

If `α` is a linedarly ordered type and `a` and `b` are elements of `α` with `a >= b` and `b >= a`, then `a = b`.


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

This theorem states that for any type `α` that has a `Preorder` relation (a relation that is reflexive and transitive), and for any elements `a`, `b`, and `x` of this type, `x` is in the left-open right-closed interval from `a` to `b` if and only if `x` is strictly greater than `a` and less than or equal to `b`. In mathematical terms, it verifies that `x` belongs to the interval `(a, b]` precisely when `a < x ≤ b`.

For any type `α` with a `Preorder` relation, an element `x` lies in the left-open right-closed interval `(a, b]` if and only if `a < x <= b`.


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

This theorem, `not_not_intro`, states that for any given proposition `p`, if `p` is true, then it is not the case that `p` is not true. In other words, it asserts the principle of double negation: if you have a proposition `p`, and `p` is true, then you cannot assert that it is not untrue. This is a fundamental concept in logic and proof theory.

For all propositions p, p && ∼∼p. (In Lean syntax: `not_not p`)


theorem Complex.ofReal_inj : ∀ {z w : ℝ}, ↑z = ↑w ↔ z = w := by sorry

This theorem states that for any two real numbers `z` and `w`, the complex number that `z` is converted to (`↑z`) is equal to the complex number that `w` is converted to (`↑w`) if and only if `z` is equal to `w`. In other words, the function that maps real numbers to complex numbers is injective, which means that different real numbers will be mapped to different complex numbers.

The complex conversion function `↑` is injective on the real numbers, that is, for all real numbers `z` and `w`, `↑z = ↑w` implies `z = w`.


theorem Real.toNNReal_coe : ∀ {r : NNReal}, Real.toNNReal ↑r = r := by sorry

This theorem states that for every non-negative real number `r`, when we apply the function `Real.toNNReal` to `r` (after it has been coerced to a real number), we get back `r` itself. This essentially means that converting a non-negative real number to a real and then reinterpreting it back to a non-negative real number does not change the initial number.

For every non-negative real number `r`, `Real.toNNReal (real.coerce r) = r`.


/-- Extract the equation from a morphism in a discrete category.  -/
theorem CategoryTheory.Discrete.eq_of_hom : ∀ {α : Type u₁} {X Y : CategoryTheory.Discrete α}, (X ⟶ Y) → X.as = Y.as :=
  by sorry

The theorem `CategoryTheory.Discrete.eq_of_hom` states that for any type `α` and any two objects `X` and `Y` in a discrete category of `α`, if there exists a morphism from `X` to `Y`, then `X.as` must be equal to `Y.as`. In other words, in a discrete category, if there's a morphism between two objects, those objects must be the same.

In a discrete category, if there exists a morphism between objects X and Y, then X = Y.


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

This theorem, `inf_sup_left`, states that for any distributive lattice of type `α`, the supremum (join operation) of two elements `b` and `c`, when infimum (meet operation) with another element `a`, distributes over the infimum operation. In other words, `a` meet (`b` join `c`) is equal to (`a` meet `b`) join (`a` meet `c`). This is a property of lattice theory in mathematics, symbolically represented as `a ⊓ (b ⊔ c) = a ⊓ b ⊔ a ⊓ c`.

In a distributive lattice, the meet of an element with the join of two other elements is equal to the meet of each element with the join of those two elements. (a ⊓ (b ⊔ c) = a ⊓ b ⊔ a ⊓ c)


AddCommGroupCat.ext

theorem AddCommGroupCat.ext : ∀ {X Y : AddCommGroupCat} {f g : X ⟶ Y}, (∀ (x : ↑X), f x = g x) → f = g := by sorry

This theorem states that for any two objects `X` and `Y` in the category of additive commutative groups (`AddCommGroupCat`), if there are two morphisms `f` and `g` from `X` to `Y`, and for all elements `x` in `X`, `f(x)` is equal to `g(x)`, then the morphisms `f` and `g` are equal. In other words, it says that two morphisms between additive commutative groups are equal if they agree on all elements of the source group.

In the category of additive commutative groups, if two morphisms between objects agree on all elements of the source group, then they are equal.


theorem nhds_induced :
    ∀ {α : Type u} {β : Type v} [T : TopologicalSpace α] (f : β → α) (a : β), nhds a = Filter.comap f (nhds (f a)) := by
  sorry

The theorem `nhds_induced` states that for any types `α` and `β`, given a topological space `T` on `α`, a function `f` from `β` to `α`, and an element `a` of `β`, the neighborhood filter of `a` is equal to the preimage (under the function `f`) of the neighborhood filter of `f(a)`. In other words, the local properties around `a` in the space `β` (as described by the neighborhood filter) are exactly those that come from the local properties around `f(a)` in the space `α`, as described by the neighborhood filter of `f(a)`, mapped back via the function `f`.

For any topological spaces T on α and β, function f from β to α, and element a of β, the neighborhood filter of a in β is equal to the preimage under f of the neighborhood filter of f(a) in α.


/-- A variant of `range_coe`. Try to use `range_coe` if possible.
This version is useful when defining a new type that is defined as the subtype of something.
In that case, the coercion doesn't fire anymore.  -/
theorem Subtype.range_val : ∀ {α : Type u_1} {s : Set α}, Set.range Subtype.val = s := by sorry

This theorem, named `Subtype.range_val`, states that for any type `α` and any set `s` of that type, the range of the `Subtype.val` function is equal to `s`. The `Subtype.val` function retrieves the underlying base element from a subtype. This variant is particularly useful when defining a new type as a subtype of something else, in which case the usual coercion mechanism may not work as expected. The more general version `range_coe` should be used when possible, but this version is available for those special cases.

For any type `α` and set `s` of that type, the image of `s` under the `Subtype.val` function is equal to `s`.


theorem Metric.isOpen_ball : ∀ {α : Type u} [inst : PseudoMetricSpace α] {x : α} {ε : ℝ}, IsOpen (Metric.ball x ε) := by
  sorry

The theorem `Metric.isOpen_ball` states that for any type `α` that is a pseudometric space, and for any point `x` in `α` and any real number `ε`, the metric ball centered at `x` with radius `ε` is an open set in the topological space of `α`. In mathematical terms, this is saying that the set of all points `y` such that the distance between `y` and `x` is less than `ε` is an open set. This is a fundamental property of metric spaces in topology.

In a pseudometric space, the metric ball centered at a point is an open set.


theorem CategoryTheory.Limits.IsZero.eq_of_tgt :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C},
      CategoryTheory.Limits.IsZero X → ∀ (f g : Y ⟶ X), f = g :=
  by sorry

This theorem states that for any category `C` and any objects `X` and `Y` in this category, if `X` is a zero object in the category, then any two morphisms `f` and `g` from `Y` to `X` are equal. Here, a zero object in a category is an object that is both an initial object and a terminal object, i.e., it has a unique morphism to every object and a unique morphism from every object.

In any category, if an object is both initial and terminal, then any two morphisms from any object to it are equal.


Homeomorph.isOpenMap

theorem Homeomorph.isOpenMap :
    ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] (h : X ≃ₜ Y),
      IsOpenMap ⇑h :=
  by sorry

The theorem `Homeomorph.isOpenMap` states that for any two types `X` and `Y` equipped with topological spaces, if there exists a homeomorphism `h` from `X` to `Y`, then the function `h` is an open map. In other words, for any open set `U` in `X`, its image under `h` will also be an open set in `Y`. A homeomorphism is a bijective function that is continuous, and its inverse is also continuous. An open map, as defined in the preamble, is a function for which the image of any open set is also an open set.

Given types equipped with topological spaces `X` and `Y`, if there exists a homeomorphism `h` from `X` to `Y`, then `h` maps open sets in `X` to open sets in `Y`.


theorem Finset.cons_induction_on :
    ∀ {α : Type u_4} {p : Finset α → Prop} (s : Finset α),
      p ∅ → (∀ ⦃a : α⦄ {s : Finset α} (h : a ∉ s), p s → p (Finset.cons a s h)) → p s :=
  by sorry

The theorem `Finset.cons_induction_on` specifies a scheme for mathematical induction on finite sets. For any type `α`, if we have a property `p` that holds for the empty set, and if the property is such that whenever it holds for any set `s` and some element `a` not in `s`, it also holds for the set obtained by adding `a` to `s`, then `p` holds for all finite sets of type `α`. This is a kind of structural induction where the inductive step involves adding an element to the set.

If a property `p` holds for the empty set `∅` of type `α` and satisfies `p(s : set α) ∧ a ∉ s → p(s ∪ {a})`, then `p` holds for all finite sets `s` of type `α`.


theorem MeasureTheory.Measure.dirac_apply' :
    ∀ {α : Type u_1} [inst : MeasurableSpace α] {s : Set α} (a : α),
      MeasurableSet s → ↑↑(MeasureTheory.Measure.dirac a) s = Set.indicator s 1 a :=
  by sorry

This theorem states that for any measurable space `α`, any set `s` of type `α`, and any element `a` of type `α`, if `s` is a measurable set, then the measure of set `s` under the Dirac measure centered at `a` is equal to the indicator function of set `s` evaluated at `a` with the function mapping each element to one. In simpler terms, if we have a set `s` in a measurable space, the Dirac measure of `s` at a point `a` is 1 if `a` is in the set `s` and 0 otherwise.

For any measurable space `α`, any measurable set `s` of type `α`, and any point `a` in `α`, the Dirac measure of `s` at `a` equals the indicator function of `s` evaluated at `a`.


Submonoid.ext

/-- Two submonoids are equal if they have the same elements.  -/
theorem Submonoid.ext :
    ∀ {M : Type u_1} [inst : MulOneClass M] {S T : Submonoid M}, (∀ (x : M), x ∈ S ↔ x ∈ T) → S = T := by sorry

This theorem states that for any given type `M` that has a multiplication and identity operation (i.e., `M` is a mul-one-class), two submonoids `S` and `T` of `M` are equal if every element `x` of `M` belongs to `S` if and only if `x` belongs to `T`. In other words, if the same elements from `M` belong to both `S` and `T`, then `S` and `T` are considered the same submonoid.

Two submonoids of a type `M` with multiplication and identity operations are equal if and only if they contain the same elements of `M`.


theorem Mathlib.Data.Finset.Basic._auxLemma.2 : ∀ {α : Type u_1} {a : α} {s : Finset α}, (a ∈ s.val) = (a ∈ s) := by
  sorry

This theorem, named `_auxLemma.2` in the module `Mathlib.Data.Finset.Basic`, states that for any type `α`, any element `a` of type `α`, and any finite set `s` of elements of type `α`, the element `a` is in the underlying value (`s.val`) of the finite set `s` if and only if the element `a` is in the finite set `s` itself. This asserts the equivalence between the membership in the set and the membership in its underlying value.

For any type α, any element a of α, and any finite set s of elements of α, the element a is in set s if and only if a is in the underlying value s.val of s.


theorem Complex.ext_iff : ∀ {z w : ℂ}, z = w ↔ z.re = w.re ∧ z.im = w.im := by sorry

This theorem states that for any two complex numbers `z` and `w`, `z` is equal to `w` if and only if the real part of `z` (`z.re`) is equal to the real part of `w` (`w.re`) and the imaginary part of `z` (`z.im`) is equal to the imaginary part of `w` (`w.im`). In other words, two complex numbers are identical when both their real and imaginary components match.

Two complex numbers are equal if and only if their real and imaginary parts are equal respectively.


Filter.EventuallyEq.rfl

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

The Lean theorem `Filter.EventuallyEq.rfl` states that, for any type `α` and `β`, any filter `l` on type `α`, and any function `f` from `α` to `β`, `f` is eventually equal to itself with respect to the filter `l`. In other words, at some point and thereafter, every value f(x) equals f(x). This theorem is a reflection of the reflexivity property in the context of filters and functions.

For any filter `l` on type `α` and function `f` from `α` to `β`, there exists an index `n` such that for all `i ≥ n`, `f(l.at i) = f(l.at i)`. Here, `l.at i` represents the element in `α` that `l` selects at index `i`.


theorem mul_lt_mul_of_pos_left :
    ∀ {α : Type u_1} {a b c : α} [inst : Mul α] [inst_1 : Zero α] [inst_2 : Preorder α] [inst_3 : PosMulStrictMono α],
      b < c → 0 < a → a * b < a * c :=
  by sorry

The theorem `mul_lt_mul_of_pos_left` states that for any type `α` that has multiplication (`Mul α`), zero element (`Zero α`), a preorder structure (`Preorder α`) and obeys the principle of strict monotonicity of multiplication by positive elements on the left (`PosMulStrictMono α`), if `b` is less than `c` and `a` is positive, then the product of `a` and `b` is strictly less than the product of `a` and `c`. In other words, if `b < c` and `0 < a`, then `a * b < a * c`. This is a property of ordered rings where the multiplication of a smaller number with a positive number results in a smaller product.

If `α` is an ordered ring with multiplication, zero, preorder, and strict monotonicity of multiplication by positive elements on the left, then for any positive `a` and `b` with `b` less than `c`, `a * b` is strictly less than `a * c`.


theorem Int.zero_mul : ∀ (a : ℤ), 0 * a = 0 := by sorry

This theorem states that for any integer 'a', the product of 0 and 'a' is always 0. It's a formal expression of the well-known mathematical rule that multiplying any number by zero results in zero.


theorem Real.sin_neg : ∀ (x : ℝ), Real.sin (-x) = -Real.sin x := by sorry

The theorem `Real.sin_neg` states that the sine function in real numbers, `Real.sin`, is an odd function. That is, for any real number `x`, the sine of the negative of `x` (i.e., `-x`) is equal to the negative of the sine of `x` (i.e., `-Real.sin x`). This is a common property of the sine function in mathematics and is often written as: sin(-x) = -sin(x).

The sine function is an odd function, i.e., sin(-x) = -sin(x) for all real numbers x.


theorem Complex.ofReal_pow : ∀ (r : ℝ) (n : ℕ), ↑(r ^ n) = ↑r ^ n := by sorry

This theorem states that for any real number `r` and any natural number `n`, the complex number obtained by taking `r` to the power of `n` and then casting to a complex number is equal to the complex number obtained by first casting `r` to a complex number and then taking it to the power of `n`. That is, the process of exponentiation and the process of casting real numbers to complex numbers commute with each other. In mathematical notation, this can be written as `(r ^ n) = r ^ n` for all real numbers `r` and all natural numbers `n`, where `^` denotes exponentiation and `(·)` denotes the complex conjugate.

For all real numbers `r` and natural numbers `n`, the result of raising `r` to the power `n` as a complex number is equal to the result of first casting `r` to a complex number and then raising it to the power `n`. In other words, the operations of exponentiation and casting real numbers to complex numbers commute.


theorem add_halves : ∀ {α : Type u_2} [inst : LinearOrderedSemifield α] (a : α), a / 2 + a / 2 = a := by sorry

This theorem, named "add_halves", states that for any type `α` which is a Linear Ordered Semifield (a structure which is both a linearly ordered ring and a commutative division algebra), the sum of half of a given element `a` and half of the same element `a` is equal to `a` itself. Formally, for all `a` in `α`, `a / 2 + a / 2 = a`. This is essentially a formal statement of the intuitive mathematical fact that halving a number and then adding the two halves gives you the original number.

For all elements `a` in a Linear Ordered Semifield `α`, `a / 2 + a / 2 = a`.


/-- Ring homomorphisms preserve additive inverse.  -/
theorem RingHom.map_neg :
    ∀ {α : Type u_2} {β : Type u_3} [inst : NonAssocRing α] [inst_1 : NonAssocRing β] (f : α →+* β) (x : α),
      f (-x) = -f x :=
  by sorry

The theorem `RingHom.map_neg` states that for any two types `α` and `β`, if they are both non-associative rings (indicated by `NonAssocRing α` and `NonAssocRing β`), then for a ring homomorphism `f` from `α` to `β` and any element `x` of `α`, the ring homomorphism of the additive inverse of `x` (-x) is equal to the additive inverse of the ring homomorphism of `x` (-f x). In simpler terms, ring homomorphisms preserve the property of additive inverses.

For any non-associative rings α and β and ring homomorphism f : α → β, we have -(f(x)) = f(-x) for all x ∈ α.


theorem Set.image2_subset_iff :
    ∀ {α : Type u_1} {β : Type u_3} {γ : Type u_5} {f : α → β → γ} {s : Set α} {t : Set β} {u : Set γ},
      Set.image2 f s t ⊆ u ↔ ∀ x ∈ s, ∀ y ∈ t, f x y ∈ u :=
  by sorry

The theorem `Set.image2_subset_iff` states that for all types `α`, `β`, `γ`, a binary function `f : α → β → γ`, and sets `s : Set α`, `t : Set β`, and `u : Set γ`, the image of the function `f` applied to the elements of sets `s` and `t` is a subset of set `u` if and only if for every element `x` in set `s` and for every element `y` in set `t`, the result of the function `f` applied to `x` and `y` is an element of set `u`. In mathematical terms, this theorem states that the image of a binary function mapped across two sets is a subset of another set if and only if every possible output of the function on elements of the two sets is an element of the third set.

For sets \(s : Set \alpha, t : Set \beta, u : Set \gamma, f : \alpha \rightarrow \beta \rightarrow \gamma\), \(f(s) \subseteq u\) if and only if for all \(x : \alpha \in s\) and \(y : \beta\), \(f(x, y) \in u\).


theorem Ideal.mul_mem_right : ∀ {α : Type u} {a : α} (b : α) [inst : CommSemiring α] (I : Ideal α), a ∈ I → a * b ∈ I :=
  by sorry

The theorem `Ideal.mul_mem_right` states that for all types `α`, elements `a` and `b` of `α`, and for a commutative semiring over `α`, if an ideal `I` of the semiring contains the element `a`, then the multiplication of `a` and `b` would also be contained in the ideal `I`. In mathematical terms, if `a` is an element of an ideal `I` in a commutative semiring, then for any element `b`, the product `a * b` is also in `I`.

If `a` belongs to an ideal `I` in a commutative semiring, then for all `b`, the product `a * b` is also in `I`.


Continuous.fst'

/-- Precomposing `f` with `Prod.fst` is continuous  -/
theorem Continuous.fst' :
    ∀ {X : Type u} {Y : Type v} {Z : Type u_1} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y]
      [inst_2 : TopologicalSpace Z] {f : X → Z}, Continuous f → Continuous fun x => f x.1 :=
  by sorry

The theorem `Continuous.fst'` states that, for any three types `X`, `Y`, and `Z` equipped with a topological space structure, and for any function `f` from `X` to `Z`, if `f` is continuous then the function obtained by precomposing `f` with the first projection function (`Prod.fst`) is also continuous. In other words, if `f` is a continuous function, then applying `f` to the first element of a pair of values (an element of the product type `X × Y`) results in a continuous function.

If `f : X → Z` is continuous and `X` is a topological space, then the composed function `f ∘ Prod.fst : X × Y → Z` is continuous.


/-- Adding a group element then subtracting the original point
produces that group element.  -/
theorem vadd_vsub :
    ∀ {G : Type u_1} {P : Type u_2} [inst : AddGroup G] [T : AddTorsor G P] (g : G) (p : P), g +ᵥ p -ᵥ p = g := by sorry

This theorem states that for any group `G`, point `P` (with `G` acting on `P` in an additive manner), group element `g` in `G`, and point `p` in `P`, if you add `g` to `p` and then subtract `p`, the result will be `g`. This is analogous to the rule in ordinary arithmetic that (a + b) - b = a.

For any group `G` acting additively on a set `P`, and for all `g` in `G` and `p` in `P`, the group operation satisfies `g + p - p = g`.


theorem Set.subsingleton_singleton : ∀ {α : Type u} {a : α}, Set.Subsingleton {a} := by sorry

The theorem `Set.subsingleton_singleton` states that for any type `α` and any element `a` of that type, the set containing only `a` is a `Subsingleton` set. In other words, a set that contains a single element is a `Subsingleton` set, meaning it has at most one element, which in this case is `a`.

For any type `α` and element `a` in `α`, the singleton set `{a}` is a `Subsingleton` set.


theorem Equiv.Perm.mem_support :
    ∀ {α : Type u_1} [inst : DecidableEq α] [inst_1 : Fintype α] {f : Equiv.Perm α} {x : α},
      x ∈ Equiv.Perm.support f ↔ f x ≠ x :=
  by sorry

The theorem `Equiv.Perm.mem_support` states that for any type `α` with decidable equality and finite number of elements, and for any permutation `f` on `α` and any element `x` of `α`, the element `x` is in the support of the permutation `f` if and only if `f` of `x` is not equal to `x`. In other words, the support of a permutation is the set of all elements that are not fixed by the permutation.

For any finite type `α` with decidable equality, a permutation `f` on `α` fixes an element `x` if and only if `x` is not in the support of `f`.


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

This theorem states that for any function `f` from an arbitrary type `α` to another arbitrary type `β`, and for any set `s` of elements of type `β`, the image under `f` of the preimage of `s` under `f` is a subset of `s`. In other words, if you take a set `s`, consider the set of all elements that get mapped into `s` by `f`, and then apply `f` to that set, you obtain a set that is contained within `s`. This is a fundamental property of the concept of a function's image and preimage.

For any function `f` from type `α` to type `β`, and any set `s` in type `β`, the image of `f` of the preimage of `s` is contained in `s`: `image (f : α → β) (preimage s : Set α) ⊆ s`.


theorem Cardinal.lift_inj : ∀ {a b : Cardinal.{u}}, Cardinal.lift.{v, u} a = Cardinal.lift.{v, u} b ↔ a = b := by sorry

This theorem, named `Cardinal.lift_inj`, states that for any two cardinals 'a' and 'b' in a certain universe 'u', the lifting of 'a' and 'b' to a potentially larger universe 'v' are equal if and only if 'a' and 'b' themselves are equal. In other words, the lift operation on cardinals is injective, meaning it preserves distinctness: distinct cardinals in the original universe remain distinct when lifted.

For any cardinals 'a' and 'b' in universe 'u', if the lift of 'a' to universe 'v' equals the lift of 'b' to 'v', then 'a' = 'b'.


theorem norm_norm : ∀ {α : Type u_1} [inst : SeminormedAddCommGroup α] (x : α), ‖‖x‖‖ = ‖x‖ := by sorry

This theorem states that for all elements `x` of a given type `α`, where `α` is a seminormed add commutative group, the norm of the norm of `x` is equal to the norm of `x`. In mathematical terms, this is stating that for any `x` in our group, ||||x|||| = ||x||. This theorem is essentially saying that applying the norm function twice doesn't change the result; the norm of `x` is the same whether you calculate it once or twice.

The norm of an element in a seminormed add commutative group is equal to the square of its norm.


theorem Int.eq_ofNat_of_zero_le : ∀ {a : ℤ}, 0 ≤ a → ∃ n, a = ↑n := by sorry

This theorem states that for any integer 'a', if 'a' is greater than or equal to zero, then there exists a natural number 'n' such that 'a' is equal to the integer representation of 'n'. In other words, any non-negative integer can be expressed as the integer representation of some natural number.

For any non-negative integer `a`, there exists a natural number `n` such that `a = Nat.toInt n`.


theorem Fin.succ_pred : ∀ {n : ℕ} (i : Fin (n + 1)) (h : i ≠ 0), Fin.succ (Fin.pred i h) = i := by sorry

The theorem `Fin.succ_pred` asserts that for any natural number `n` and any nonzero element `i` of `Fin (n + 1)`, the successor of the predecessor of `i` is `i` itself. This theorem reflects that the operations `Fin.succ` and `Fin.pred` are inverses of each other for nonzero elements in the finite set `Fin (n + 1)`. In other words, if you take a nonzero element `i` from the set `Fin (n+1)`, compute its predecessor, and then compute the successor of the result, you end up with the original element `i`.

For any natural number `n` and nonzero `i` in `Fin (n + 1)`, `Fin.pred (Fin.pred i) = i`.


Function.Surjective.comp

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

The theorem `Function.Surjective.comp` states that for any three sorts (types) `α`, `β`, and `φ`, and any two functions `f` from `α` to `β` and `g` from `β` to `φ`, if `g` is surjective and `f` is surjective then their composition `g ∘ f` (first applying `f`, then `g`) is also surjective. In other words, if every element of `β` is the image of some element of `α` under `f`, and every element of `φ` is the image of some element of `β` under `g`, then every element of `φ` is the image of some element of `α` under the composition `g ∘ f`.

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


theorem nsmul_one : ∀ {A : Type u_6} [inst : AddMonoidWithOne A] (n : ℕ), n • 1 = ↑n := by sorry

This theorem states that for any natural number `n` and for any type `A` that is an additive monoid with a distinguished one element, the operation of scaling the one element by `n` (denoted by `n • 1`) is equal to the natural number `n` itself when viewed as an element of the monoid `A` (denoted by `↑n`). In other words, if you add one to itself `n` times in the additive monoid `A`, you get `n`.

For any additive monoid with identity element `A` and natural number `n`, the operation of scaling the identity `n` times equals `n` itself in `A`.


theorem total_of : ∀ {α : Sort u} (r : α → α → Prop) [inst : IsTotal α r] (a b : α), r a b ∨ r b a := by sorry

This theorem states that for any type `α` and relation `r` on `α`, if the relation `r` is a total relation on `α` (i.e., for all elements `a` and `b` of `α`, either `r a b` or `r b a` holds true), then for any two elements `a` and `b` of `α`, either `r a b` or `r b a` is true. In terms of mathematical logic, it asserts that the relation `r` is total, meaning that for any two elements in the set, one must be related to the other or vice versa.

If a relation on a type is total, then it is reflexive and symmetric. (In other words, for all `a` and `b` in the type, `r a b` and `r b a` hold true.)


theorem Option.some_injective : ∀ (α : Type u_5), Function.Injective some := by sorry

The theorem `Option.some_injective` states that for any type `α`, the `some` function, which wraps an element of `α` into the `Option` type, is injective. In other words, if `some a = some b` for any two elements `a` and `b` of type `α`, then it must be the case that `a = b`.

For any type `α`, the function `some : α → Option α` is injective, i.e., `some a = some b` implies `a = b`.


theorem Finset.mem_product :
    ∀ {α : Type u_1} {β : Type u_2} {s : Finset α} {t : Finset β} {p : α × β}, p ∈ s ×ˢ t ↔ p.1 ∈ s ∧ p.2 ∈ t := by
  sorry

This theorem states that for any two sets `s` of type `α` and `t` of type `β`, and any ordered pair `p` of type `α × β`, the pair `p` belongs to the Cartesian product of `s` and `t` if and only if the first element of `p` belongs to `s` and the second element of `p` belongs to `t`. The Cartesian product of `s` and `t` is denoted by `s ×ˢ t` in Lean 4.

For any sets `s` and `t`, the ordered pair `p` belongs to the Cartesian product `s ×ˢ t` if and only if its first component belongs to `s` and its second component belongs to `t`.


theorem Matrix.det_one :
    ∀ {n : Type u_2} [inst : DecidableEq n] [inst_1 : Fintype n] {R : Type v} [inst_2 : CommRing R], Matrix.det 1 = 1 :=
  by sorry

This theorem, `Matrix.det_one`, states that for any type `n` with decidable equality and finite instances, and any commutative ring `R`, the determinant of the identity matrix is 1. Here, `Matrix.det 1` represents the determinant of the identity matrix, and the theorem asserts that this determinant equals 1, which is a well-known property of identity matrices in linear algebra.

For any commutative ring R and finite type n with decidable equality, the determinant of the identity matrix of size n over R is equal to 1.


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

This theorem states that for any types `α` and `M` (with `M` having a `Zero` instance), given elements `a` and `a'` of type `α`, and an element `b` of type `M`, if `a` is not equal to `a'`, then the value of the function `fun₀` (which maps `a` to `b`) at `a'` is zero. Essentially, this is saying that a function defined for a particular input will yield zero when evaluated at a different input.

For any types `α` and `M` with a `Zero` instance, if `a ≠ a'` are elements of `α`, then `fun₀ a' = 0` where `fun₀ : α → M`.


theorem Prime.not_unit : ∀ {α : Type u_1} [inst : CommMonoidWithZero α] {p : α}, Prime p → ¬IsUnit p := by sorry

This theorem states that for any commutative monoid with zero, an element `p` being prime implies that `p` is not a unit. In other words, any prime element in a commutative monoid with zero does not have a two-sided inverse, or equivalently, cannot be written as the product of a unit and some other element.

In a commutative monoid with zero, a prime element has no multiplicative inverse.


theorem ContinuousMap.coe_zero :
    ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] [inst_2 : Zero β],
      ⇑0 = 0 :=
  by sorry

This theorem states that for any types `α` and `β`, where `α` and `β` have a topological space structure, and `β` also has a zero defined, the continuous function that maps everything to zero (denoted by `⇑0`) is indeed the zero function. In other words, the zero-constant continuous function is the zero element in the space of all continuous functions from `α` to `β`.

For any topological spaces `α` and `β` with a zero element in `β`, the continuous function mapping every element of `α` to the zero element of `β` is the zero function in the space of continuous functions from `α` to `β`.


LocallyConstant.ext

theorem LocallyConstant.ext :
    ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] ⦃f g : LocallyConstant X Y⦄,
      (∀ (x : X), f x = g x) → f = g :=
  by sorry

This theorem states that for any two locally constant functions `f` and `g` from a topological space `X` to any type `Y`, if these two functions agree on every point in `X` (i.e., for each `x` in `X`, `f(x) = g(x)`), then `f` and `g` are the same function. In other words, two locally constant functions are considered identical if they produce the same value for every input in the underlying topological space.

If two locally constant functions from a topological space to a type have the same value at every point, then they are equal.


theorem Finsupp.coe_zero : ∀ {α : Type u_1} {M : Type u_5} [inst : Zero M], ⇑0 = 0 := by sorry

This theorem, `Finsupp.coe_zero`, states that for any types `α` and `M` where `M` is equipped with a zero element, the function obtained by applying the coercion function `⇑` to the zero element of the type of finitely supported functions from `α` to `M` is equivalent to the zero function. In other words, the zero finitely supported function maps every element to zero.

The coercion of the zero element in a type equipped with a zero element to the type of finitely supported functions maps every element to the zero value in the codomain.


And.symm

theorem And.symm : ∀ {a b : Prop}, a ∧ b → b ∧ a := by sorry

This theorem, `And.symm`, states that for all propositions `a` and `b`, if both `a` and `b` are true (denoted as `a ∧ b`), then it's also true that `b` and `a` are true (denoted as `b ∧ a`). In other words, the "and" operation (`∧`) is symmetric in the context of propositional logic.

Given propositions `a` and `b`, if `a ∧ b` holds, then `b ∧ a` holds as well. (Or, equivalently, `a ∧ b` if and only if `b ∧ a`. )


theorem Mathlib.CategoryTheory.Idempotents.Karoubi._auxLemma.1 :
    ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] {P Q : CategoryTheory.Idempotents.Karoubi C}
      {f g : P ⟶ Q}, (f = g) = (f.f = g.f) :=
  by sorry

This theorem states that in the context of category theory, for any category `C` and any two idempotent Karoubi envelopes `P` and `Q` of `C`, two morphisms `f` and `g` from `P` to `Q` are equal if and only if their underlying morphisms (`f.f` and `g.f`) are equal. In formal terms, it establishes an equivalence between the equality of morphisms and the equality of their underlying structures in the category of idempotent Karoubi envelopes.

In category theory, two morphisms between idempotent Karoubi envelopes of a category are equal if and only if their underlying morphisms have the same underlying structure.