theorem Mathlib.Algebra.Algebra.Spectrum._auxLemma.2 :
    ∀ {R : Type u} {A : Type v} [inst : CommSemiring R] [inst_1 : Ring A] [inst_2 : Algebra R A] {r : R} {a : A},
      (r ∈ spectrum R a) = ¬IsUnit ((algebraMap R A) r - a) :=
  by sorry

The theorem `Mathlib.Algebra.Algebra.Spectrum._auxLemma.2` states that for any commutative semiring `R`, any ring `A` that is also an `R`-algebra, and any elements `r` of `R` and `a` of `A`, `r` is in the spectrum of `a` if and only if the difference between the image of `r` under the algebra structure map and `a` itself is not a unit in the algebra `A`. In the context of the algebra, a unit is an element that has a multiplicative inverse. Essentially, it details the relationship between the spectrum of an element of an `R`-algebra and the set of non-unit elements in the algebra.

For any commutative semiring R, an R-algebra A, and elements r in R and a in A, r is in the spectrum of a if and only if r \* a \*-1 is not defined in A.


theorem lt_iff_not_le : ∀ {α : Type u} [inst : LinearOrder α] {x y : α}, x < y ↔ ¬y ≤ x := by sorry

This theorem, `lt_iff_not_le`, states that for any type of object `α` which has a linear ordering, for two objects `x` and `y` of this type, `x` is less than `y` if and only if it is not the case that `y` is less than or equal to `x`. This theorem essentially establishes the relationship between the "less than" (`<`) and "less than or equal to" (`≤`) operators in a linear order.

For any linear ordered type α, x and y in α, x < y if and only if y ≤ x does not hold.


theorem AbstractCompletion.extend_coe :
    ∀ {α : Type u_1} [inst : UniformSpace α] (pkg : AbstractCompletion α) {β : Type u_2} [inst_1 : UniformSpace β]
      {f : α → β} [inst_2 : T2Space β],
      UniformContinuous f → ∀ (a : α), AbstractCompletion.extend pkg f (pkg.coe a) = f a :=
  by sorry

The theorem `AbstractCompletion.extend_coe` states that for any types `α` and `β` with respective uniform spaces, any uniform continuous function `f` from `α` to `β`, and any element `a` of `α`, if we extend the function `f` to the completion of `α` and apply it to the embedding of `a` in the completion, we get the same result as applying `f` to `a` directly. This theorem ensures that the extension of `f` to the completion is consistent with the original function `f` on the original space `α`. This holds under the assumption that `β` is a Hausdorff space (T2 space), which guarantees unique limits in `β`.

For any Hausdorff spaces `α` and `β`, uniformly continuous `f : α → β`, and `a : α`, the extension of `f` to the completions of `α` and `β` satisfy `f(completion_of_a) = completion_of(f a)`.


theorem ball_congr :
    ∀ {α : Sort u_1} {p : α → Prop} {P Q : (x : α) → p x → Prop},
      (∀ (x : α) (h : p x), P x h ↔ Q x h) → ((∀ (x : α) (h : p x), P x h) ↔ ∀ (x : α) (h : p x), Q x h) :=
  by sorry

This theorem states that given any type `α`, a predicate `p` on `α`, and two predicates `P` and `Q` that are dependent on both `α` and the truth of `p`, if for all `α` for which `p` is true, `P` is equivalent to `Q`, then the statement that `P` is true for all `α` for which `p` is true is equivalent to the statement that `Q` is true for all `α` for which `p` is true. In simpler terms, if two conditions `P` and `Q` are equivalent for all elements satisfying a certain property `p`, then the universal statements "All elements that satisfy `p` also satisfy `P`" and "All elements that satisfy `p` also satisfy `Q`" are also equivalent.

If for all `α` with `p(α)`, `P(α)` is equivalent to `Q(α)`, then `∀α. p(α) → P(α)` is equivalent to `∀α. p(α) → Q(α)`.


theorem Set.iUnion_const : ∀ {β : Type u_2} {ι : Sort u_4} [inst : Nonempty ι] (s : Set β), ⋃ x, s = s := by sorry

The theorem `Set.iUnion_const` asserts that for any type `β`, any type `ι` (where `ι` is nonempty), and any set `s` of type `β`, the indexed union over `s` (denoted by `⋃ x, s`) is equal to `s` itself. This is equivalent to stating that the union of a constant set `s` over all elements of any nonempty indexing set `ι` results in the set `s` itself. The theorem applies regardless of the specific types `β` and `ι` involved.

For any nonempty indexing type ι and set s of type β, the indexed union (⋃ x, s) equals set s.


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

The theorem `StrictAntiOn.dual_right` states that, for any given set `s` of type `α`, and a function `f` from `α` to `β`, if `f` is strictly antitone on `s` (meaning that for any two elements `a` and `b` in `s`, `a < b` implies `f(b) < f(a)`), then the composition of `f` and the identity function on the dual ordered set `OrderDual.toDual` is strictly monotone on `s` (i.e., for any two elements `a` and `b` in `s`, `a < b` implies that the result of applying `f` to `a` and 'dualizing' is less than the result of applying `f` to `b` and 'dualizing'). In other words, if `f` reverses order in `s`, then when applied to the dual order, `f` preserves the order in `s`.

If `f` is a strictly antitone function from a set `α` to `β`, then the composition of `f` and the identity function on the dual order of `α` is a strictly monotone function on `α`.


theorem CancelDenoms.div_subst :
    ∀ {α : Type u_1} [inst : Field α] {n1 n2 k e1 e2 t1 : α},
      n1 * e1 = t1 → n2 / e2 = 1 → n1 * n2 = k → k * (e1 / e2) = t1 :=
  by sorry

This theorem states that for any type `α` that is a field, given any elements `n1`, `n2`, `k`, `e1`, `e2`, and `t1` of `α`, if `n1 * e1` equals `t1`, `n2 / e2` equals `1`, and `n1 * n2` equals `k`, then it follows that `k * (e1 / e2)` equals `t1`. This theorem essentially provides a rule for substituting division and multiplication in terms of other product and division expressions, assuming certain conditions are met.


theorem Vector.get_zero : ∀ {n : ℕ} {α : Type u_1} (v : Vector α (Nat.succ n)), Vector.get v 0 = Vector.head v := by
  sorry

This theorem, referred to as `Vector.get_zero`, states that for any natural number `n` and any type `α`, given a vector `v` of length `n+1` with elements of type `α`, the first element of the vector obtained using the `Vector.get` function with an index of `0` is equal to the first element of the vector as obtained by the `Vector.head` function. In other words, it confirms that both `Vector.get v 0` and `Vector.head v` retrieve the same first element from a vector `v` of non-zero length.

For any vector `v` of length `n+1` and type `α`, `Vector.get v 0 = Vector.head v`.


Function.Periodic.zsmul

theorem Function.Periodic.zsmul :
    ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {c : α} [inst : AddGroup α],
      Function.Periodic f c → ∀ (n : ℤ), Function.Periodic f (n • c) :=
  by sorry

The theorem `Function.Periodic.zsmul` states that for any types `α` and `β`, any function `f` from `α` to `β`, any element `c` of `α`, and any integer `n`, if `f` is periodic with period `c` (i.e., for all `x` in `α`, `f(x + c) = f(x)`), then `f` is also periodic with period `n • c` (i.e., for all `x` in `α`, `f(x + n•c) = f(x)`). This is under the assumption that `α` forms an additive group. In simpler terms, if a function is periodic with a certain period, then it is also periodic with any integer multiple of that period.

If `α` is an additive group, `f:` `α` `->` `β` is periodic with period `c` in `α`, then `f` is also periodic with period `n • c` for any integer `n`.


theorem Cardinal.power_le_power_left : ∀ {a b c : Cardinal.{u_1}}, a ≠ 0 → b ≤ c → a ^ b ≤ a ^ c := by sorry

The theorem `Cardinal.power_le_power_left` states that for any three cardinal numbers `a`, `b`, and `c`, if `a` is not zero and `b` is less than or equal to `c`, then `a` raised to the power `b` is less than or equal to `a` raised to the power `c`. It illustrates a property of exponentiation in the context of cardinal numbers.

For any cardinal numbers `a`, `b`, and `c` with `a > 0` and `b <= c`, we have `a^b <= a^c`.


ContinuousAddMonoidHom.ext

theorem ContinuousAddMonoidHom.ext :
    ∀ {A : Type u_2} {B : Type u_3} [inst : AddMonoid A] [inst_1 : AddMonoid B] [inst_2 : TopologicalSpace A]
      [inst_3 : TopologicalSpace B] {f g : ContinuousAddMonoidHom A B}, (∀ (x : A), f x = g x) → f = g :=
  by sorry

This theorem states that for any two continuous additive monoid homomorphisms `f` and `g` from one add monoid `A` to another add monoid `B`, where both `A` and `B` are topological spaces, if `f` and `g` map any element `x` from `A` to the same element in `B` (i.e., `f(x) = g(x)` for all `x` in `A`), then `f` and `g` are the same continuous additive monoid homomorphisms. In other words, two continuous additive monoid homomorphisms are the same if they agree on all elements of the domain.

If two continuous additive monoid homomorphisms between topological add monoids agree on all elements, they are equal.


theorem Nat.add_one_le_iff : ∀ {m n : ℕ}, m + 1 ≤ n ↔ m < n := by sorry

This theorem, `Nat.add_one_le_iff`, states a property about natural numbers. For every pair of natural numbers `m` and `n`, the statement that `m + 1` is less than or equal to `n` is equivalent to the statement that `m` is strictly less than `n`.

For all natural numbers m and n, m + 1 < n if and only if m < n.


theorem mul_le_one : ∀ {α : Type u} [inst : OrderedSemiring α] {a b : α}, a ≤ 1 → 0 ≤ b → b ≤ 1 → a * b ≤ 1 := by sorry

This theorem states that for any type `α` that has the structure of an ordered semiring, if `a` and `b` are elements of `α` such that `a` is less than or equal to 1, `b` is non-negative (equal to or greater than 0), and `b` is less than or equal to 1, then the product of `a` and `b` is less than or equal to 1. In simpler terms, in a certain numerical context (an ordered semiring), if you multiply a number not exceeding 1 with a number between 0 and 1, the result will not exceed 1.

In an ordered semiring, the product of any element less than or equal to 1 and any non-negative element less than or equal to 1 is less than or equal to 1.


/-- In an R₁ topological space with Borel measure `μ`,
the measure of the closure of a compact set `K` is equal to the measure of `K`.

See also `MeasureTheory.Measure.OuterRegular.measure_closure_eq_of_isCompact`
for a version that assumes `μ` to be outer regular
but does not assume the `σ`-algebra to be Borel.   -/
theorem IsCompact.measure_closure :
    ∀ {γ : Type u_3} [inst : TopologicalSpace γ] [inst_1 : MeasurableSpace γ] [inst_2 : BorelSpace γ]
      [inst_3 : R1Space γ] {K : Set γ}, IsCompact K → ∀ (μ : MeasureTheory.Measure γ), ↑↑μ (closure K) = ↑↑μ K :=
  by sorry

The theorem `IsCompact.measure_closure` states that in a topological space (denoted as `γ`) which has an R₁ structure, and is equipped with a Borel measure `μ`, the measure of the closure of a compact set `K` is equal to the measure of `K` itself. In other words, if a set `K` is compact in this space, then taking the closure of `K` does not change its measure under `μ`. An additional statement in the theorem refers to another version `MeasureTheory.Measure.OuterRegular.measure_closure_eq_of_isCompact` that does not require the σ-algebra to be Borel, but instead assumes `μ` to be outer regular.

In a topological space with an R₁ structure and a Borel measure, the measure of a compact set is equal to the measure of its closure. (Alternatively, for a measure that is outer regular, the measure of a compact set equals the measure of its closure without requiring a Borel σ-algebra.)


theorem PowerSeries.coeff_C :
    ∀ {R : Type u_1} [inst : Semiring R] (n : ℕ) (a : R),
      (PowerSeries.coeff R n) ((PowerSeries.C R) a) = if n = 0 then a else 0 :=
  by sorry

The theorem `PowerSeries.coeff_C` states that for any semiring `R`, any natural number `n`, and any element `a` of `R`, the `n`th coefficient of the constant formal power series generated by `a` is `a` if `n` is zero and zero otherwise. In other words, the only non-zero coefficient of a constant power series is the zeroth one, which is equal to the constant value `a` itself, and all other coefficients are zero.

The constant formal power series generated by an element `a` in a semiring `R` has `a` as its zeroth coefficient and zero as all other coefficients.


theorem CategoryTheory.Equivalence.locallyCoverDense :
    ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_5, u_1} C] (J : CategoryTheory.GrothendieckTopology C)
      {D : Type u_2} [inst_1 : CategoryTheory.Category.{u_4, u_2} D] (e : C ≌ D),
      CategoryTheory.LocallyCoverDense J e.inverse :=
  by sorry

This theorem states that for any category `C` with a Grothendieck topology `J` and any category `D`, if `C` and `D` are equivalent as categories with the equivalence `e`, then the inverse of `e` is locally cover dense for the topology `J`. Locally cover dense is a property of a functor for spanning a cover in a Grothendieck topology.

If categories `C` and `D` are equivalent with an equivalence `e` in a category with a Grothendieck topology `J`, then the inverse of `e` is locally cover-preserving for `J`. (This means that for every cover `C'` in `C` by `J`, the image `e(C')` is a cover in `D`.)


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

This theorem states that for any two propositions 'a' and 'b', the negation of the biconditional between 'a' and 'b' is equivalent to the biconditional between the negation of 'a' and 'b'. In other words, if 'a' is not equivalent to 'b', then 'b' is equivalent to the statement that 'a' is not true.

The negation of (a ≤f/∥ b) is equivalent to (~a ≤f/∥ b) and (a ≤f/∥ b) is equivalent to (a ≤f/∥ ~b), where "≤f/∥" denotes biconditional.


/-- In a linear ordered field, for positive `a` and `b` we have `a⁻¹ < b ↔ b⁻¹ < a`.
See also `inv_lt_of_inv_lt` for a one-sided implication with one fewer assumption.  -/
theorem inv_lt : ∀ {α : Type u_2} [inst : LinearOrderedSemifield α] {a b : α}, 0 < a → 0 < b → (a⁻¹ < b ↔ b⁻¹ < a) := by
  sorry

This theorem states that in any linearly ordered semifield, given two positive elements `a` and `b`, the reciprocal of `a` is less than `b` if and only if the reciprocal of `b` is less than `a`. This theorem also refers to `inv_lt_of_inv_lt`, which presents a similar but one-sided implication with one less assumption.

In a linearly ordered semifield, the reciprocal of one positive element is less than another if and only if the reciprocal of the other is less than the first.


theorem sdiff_inf : ∀ {α : Type u_2} [inst : GeneralizedCoheytingAlgebra α] {a b c : α}, a \ (b ⊓ c) = a \ b ⊔ a \ c :=
  by sorry

This theorem, `sdiff_inf`, states that for all types `α` in a Generalized Coheyting Algebra, and for any three elements `a`, `b`, `c` of this type, the set difference of `a` and the infimum (greatest lower bound) of `b` and `c` is equal to the supremum (least upper bound) of the set difference of `a` and `b` and the set difference of `a` and `c`. In terms of set theory, it expresses that removing elements `b` and `c` from `a` simultaneously is equivalent to removing `b` from `a` and `c` from `a` separately, and then taking the union of the two results.

For all types `α` in a Generalized Cohen algebra and all elements `a`, `b`, `c` of `α`, `a \ (inf b c) = sup (a \ b) (a \ c)`.


theorem Filter.eventually_ne_atTop :
    ∀ {α : Type u_3} [inst : Preorder α] [inst_1 : NoMaxOrder α] (a : α), ∀ᶠ (x : α) in Filter.atTop, x ≠ a := by sorry

The theorem `Filter.eventually_ne_atTop` states that for any type `α` which has a preorder relation and does not have a maximum element (captured by the `NoMaxOrder α` instance), given any element `a` of type `α`, there will eventually be an element `x` such that `x ≠ a` as `x` approaches infinity (`x` is taken from the filter representing limit towards infinity, `Filter.atTop`). In other words, if we keep ascending in the order, we will eventually find elements different from `a`.

For any type `α` without a maximum element in a preorder relation, there exists an element `x` in the filter of limit elements that is different from any given element `a`.


/-- If the two vectors passed to `oangle` are the same, the result is 0.  -/
theorem Orientation.oangle_self :
    ∀ {V : Type u_1} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V]
      [inst_2 : Fact (FiniteDimensional.finrank ℝ V = 2)] (o : Orientation ℝ V (Fin 2)) (x : V),
      Orientation.oangle o x x = 0 :=
  by sorry

This theorem states that for any two-dimensional real vector space `V` equipped with a normed additive commutative group structure and an inner product space over the real numbers, and for any orientation `o` of `V` and any vector `x` in `V`, the oriented angle from `x` to itself, denoted by `Orientation.oangle o x x`, is always zero. This is a mathematical statement about geometry, which asserts that the angle that a vector forms with itself in a given orientation is always zero.

For any two-dimensional real vector space `V` endowed with a normed additive commutative group structure and an inner product space structure over the real numbers, and for any orientation `o` and vector `x` in `V`, the oriented angle `oangle o x x` is equal to zero.


theorem Mathlib.Order.WithBot._auxLemma.13 : ∀ {α : Type u_1} {a b : α} [inst : LT α], (↑a < ↑b) = (a < b) := by sorry

This theorem states that for any type `α` and any two elements `a` and `b` of that type, where `α` has a defined "less than" (`<`) relation, the comparison of the "coerced" (or "uplifted") values of `a` and `b` is equivalent to the comparison of `a` and `b` themselves. In other words, lifting `a` and `b` to an encompassing type with a bottom element (`WithBot α`) doesn't change the result of their comparison.

For any type `α` with a defined `<` relation and any `a`, `b` in `α`, `a < b` if and only if `WithBot a < WithBot b` in `WithBot α`.


/-- The image under a monoid hom of the submonoid generated by a set equals the submonoid generated
by the image of the set.  -/
theorem MonoidHom.map_mclosure :
    ∀ {M : Type u_1} {N : Type u_2} [inst : MulOneClass M] [inst_1 : MulOneClass N] {F : Type u_5}
      [inst_2 : FunLike F M N] [mc : MonoidHomClass F M N] (f : F) (s : Set M),
      Submonoid.map f (Submonoid.closure s) = Submonoid.closure (⇑f '' s) :=
  by sorry

The theorem `MonoidHom.map_mclosure` states that for any two types `M` and `N` that are instances of the `MulOneClass` (which means they are monoids), any instance `F` that is a function-like from `M` to `N` and an instance of `MonoidHomClass` (meaning it preserves the monoid structure), a function `f : F`, and a set `s` of type `M`, the image under the function `f` of the submonoid generated by the set `s` is equal to the submonoid generated by the image of the set `s` under the function `f`. In mathematical notation, this means that for a monoid homomorphism `f` and a subset `s` of a monoid, the image of the submonoid generated by `s` under `f` is the same as the submonoid generated by the image of `s` under `f`.

For any monoid homomorphism `f` between monoids `M` and `N`, the image of the submonoid generated by `s` in `M` under `f` is equal to the submonoid generated by the image of `s` in `N`.


AddCon.ext

/-- Extensionality rule for additive congruence relations. -/
theorem AddCon.ext : ∀ {M : Type u_1} [inst : Add M] {c d : AddCon M}, (∀ (x y : M), c x y ↔ d x y) → c = d := by sorry

This theorem is called the Extensionality rule for additive congruence relations. It states that for all types `M` with addition operation, and for any two additive congruence relations `c` and `d` on `M`, if for all elements `x` and `y` of `M`, `x` is related to `y` by `c` if and only if `x` is related to `y` by `d`, then `c` and `d` are the same relation. In mathematical terms, if two additive congruence relations define the same set of pairs `(x, y)`, then they are equal.

If two additive congruence relations on a type with addition define the same equivalence classes, then they are equal.


theorem Ordinal.typein_lt_typein :
    ∀ {α : Type u} (r : α → α → Prop) [inst : IsWellOrder α r] {a b : α},
      Ordinal.typein r a < Ordinal.typein r b ↔ r a b :=
  by sorry

The theorem `Ordinal.typein_lt_typein` states that for any type `α` and a relation `r` on `α` that is a well-order, and any two elements `a` and `b` from `α`, the ordinal type of `a` with respect to `r` is less than the ordinal type of `b` with respect to `r` if and only if `r a b` holds. In other words, the ordering of the ordinal types of elements (defined by `Ordinal.typein`) reflects the ordering in the well-order `r`.

For any well-ordered type `(α, r)`, the ordinal type `Ordinal.typein a` of an element `a` is less than the ordinal type `Ordinal.typein b` of another element `b` if and only if `r a b` holds.


theorem Finset.coe_range : ∀ (n : ℕ), ↑(Finset.range n) = Set.Iio n := by sorry

This theorem states that for any natural number 'n', the coercion of the set of natural numbers less than 'n' (denoted as 'Finset.range n') is equal to the left-infinite right-open interval of 'n' (denoted as 'Set.Iio n'). In other words, the set of all natural numbers less than a given natural number 'n' and the left-infinite interval of 'n' are equivalent sets. Here, the left-infinite right-open interval is a set of all elements 'x' such that 'x' is less than 'n'. The coercive function (↑) is used to convert the 'Finset' object into a 'Set' object.

For any natural number n, the coercion of the finite set of natural numbers less than n to a set equals the left-infinite right-open interval of n. In Lean syntax, `Finset.range n ≈ Set.Iio n`.


theorem Set.diff_singleton_eq_self : ∀ {α : Type u} {a : α} {s : Set α}, a ∉ s → s \ {a} = s := by sorry

The theorem `Set.diff_singleton_eq_self` states that for any type `α`, any element `a` of type `α`, and any set `s` of elements of type `α`, if `a` does not belong to `s` (`a ∉ s`), then the difference of `s` and the singleton set containing `a` (`s \ {a}`) is equal to `s` itself. In other words, removing an element that is not in the set does not change the set.

For any set `s` and element `a` in a type `α`, if `a ∉ s`, then `s \ {a} = s`.


theorem Matrix.neg_mul :
    ∀ {m : Type u_2} {n : Type u_3} {o : Type u_4} {α : Type v} [inst : NonUnitalNonAssocRing α] [inst_1 : Fintype n]
      (M : Matrix m n α) (N : Matrix n o α), -M * N = -(M * N) :=
  by sorry

The theorem `Matrix.neg_mul` states that for any three types `m`, `n`, and `o`, and a type `α` forming a non-unital non-associative ring, and for any finite type `n`, if we have two matrices `M` and `N` such that `M` is a matrix with entries of type `α`, rows indexed by `m`, and columns indexed by `n`, and `N` is a matrix with entries of type `α`, rows indexed by `n`, and columns indexed by `o`, the multiplication of the negation of `M` with `N` equals the negation of the product of `M` and `N`. This theorem essentially states a property of matrix multiplication similar to the distributive law of scalar multiplication in linear algebra.

For matrices $M$ and $N$ with compatible dimensions over a non-unital non-associative ring $\alpha$, $-M \cdot N = -(M \cdot N)$.


MeasureTheory.Submartingale.integrable

theorem MeasureTheory.Submartingale.integrable :
    ∀ {Ω : Type u_1} {E : Type u_2} {ι : Type u_3} [inst : Preorder ι] {m0 : MeasurableSpace Ω}
      {μ : MeasureTheory.Measure Ω} [inst_1 : NormedAddCommGroup E] [inst_2 : NormedSpace ℝ E]
      [inst_3 : CompleteSpace E] {f : ι → Ω → E} {ℱ : MeasureTheory.Filtration ι m0} [inst_4 : LE E],
      MeasureTheory.Submartingale f ℱ μ → ∀ (i : ι), MeasureTheory.Integrable (f i) μ :=
  by sorry

The theorem states that for any submartingale `f` indexed by a preorder `ι` and defined on a given measurable space `Ω` with a measure `μ`, measurement filtration `ℱ`, and values in a real normed, complete additive group `E` with a partial order, each function `f i` (for every `i` in `ι`) is integrable. In mathematical terms, integrability here means that each `f i` is measurable and the integral of the norm of `f i` with respect to the measure `μ` is finite.

For any submartingale `f` indexed by a preorder `ι` on measurable space `(Ω, ℱ, μ)` with values in a real normed, complete additive group `(E, ≤)`, each function `fi` is integrable, i.e., measurable and ∫ |fi|dμ<∞.


NonemptyInterval.ext

theorem NonemptyInterval.ext : ∀ {α : Type u_7} {inst : LE α} (x y : NonemptyInterval α), x.toProd = y.toProd → x = y :=
  by sorry

This theorem states that for any type `α` with a less-than-or-equal-to relation, if we have two non-empty intervals `x` and `y` of `α`, then if the interval represented as a product by `toProd` function is the same for both `x` and `y`, then `x` and `y` must be the same interval. Essentially, it guarantees that two non-empty intervals are equal if they represent the same interval (as a product of lower and upper bounds).

If `α` is a type with a total order and `x` and `y` are non-empty intervals of `α` with equal product representations, then `x = y`.


theorem sup_top_eq : ∀ {α : Type u} [inst : SemilatticeSup α] [inst_1 : OrderTop α] (a : α), a ⊔ ⊤ = ⊤ := by sorry

This theorem states that for any type `α` that forms a semilattice with an operation "sup" (which stands for supremum or least upper bound) and also has a top element (`⊤`), the supremum of any element `a` of type `α` and the top element is always equal to the top element. In terms of set theory, the supremum of a set and the universal set is the universal set itself. This is an instance of the general principle that in a partially ordered set, the supremum of any element and the greatest element is the greatest element.

For any semilattice `α` with top element `⊤`, the supremum of any element `a` in `α` is equal to `⊤`.


CategoryTheory.Limits.image.ext

theorem CategoryTheory.Limits.image.ext :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} (f : X ⟶ Y)
      [inst_1 : CategoryTheory.Limits.HasImage f] {W : C} {g h : CategoryTheory.Limits.image f ⟶ W}
      [inst_2 : CategoryTheory.Limits.HasLimit (CategoryTheory.Limits.parallelPair g h)],
      CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.factorThruImage f) g =
          CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.factorThruImage f) h →
        g = h :=
  by sorry

This theorem, `CategoryTheory.Limits.image.ext`, states that in any category `C` with given objects `X`, `Y`, and `W`, and a morphism `f` from `X` to `Y` that has an image, if there exist two morphisms `g` and `h` from the image of `f` to `W`, and if a limit exists for the parallel pair `g` and `h`, then if the composition of the factor through image of `f` with `g` equals the composition of the factor through image of `f` with `h`, it must be the case that `g` equals `h`. Essentially, this theorem asserts the uniqueness of morphisms from the image of `f` under certain conditions.

If in a category with an object `X`, morphisms `f: X -> Y`, `g, h: Im(f) -> W`, and a limit for the parallel pair `g` and `h`, then equal composition with `f` implies `g = h`.


theorem Submodule.smul_le :
    ∀ {R : Type u} {M : Type v} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {I : Ideal R}
      {N P : Submodule R M}, I • N ≤ P ↔ ∀ r ∈ I, ∀ n ∈ N, r • n ∈ P :=
  by sorry

The theorem `Submodule.smul_le` establishes a relationship between ideals and submodules in a commutative semiring `R` with an added commutative monoid `M` structure and a `R`-module `M` structure. Specifically, it states that for any ideal `I` of `R` and any two submodules `N` and `P` of `M`, `I` scaled by `N` (`I • N`) is a subset of or equal to `P` if and only if for every element `r` in the ideal `I` and every element `n` in the submodule `N`, the scalar multiplication of `r` and `n` (`r • n`) is an element of `P`.

For an ideal I of a commutative semiring R with an added commutative monoid and R-module structure on M, I • N ⊆ P if and only if ∀ r ∈ I, ∀ n ∈ N, r • n ∈ P.


Ideal.IsPrime.isRadical

theorem Ideal.IsPrime.isRadical :
    ∀ {R : Type u} [inst : CommSemiring R] {I : Ideal R}, Ideal.IsPrime I → Ideal.IsRadical I := by sorry

This theorem states that for any commutative semiring `R` and any ideal `I` of `R`, if `I` is a prime ideal in `R`, then `I` is also a radical ideal in `R`. Here, an ideal `I` is said to be a prime ideal if whenever a product of two elements of the semiring `R` is in `I`, then at least one of the elements must be in `I`. An ideal is said to be radical if it contains its radical, that is, all elements `r` in `R` such that some positive power of `r` is in `I`.

If `I` is a prime ideal in the commutative semiring `R`, then `I` is a radical ideal.


theorem continuous_circleMap : ∀ (c : ℂ) (R : ℝ), Continuous (circleMap c R) := by sorry

The theorem `continuous_circleMap` states that for any given complex number `c` and real number `R`, the function `circleMap` with fixed parameters `c` and `R` is continuous. In mathematical terms, this means that for every complex number `c` and real number `R`, the exponential map `θ ↦ c + Re^{θi}`, which maps a real number `θ` to a point on the circle in the complex plane with center `c` and radius `|R|`, is a continuous function.

The exponential map `θ ↦ c + Re^(θi)` is a continuous function from the real numbers to the complex plane for any complex number `c` and real number `R`.


/-- A specialization of `subset_iUnion₂`.  -/
theorem Set.subset_biUnion_of_mem :
    ∀ {α : Type u_1} {β : Type u_2} {s : Set α} {u : α → Set β} {x : α}, x ∈ s → u x ⊆ ⋃ x ∈ s, u x := by sorry

This theorem states that for any types `α` and `β`, given a set `s` of elements of type `α`, a function `u` from `α` to a set of `β`, and an element `x` of type `α`, if `x` is in `s`, then the set `u(x)` is a subset of the union over all `x` in `s` of `u(x)`. In mathematical notation, this can be written as: if $x \in s$, then $u(x) \subseteq \bigcup_{x \in s} u(x)$.

For any set `s` of type `α`, function `u` from `α` to a set of `β`, and `x` in `α` belonging to `s`, `u(x)` is a subset of the union of `u(y)` over all `y` in `s`.


theorem LineDifferentiableWithinAt.hasLineDerivWithinAt :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {F : Type u_2} [inst_1 : NormedAddCommGroup F]
      [inst_2 : NormedSpace 𝕜 F] {E : Type u_3} [inst_3 : AddCommGroup E] [inst_4 : Module 𝕜 E] {f : E → F} {s : Set E}
      {x v : E}, LineDifferentiableWithinAt 𝕜 f s x v → HasLineDerivWithinAt 𝕜 f (lineDerivWithin 𝕜 f s x v) s x v :=
  by sorry

This theorem, `LineDifferentiableWithinAt.hasLineDerivWithinAt`, states that for any non-trivially normed field `𝕜`, a normed additive commutative group `F` that is also a normed space over `𝕜`, an additive group `E` that is a module over `𝕜`, a function `f` mapping from `E` to `F`, a set `s` of elements of `E`, and two elements `x` and `v` of `E`, if `f` is line differentiable at `x` with direction `v` within the set `s` (i.e., `LineDifferentiableWithinAt 𝕜 f s x v`), then `f` also has a line derivative at `x` with direction `v` within `s`, and the derivative is given by `lineDerivWithin 𝕜 f s x v` (i.e., `HasLineDerivWithinAt 𝕜 f (lineDerivWithin 𝕜 f s x v) s x v`). The theorem asserts the existence of a line derivative for a function that is line differentiable within a certain set.

If a function `f` is line differentiable within a set `s` at point `x` in the direction `v` over a normed field `𝕜`, then `f` has a line derivative at `x` in the direction `v` within `s`, which is equal to the line derivative of `f` within `s` at `x` and `v`.


theorem Cardinal.one_le_iff_ne_zero : ∀ {c : Cardinal.{u_1}}, 1 ≤ c ↔ c ≠ 0 := by sorry

This theorem states that for any cardinal number `c` from the universe `u_1`, the cardinal number `c` is greater than or equal to one if and only if `c` is not equal to zero. In other words, in the context of cardinal numbers, a cardinal number is non-zero if and only if it is at least one.

For any cardinal number `c`, `c` is non-zero if and only if `c` is greater than or equal to one.


theorem Int.log_of_one_le_right :
    ∀ {R : Type u_1} [inst : LinearOrderedSemifield R] [inst_1 : FloorSemiring R] (b : ℕ) {r : R},
      1 ≤ r → Int.log b r = ↑(Nat.log b ⌊r⌋₊) :=
  by sorry

The theorem `Int.log_of_one_le_right` states that for any type `R` which is a linear ordered semiring and has a floor function, and for any natural number `b` and any value `r` of type `R`, if `r` is greater than or equal to 1, then the integer logarithm of `r` in base `b` is equal to the natural logarithm of the floor of `r` in base `b`. In simpler terms, when `r` is at least 1, the maximum exponent to which you can raise `b` to get a number less than or equal to `r` is the same whether you're considering `r` as an integer or as a real number rounded down to the nearest integer.

For any base `b` and type `R` being a linear ordered semiring with a floor function, if `R` value `r` is greater than or equal to 1, then the integer logarithm of `r` in base `b` equals the natural logarithm of the floor of `r` in base `b`.


/-- **Alias** of the forward direction of `Function.semiconj_iff_comp_eq`.

---

Definition of `Function.Semiconj` in terms of functional equality.  -/
theorem Function.Semiconj.comp_eq :
    ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {ga : α → α} {gb : β → β},
      Function.Semiconj f ga gb → f ∘ ga = gb ∘ f :=
  by sorry

The theorem `Function.Semiconj.comp_eq` states that for any types `α` and `β`, and any functions `f : α → β`, `ga : α → α`, and `gb : β → β`, if `f` semiconjugates `ga` to `gb` (i.e., for all `x` in `α`, `f(ga(x))` equals `gb(f(x))`), then the composition `f ∘ ga` equals the composition `gb ∘ f`. This theorem provides a definition of semiconjugation in terms of functional equality.

If functions `f : α → β`, `ga : α → α`, and `gb : β → β` satisfy `f (ga x) = gb (f x)` for all `x` in `α`, then `f ∘ ga = gb ∘ f`.


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

This theorem, `CategoryTheory.Limits.pullbackSymmetry_hom_comp_snd`, states that in any category `C`, for any objects `X`, `Y`, and `Z`, and morphisms `f : X ⟶ Z` and `g : Y ⟶ Z` that have a pullback, the composition of the morphism `hom` from the pullback symmetry of `f` and `g` and the second projection of the pullback equals the first projection of the pullback. In other words, if we take the pullback of `f` and `g`, swap the roles of `X` and `Y` (i.e., apply the pullback symmetry), then project back onto `Y`, we end up at the same place as if we had just projected onto `X` from the original pullback.

In any category with pullbacks, given morphisms `f : X ⟶ Z` and `g : Y ⟶ Z` with a pullback, the composition of the pullback symmetry morphism of `f` and `g` with the second projection of the pullback equals the first projection of the pullback.


theorem Function.nmem_support :
    ∀ {α : Type u_1} {M : Type u_5} [inst : Zero M] {f : α → M} {x : α}, x ∉ Function.support f ↔ f x = 0 := by sorry

The theorem `Function.nmem_support` states that for any types `α` and `M` with `M` having an instance of `Zero` and for any function `f` from `α` to `M` and any element `x` of `α`, `x` is not in the support of `f` if and only if `f(x)` equals zero. In other words, an element is not in the support of a function (defined as the set of points where the function does not equal zero) if and only if the function evaluated at that element is equal to zero.

The theorem `Function.nmem_support` asserts that an element is not in the support of a function if and only if the function evaluates to zero at that element.


theorem Ordinal.le_add_right : ∀ (a b : Ordinal.{u_3}), a ≤ a + b := by sorry

This theorem, `Ordinal.le_add_right`, asserts that for all ordinal numbers `a` and `b`, `a` is always less than or equal to the sum of `a` and `b`. This is an analogue to a common arithmetic law in the context of ordinal numbers, where an ordinal number `a` added to any other ordinal number `b` results in a sum that is greater or equal to `a`. This can be written in mathematical terms as ∀a,b ∈ Ordinal, a ≤ a + b.

For all ordinal numbers `a` and `b`, `a` is less than or equal to the sum `a + b`.


theorem Prod.swap_injective : ∀ {α : Type u_1} {β : Type u_2}, Function.Injective Prod.swap := by sorry

This theorem states that for any types `α` and `β`, the function `Prod.swap` is injective. In other words, for any pairs of elements `(a, b)` and `(c, d)` from the Cartesian product of the types `α` and `β`, if `Prod.swap (a, b) = Prod.swap (c, d)` (meaning that `(b, a) = (d, c)`), then it must be the case that `(a, b) = (c, d)`. This essentially means that swapping the elements of a pair doesn't create any duplicate pairs, hence the function `Prod.swap` is injective.

For any types `α` and `β`, the function `Prod.swap` on the Cartesian product `α × β` is a bijection. (Injectivity is half of this statement, and the surjectivity part states that for any `(c, d)` in `α × β`, there exists a unique `(a, b)` such that `Prod.swap (a, b) = (c, d)`.)


theorem Complex.I_sq : Complex.I ^ 2 = -1 := by sorry

This theorem states that the square of the imaginary unit in complex numbers equals negative one. In mathematical terms, it corresponds to the well-known identity i² = -1, where i is the imaginary unit, a fundamental concept in complex number theory.

The square of the imaginary unit i in complex numbers equals negative one. (i.e., i² = -1)


theorem Asymptotics.isLittleO_norm_right :
    ∀ {α : Type u_1} {E : Type u_3} {F' : Type u_7} [inst : Norm E] [inst_1 : SeminormedAddCommGroup F'] {f : α → E}
      {g' : α → F'} {l : Filter α}, (f =o[l] fun x => ‖g' x‖) ↔ f =o[l] g' :=
  by sorry

The theorem `Asymptotics.isLittleO_norm_right` states that for any types `α`, `E`, and `F'`, with `E` being a normed space, and `F'` being a seminormed add commutative group, and for any functions `f : α → E` and `g' : α → F'`, and for any filter `l` on `α`, `f` is little-o of the norm of `g'` at `l` if and only if `f` is little-o of `g'` at `l`. In terms of asymptotic notation, this theorem is saying that `f(x)` is asymptotically smaller than `‖g' x‖` if and only if `f(x)` is asymptotically smaller than `g' x`.

For functions `f : α → E` from type `α` to a normed space `E` and `g' : α → F'` from type `α` to a seminormed additive commutative group `F'`, `f` is little-o of the norm of `g'` at a filter `l` on `α` if and only if `f` is little-o of `g'` at `l`. In other words, `f(x)` is asymptotically smaller than `‖g' x‖` and `g' x` as `x` approaches limits in `l`.


theorem Array.append_data : ∀ {α : Type u_1} (arr arr' : Array α), (arr ++ arr').data = arr.data ++ arr'.data := by
  sorry

This theorem, `Array.append_data`, states that for any two arrays `arr` and `arr'` of any type `α`, the data of the concatenated array (`arr ++ arr'`) is equal to the concatenation of the data of `arr` and `arr'`. In other words, it establishes that the operation of appending two arrays together in Lean 4 corresponds exactly to appending their underlying data together.

For any type `α` and arrays `arr:` Array `α` and `arr':` Array `α`, the data of the concatenated array `arr ++ arr'` is equal to the concatenation of the data of `arr` and `arr'`.


/-- Two `MonoidHom`s from a quotient group are equal if their compositions with
`QuotientGroup.mk'` are equal.

See note [partially-applied ext lemmas].  -/
theorem QuotientGroup.monoidHom_ext :
    ∀ {G : Type u} [inst : Group G] (N : Subgroup G) [nN : Subgroup.Normal N] {M : Type x} [inst_1 : Monoid M]
      ⦃f g : G ⧸ N →* M⦄, MonoidHom.comp f (QuotientGroup.mk' N) = MonoidHom.comp g (QuotientGroup.mk' N) → f = g :=
  by sorry

The theorem `QuotientGroup.monoidHom_ext` states that for any group `G`, normal subgroup `N` of `G`, and monoid `M`, if we have two monoid homomorphisms `f` and `g` from the quotient group `G ⧸ N` to `M`, then `f` and `g` are equal if their compositions with the group homomorphism `QuotientGroup.mk'`, which maps from `G` to `G ⧸ N`, are equal. This theorem is typically used in situations where we want to show that two monoid homomorphisms are equal based on their actions when composed with another specific homomorphism.

If two monoid homomorphisms from the quotient group of a group by a normal subgroup to a monoid have equal compositions with the quotient group homomorphism, then they are equal.


theorem Ultrafilter.coe_injective : ∀ {α : Type u}, Function.Injective Ultrafilter.toFilter := by sorry

The theorem `Ultrafilter.coe_injective` states that for all types `α`, the function `Ultrafilter.toFilter` is injective. In other words, given any two ultrafilters on a type `α`, if they are mapped to the same filter using `Ultrafilter.toFilter`, then the original ultrafilters must have been the same. This is equivalent to saying that no two distinct ultrafilters on the same type can be mapped to the same filter, ensuring uniqueness of representation in the context of filters.

Given any two ultrafilters on the same type, if their images under `Ultrafilter.toFilter` are equal, then the ultrafilters themselves are equal.


theorem Pi.one_apply : ∀ {I : Type u} {f : I → Type v₁} (i : I) [inst : (i : I) → One (f i)], 1 i = 1 := by sorry

This theorem, `Pi.one_apply`, states that for any type `I` and any function `f` from `I` to another type `v₁`, given any element `i` of `I` and assuming that for each `i` in `I` the type `f i` has a multiplicative identity (i.e., it has a `One` instance), applying the multiplicative identity `1` to `i` is the same as the multiplicative identity `1` itself. In simple terms, it says that the identity element does not change when applied to an element of the domain.

For any type `I` and function `f` from `I` to a type with a multiplicative identity, the application of the multiplicative identity `1` to an element `i` of `I` equals the identity `1` itself.


AddCommute.all

theorem AddCommute.all : ∀ {S : Type u_2} [inst : AddCommMagma S] (a b : S), AddCommute a b := by sorry

This theorem states that for any type `S` which is an additive commutative magma (that is, the operation of addition `+` is defined and is commutative on `S`), and for any two elements `a` and `b` of `S`, the property `AddCommute a b` holds. In other words, for any two elements `a` and `b` in a commutative magma, their addition is commutative: `a + b = b + a`.

In any commutative magma `S`, for all `a, b` in `S`, `a + b = b + a`.


theorem Mathlib.Data.Bool.Basic._auxLemma.1 : ∀ {p : Bool → Prop}, (∀ (b : Bool), p b) = (p false ∧ p true) := by sorry

This theorem states that for any predicate `p` that operates on boolean values, the property that `p` holds for all boolean values (`∀ (b : Bool), p b`) is equivalent to the conjunction of `p` holding for `false` and `p` holding for `true` (`p false ∧ p true`). Essentially, it captures the idea that, because there are only two boolean values, checking a predicate on all booleans is the same as checking it on `false` and `true` individually.

For any predicate `p` on boolean values, `∀ (b : Bool), p b` is equivalent to `p false ∧ p true`.


theorem Nat.mem_factors : ∀ {n p : ℕ}, n ≠ 0 → (p ∈ Nat.factors n ↔ Nat.Prime p ∧ p ∣ n) := by sorry

The theorem `Nat.mem_factors` states that for all natural numbers `n` and `p`, given that `n` is not equal to zero, `p` is a member of the list of prime factors of `n` if and only if `p` is a prime number and `p` divides `n`. Here, `Nat.Prime p` means `p` is a prime number, meaning it is a natural number greater than or equal to 2 whose only divisors are `p` and `1`, and `p ∣ n` means `p` divides `n`.

For a prime number `p` to be a factor of a natural number `n` (i.e., `p | n`), it must be a prime factor of `n` (belong to the list of prime factors of `n`).


theorem MeasureTheory.average_eq_integral :
    ∀ {α : Type u_1} {E : Type u_2} {m0 : MeasurableSpace α} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E]
      (μ : MeasureTheory.Measure α) [inst_2 : MeasureTheory.IsProbabilityMeasure μ] (f : α → E),
      ⨍ (x : α), f x ∂μ = ∫ (x : α), f x ∂μ :=
  by sorry

The theorem `MeasureTheory.average_eq_integral` states that for any type `α`, any normed additive commutative group `E`, any measurable space `m0` on `α`, any normed space of real numbers `ℝ` on `E`, any measure `μ` on `α` that is a probability measure, and any function `f` from `α` to `E`, the Bochner (or Lebesgue) integral of `f` with respect to `μ` is equal to the expected value of `f` under the probability measure `μ`.

For any measurable space `(α, Σ, μ)` where `μ` is a probability measure, the Bochner integral of a `Σ → ℝ` measurable function `f` equals the expected value of `f` under `μ`.


theorem biSup_mono :
    ∀ {α : Type u_1} {ι : Sort u_5} [inst : CompleteLattice α] {f : ι → α} {p q : ι → Prop},
      (∀ (i : ι), p i → q i) → ⨆ i, ⨆ (_ : p i), f i ≤ ⨆ i, ⨆ (_ : q i), f i :=
  by sorry

This theorem, `biSup_mono`, states that for any type `α` which forms a complete lattice, and any function `f` from some type `ι` to `α`, along with propositions `p` and `q` about elements of type `ι`, if every element that satisfies `p` also satisfies `q`, then the supremum (greatest lower bound) of `f` over all elements that satisfy `p` is less than or equal to the supremum of `f` over all elements that satisfy `q`. This result is a demonstration of monotonicity in the context of order theory and lattice theory.

For any complete lattice `α` and function `f` from a type `ι` to `α`, if `p` implies `q` for elements of `ι`, then the supremum of `f` over elements satisfying `p` is less than or equal to the supremum over elements satisfying `q`.


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

The theorem `tsum_eq_single` states that for any types `α` and `β`, given an addition commutative monoid on `α` and a topology on `α`, and a function `f` from `β` to `α`, for any element `b` in `β`, if the function `f` maps every other element of `β` except `b` to zero, then the infinite summation over all elements `b` in `β` of `f(b)` is equal to `f(b)`. In other words, in an infinite sum, if all terms are zero except for one term, then the sum equals to the value of that one term.

For any commutative monoid addition on type `α`, topology on `α`, and function `f` from type `β` to `α`, if for all `b' in β \ {b}, `f(b') = 0`, then `∑(b ∈ β) f(b) = f(b)`.


theorem PNat.gcd_props :
    ∀ (a b : ℕ+),
      let d := PNat.gcdD a b;
      let w := PNat.gcdW a b;
      let x := PNat.gcdX a b;
      let y := PNat.gcdY a b;
      let z := PNat.gcdZ a b;
      let a' := PNat.gcdA' a b;
      let b' := PNat.gcdB' a b;
      w * z = Nat.succPNat (x * y) ∧
        a = a' * d ∧
          b = b' * d ∧
            z * a' = Nat.succPNat (x * ↑b') ∧
              w * b' = Nat.succPNat (y * ↑a') ∧ ↑z * ↑a = x * ↑b + ↑d ∧ ↑w * ↑b = y * ↑a + ↑d :=
  by sorry

This theorem, `PNat.gcd_props`, asserts a collection of properties about the greatest common divisor operation on positive natural numbers. For every two positive natural numbers `a` and `b`, it provides a set of equations involving the results of several functions applied to `a` and `b`.

Firstly, it states that the product of the final values of `w` and `z` from the extended GCD operation is equal to one plus the product of the final values of `x` and `y`. Secondly, it states that `a` and `b` are each equal to the product of the final value of `a / d` (`a'`) or `b / d` (`b'`) and the GCD `d` respectively.

It also provides two equations relating `a'`, `x`, `b'`, `y`, `z`, `w` with conversions of `b'` and `a'` to natural numbers. Lastly, it asserts two equations that relate `z`, `a`, `x`, `b`, `d` and `w`, `b`, `y`, `a`, `d`. These equations are key properties in the theory of greatest common divisors.

The theorem `PNat.gcd_props` in Lean 4 establishes the properties of the greatest common divisor `d` of positive natural numbers `a` and `b`, including the equations: `a * d * z + b * d * w = a' * b' + 1`, `a = a' * d` and `b = b' * d`, where `a'`, `b'`, `x`, `y`, `z`, `w` are the results of the extended GCD algorithm.


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

This theorem, `and_left_comm`, states that for any three propositions `a`, `b`, and `c`, the conjunction of `a`, `b`, and `c` is logically equivalent to the conjunction of `b`, `a`, and `c`. In other words, the order in which the first two propositions are arranged in this three-part conjunction does not affect the truth value of the whole statement. This essentially speaks to the commutative property of the logical "AND" operation.

For all propositions a, b, and c, a ∧ b is logically equivalent to b ∧ a.


theorem Codisjoint.top_le :
    ∀ {α : Type u_1} [inst : SemilatticeSup α] [inst_1 : OrderTop α] {a b : α}, Codisjoint a b → ⊤ ≤ a ⊔ b := by sorry

The theorem `Codisjoint.top_le` states that for any type `α` that forms a semilattice with a supremum operation and has a top element, and any two elements `a` and `b` of `α`, if `a` and `b` are codisjoint (meaning the supremum of `a` and `b` is the top element), then the top element is less than or equal to the supremum of `a` and `b`. This essentially guarantees that the supremum of any two codisjoint elements in such a structure is the top element.

For any semilattice with a top element `α`, if `a` and `b` are codisjoint elements of `α`, then the top element is less than or equal to their supremum.


/-- A set `s` is in the neighbourhood of `a` iff there is some basis set `t`, which
contains `a` and is itself contained in `s`.  -/
theorem TopologicalSpace.IsTopologicalBasis.mem_nhds_iff :
    ∀ {α : Type u} [t : TopologicalSpace α] {a : α} {s : Set α} {b : Set (Set α)},
      TopologicalSpace.IsTopologicalBasis b → (s ∈ nhds a ↔ ∃ t ∈ b, a ∈ t ∧ t ⊆ s) :=
  by sorry

This theorem states that in a given topological space `α`, a set `s` is in the neighborhood of an element `a` if and only if there exists some basis set `t` (from a collection `b` that forms a topological basis), such that `a` is contained in `t` and `t` itself is contained in `s`. In other words, `s` is a neighborhood of `a` precisely when `s` contains a basis set `t` that includes `a`. Here, a 'neighborhood' of `a` is defined as a set that contains an open set around `a`, and a 'topological basis' is a collection of sets whose union forms the topology and that intersects to form any given open set in the topology.

A set is a neighborhood of an element in a topological space if and only if it contains a basis set that includes that element.


theorem Array.foldl_eq_foldl_data :
    ∀ {β : Type u_1} {α : Type u_2} (f : β → α → β) (init : β) (arr : Array α),
      Array.foldl f init arr 0 = List.foldl f init arr.data :=
  by sorry

The theorem `Array.foldl_eq_foldl_data` states that for all types `β` and `α`, and for any function `f : β → α → β`, initial value `init : β`, and array `arr : Array α`, the left fold function `Array.foldl` applied on the array `arr` starting from the 0th index is equal to the left fold function `List.foldl` applied on the list of data `arr.data` with the same function `f` and initial value `init`. This means that folding from the left over an array gives the same result as folding from the left over its corresponding list of data.

For any type `β`, function `f : β → β → β`, initial value `init : β`, array `arr : Array α`, the left fold operation `Array.foldl f init arr` equals the left fold operation `List.foldl f init (arr.data : List α)`.


/-- A function is strongly measurable if and only if it is measurable and has separable
range.  -/
theorem stronglyMeasurable_iff_measurable_separable :
    ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {m : MeasurableSpace α} [inst : TopologicalSpace β]
      [inst_1 : TopologicalSpace.PseudoMetrizableSpace β] [inst_2 : MeasurableSpace β] [inst_3 : BorelSpace β],
      MeasureTheory.StronglyMeasurable f ↔ Measurable f ∧ TopologicalSpace.IsSeparable (Set.range f) :=
  by sorry

This theorem states that for any function 'f' from type 'α' to type 'β', with 'α' being a measurable space and 'β' being a topologically space, a pseudo-metrizable space, a measurable space, and a Borel space, the function 'f' is strongly measurable if and only if it is a measurable function and its range is a separable set. In terms of mathematics, a function is strongly measurable if it can be approximated by a sequence of simple functions, it is measurable if the preimage of every measurable set is also measurable, and its range is separable if it is included in the closure of a countable set.

A function from a measurable space to a separable, Borel subspace of a topological space is strongly measurable if and only if it is measurable.


theorem List.Forall₂.brecOn :
    ∀ {α : Type u_1} {β : Type u_2} {R : α → β → Prop}
      {motive : (a : List α) → (a_1 : List β) → List.Forall₂ R a a_1 → Prop} {a : List α} {a_1 : List β}
      (x : List.Forall₂ R a a_1),
      (∀ (a : List α) (a_2 : List β) (x : List.Forall₂ R a a_2), List.Forall₂.below x → motive a a_2 x) →
        motive a a_1 x :=
  by sorry

This theorem, `List.Forall₂.brecOn`, states that for any two lists of types `α` and `β` respectively, and a relation `R` between elements of `α` and `β`, if `R` holds for all corresponding pairs of elements from the two lists, then for any property or motive `motive` that depends on a pair of lists and the fact that `R` holds for all corresponding elements, if this `motive` holds for any pair of lists and their relation whenever it holds for all 'smaller' pairs (this is captured by the `List.Forall₂.below` predicate), then it holds for the original pair of lists. This is a kind of induction principle for relations over pairs of lists.

If a relation holds between corresponding elements of two lists and it is closed under the `List.Forall₂.below` predicate, then it holds for the entire pair of lists.


theorem Array.getElem_eq_data_get :
    ∀ {α : Type u_1} {i : ℕ} (a : Array α) (h : i < Array.size a), a[i] = List.get a.data { val := i, isLt := h } := by
  sorry

This theorem states that for any type `α`, any natural number `i`, and any array `a` of type `α`, if `i` is less than the size of `a`, then the `i`th element of `a` is equal to the `i`th element of the list `a.data`. The index `i` is used with proof `h` that `i` is less than the size of the array. This is a fundamental property that links the array structure with its underlying list data structure in Lean 4.

For any array `a` of type `α` and natural number `i`, if `i` is less than the array size, then the `i`th element of `a` equals the `i`th element of `a.data`.


theorem closedEmbedding_subtype_val :
    ∀ {X : Type u} [inst : TopologicalSpace X] {p : X → Prop}, IsClosed {a | p a} → ClosedEmbedding Subtype.val := by
  sorry

This theorem states that for any type `X` endowed with a topological structure, and any property `p` on `X`, if the set of elements in `X` that satisfy `p` is a closed set, then the function `Subtype.val` is a closed embedding. In other words, `Subtype.val` function, which extracts the underlying element from a subtype where the element satisfies the property `p`, preserves the topological structure when the property `p` defines a closed set.

If a subtype of a topological space, defined by a closed property, is a closed set, then its inclusion map is a closed embedding.


theorem OrderIso.map_sInf_eq_sInf_symm_preimage :
    ∀ {α : Type u_1} {β : Type u_2} [inst : CompleteLattice α] [inst_1 : CompleteLattice β] (f : α ≃o β) (s : Set α),
      f (sInf s) = sInf (⇑(OrderIso.symm f) ⁻¹' s) :=
  by sorry

The theorem `OrderIso.map_sInf_eq_sInf_symm_preimage` states that for any two types `α` and `β` that are complete lattices and an order isomorphism `f` from `α` to `β`, the smallest element (`sInf`) of a set `s` of type `α` mapped through `f` is equal to the smallest element of the preimage of `s` under the inverse (`OrderIso.symm f`) of `f`. In other words, applying the order isomorphism to the smallest element of a set in `α` gives the same result as finding the smallest element of the corresponding set in `β`.

Given complete lattices α and β and an order isomorphism f : α ↔ β, the smallest element of the image of a subset s of α under f is equal to the smallest element of the preimage of s under the inverse of f.


theorem CategoryTheory.Limits.Types.limitConeIsLimit.proof_1 :
    ∀ {J : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} J] (F : CategoryTheory.Functor J TypeMax)
      (s : CategoryTheory.Limits.Cone F) (v : s.pt) {j j' : J} (f : j ⟶ j'),
      CategoryTheory.CategoryStruct.comp (s.π.app j) (F.map f) v = s.π.app j' v :=
  by sorry

The theorem `CategoryTheory.Limits.Types.limitConeIsLimit.proof_1` states that for any category `J` and any functor `F` from `J` to `TypeMax`, given a cone `s` of `F` and an element `v` of the vertex of the cone, if there is a morphism `f` from `j` to `j'` in `J`, then the composition of the morphism `s.π.app j` in the category of types with the mapping of `f` under `F` applied to `v`, is equal to the morphism `s.π.app j'` applied to `v`. In simpler terms, it validates the commutativity of the diagram involving the cone, the functor and the morphism in the category.

For any cone `s` in a category `J` and functor `F` from `J` to `TypeMax`, if `v` is an element of the vertex of `s` and `f` is a morphism in `J`, then `F(f)(s.π.app j v) = s.π.app j' v` holds in the category of types.


theorem Set.exists_eq_singleton_iff_nonempty_subsingleton :
    ∀ {α : Type u} {s : Set α}, (∃ a, s = {a}) ↔ Set.Nonempty s ∧ Set.Subsingleton s := by sorry

This theorem, `Set.exists_eq_singleton_iff_nonempty_subsingleton`, states that for any set `s` of a given type `α`, there exists an element `a` such that `s` is the singleton set containing only `a` if and only if `s` is both non-empty and a subsingleton set. Here, a set being non-empty (`Set.Nonempty`) means there exists at least one element in the set, and a set being a subsingleton (`Set.Subsingleton`) means that it contains at most one distinct element. In other words, a set is equivalent to a singleton set if it is non-empty and all its elements are the same.

A set is equal to a singleton set if and only if it is both non-empty and has at most one element.


theorem Filter.tendsto_add_atTop_iff_nat :
    ∀ {α : Type u_3} {f : ℕ → α} {l : Filter α} (k : ℕ),
      Filter.Tendsto (fun n => f (n + k)) Filter.atTop l ↔ Filter.Tendsto f Filter.atTop l :=
  by sorry

The theorem `Filter.tendsto_add_atTop_iff_nat` states that for any type `α`, any function `f` from natural numbers to `α`, any filter `l` on `α`, and any natural number `k`, the function `f` tends to `l` as its argument tends to infinity if and only if the function `f` composed with the addition of `k` also tends to `l` as its argument tends to infinity. In other words, adding a constant `k` to the argument of `f` does not change the limiting behavior of the function as the argument approaches infinity.

For any type α, function f from natural numbers to α, filter l on α, and natural number k, the function f tends to l as its argument tends to infinity if and only if the function f composed with the constant function adding k also tends to l as its argument tends to infinity.


theorem LocallyCompactSpace.of_hasBasis :
    ∀ {X : Type u_1} [inst : TopologicalSpace X] {ι : X → Type u_4} {p : (x : X) → ι x → Prop}
      {s : (x : X) → ι x → Set X},
      (∀ (x : X), Filter.HasBasis (nhds x) (p x) (s x)) →
        (∀ (x : X) (i : ι x), p x i → IsCompact (s x i)) → LocallyCompactSpace X :=
  by sorry

This theorem, named `LocallyCompactSpace.of_hasBasis`, states that for any type `X` equipped with a topological space structure and a family of sets `s` indexed by a type `ι` that depends on `X` and a predicate `p` on each index, if every neighborhood filter (set of neighborhoods) of each point `x` in `X` has a basis consisting of sets for which the predicate `p` holds and each of these sets is compact, then `X` is a locally compact space.

In simpler terms, it means that if every point in a topological space `X` has a basis of its neighborhoods consisting of compact sets satisfying some property, then `X` itself is a locally compact space. A locally compact space is a topological space where every point has a compact neighborhood.

If every point in a topological space `X` has a neighborhood basis consisting of compact sets `s` satisfying predicate `p`, then `X` is a locally compact space.


theorem ENNReal.ofReal_eq_coe_nnreal : ∀ {x : ℝ} (h : 0 ≤ x), ENNReal.ofReal x = ↑{ val := x, property := h } := by
  sorry

The theorem `ENNReal.ofReal_eq_coe_nnreal` states that for any real number `x` that is nonnegative (i.e., `0 ≤ x`), the function `ENNReal.ofReal` applied to `x` is equal to the coercion of the nonnegative real number represented by `x` and its nonnegativity property. In other words, for any nonnegative real number `x`, the operation of "turning a real number into a nonnegative extended real number" performed by `ENNReal.ofReal` is equivalent to directly constructing a nonnegative real number with value `x` and proving its nonnegativity.

For any non-negative real number `x`, `ENNReal.ofReal x = ⟦x, 0 ≤ x⟧`.


AEMeasurable.restrict

theorem AEMeasurable.restrict :
    ∀ {α : Type u_2} {β : Type u_3} {m0 : MeasurableSpace α} [inst : MeasurableSpace β] {f : α → β}
      {μ : MeasureTheory.Measure α}, AEMeasurable f μ → ∀ {s : Set α}, AEMeasurable f (μ.restrict s) :=
  by sorry

This theorem states that, for any given types `α` and `β`, with `α` being a measurable space, and any function `f : α → β`, if `f` is almost everywhere measurable with respect to a measure `μ` on `α`, then `f` is also almost everywhere measurable with respect to the restriction of `μ` to any subset `s` of `α`. In other words, if a function almost everywhere equals a measurable function with respect to a certain measure, it will still almost everywhere equal a measurable function when that measure is restricted to a subset.

If `f : α → β` is almost everywhere measurable with respect to measure `μ` on `α`, then `f` is almost everywhere measurable with respect to the restriction of `μ` to any subset `s` of `α`.


theorem neg_lt_neg : ∀ {α : Type u} [inst : OrderedAddCommGroup α] {a b : α}, a < b → -b < -a := by sorry

This theorem, `neg_lt_neg`, states that for any type `α` that belongs to the ordered additive commutative group, given two elements `a` and `b` of this type, if `a` is less than `b`, then `-b` is less than `-a`. In other words, it expresses that in the context of an ordered additive commutative group, negating the elements reverses the order relation.

For all ordered additive commutative groups (α, <) and elements a, b ∈ α, if a < b then -b < -a.


theorem RingHom.id_comp :
    ∀ {α : Type u_2} {β : Type u_3} {x : NonAssocSemiring α} {x_1 : NonAssocSemiring β} (f : α →+* β),
      RingHom.comp (RingHom.id β) f = f :=
  by sorry

The theorem `RingHom.id_comp` states that for any two types `α` and `β` which are non-associative semirings, and any ring homomorphism `f` from `α` to `β`, the composition of `f` with the identity ring homomorphism on `β` is equal to `f`. In other words, composing any ring homomorphism with the identity function on the codomain does not change the original homomorphism. This property is one of the defining features of identity functions in the context of ring theory.

For any non-associative semirings `α` and `β`, and any ring homomorphism `f` from `α` to `β`, `f ∘ id_β = f`, where `id_β` is the identity ring homomorphism on `β`.


theorem MeasureTheory.weightedSMul_union :
    ∀ {α : Type u_1} {F : Type u_3} [inst : NormedAddCommGroup F] [inst_1 : NormedSpace ℝ F] {m : MeasurableSpace α}
      {μ : MeasureTheory.Measure α} (s t : Set α),
      MeasurableSet s →
        MeasurableSet t →
          ↑↑μ s ≠ ⊤ →
            ↑↑μ t ≠ ⊤ →
              s ∩ t = ∅ →
                MeasureTheory.weightedSMul μ (s ∪ t) =
                  MeasureTheory.weightedSMul μ s + MeasureTheory.weightedSMul μ t :=
  by sorry

The theorem `MeasureTheory.weightedSMul_union` states that, given a measure space `α`, a normed add commutative group `F` over the real numbers, and a measure `μ` over `α`, for any two measurable sets `s` and `t` within `α` such that their measures are not infinite and they have no common elements (i.e., their intersection is empty), then the weighted sum of the measure of the union of `s` and `t` (which is calculated by applying the continuous linear map `MeasureTheory.weightedSMul`) is equal to the sum of the weighted sums of the measures of `s` and `t` individually. The weighting in this context is performed by the measure function `μ`.

For measurable sets `s` and `t` in a measure space `α` with finite, non-empty, disjoint measures under a measure function `μ` over `α` and a normed add commutative group `F` over the real numbers, `MeasureTheory.weightedSMul (μ, s ∪ t) = MeasureTheory.weightedSMul (μ, s) + MeasureTheory.weightedSMul (μ, t)`.


theorem add_self : ∀ {α : Type u_1} [inst : BooleanRing α] (a : α), a + a = 0 := by sorry

This theorem states that for any type `α` which forms a Boolean ring, the sum of any element `a` from `α` with itself (i.e., `a + a`) equals zero. In mathematical terms, for all `a` in a Boolean ring, `a + a = 0`.

In a Boolean ring, the sum of any element with itself equals zero. (i.e., for all `a` in a Boolean ring, `a + a = 0`)


AffineSubspace.WSameSide.symm

/-- **Alias** of the forward direction of `AffineSubspace.wSameSide_comm`. -/
theorem AffineSubspace.WSameSide.symm :
    ∀ {R : Type u_1} {V : Type u_2} {P : Type u_4} [inst : StrictOrderedCommRing R] [inst_1 : AddCommGroup V]
      [inst_2 : Module R V] [inst_3 : AddTorsor V P] {s : AffineSubspace R P} {x y : P},
      AffineSubspace.WSameSide s x y → AffineSubspace.WSameSide s y x :=
  by sorry

The theorem `AffineSubspace.WSameSide.symm` states that for any strict ordered commutative ring `R`, any additive commutative group `V`, any module `R` over `V`, and any affine torsor `P` over `V`, if the points `x` and `y` are weakly on the same side of an affine subspace `s` (`AffineSubspace.WSameSide s x y`), then the points `y` and `x` are also weakly on the same side of the same affine subspace (`AffineSubspace.WSameSide s y x`).

The "weakly on the same side" condition here means that there exist points `p₁` and `p₂` in the subspace `s` such that the vectors `x -ᵥ p₁` and `y -ᵥ p₂` point in the same or opposite directions (they are on the "same ray").

If points `x` and `y` are weakly on the same side of an affine subspace `s` in a commutative ring `R` with an additive commutative group `V` and a module `R` over `V`, then `y` and `x` are also weakly on the same side of `s`.


theorem Nat.lt_pow_self : ∀ {a : ℕ}, 1 < a → ∀ (n : ℕ), n < a ^ n := by sorry

This theorem states that for any natural number 'a' greater than 1, and for any natural number 'n', 'n' is less than 'a' to the power of 'n'. In other words, the value of 'n' is always less than the value of 'a' raised to the 'n'-th power, given 'a' is greater than one.

For any natural number $a > 1$, and any natural number $n$, $n < a^n$.


theorem Polynomial.X_pow_mul :
    ∀ {R : Type u} [inst : Semiring R] {p : Polynomial R} {n : ℕ}, Polynomial.X ^ n * p = p * Polynomial.X ^ n := by
  sorry

The theorem `Polynomial.X_pow_mul` states that for any type `R` that is a semiring, any polynomial `p` of type `R`, and any natural number `n`, the product of `Polynomial.X` raised to the power `n` and `p` is equal to the product of `p` and `Polynomial.X` raised to the power `n`. In simple terms, this theorem asserts the commutativity of multiplication between a power of the polynomial variable `Polynomial.X` and any other polynomial in a semiring.

For any semiring `R`, any polynomial `p` over `R`, and any natural number `n`, the power `p` of the indeterminate `X` in the polynomial ring `Polynomial R` commutes with multiplication by `p`, i.e., `X^n * p = p * X^n`.


theorem Nat.add_mod_right : ∀ (x z : ℕ), (x + z) % z = x % z := by sorry

This theorem states that for any two natural numbers `x` and `z`, the result of the operation `(x + z) % z` is equal to `x % z`. In other words, adding a multiple of `z` (which is `x + z`) to `x` doesn't change the remainder when `x` is divided by `z`. This theorem reflects the property of modular arithmetic.

For any natural numbers x and z, (x + z) % z = x % z.


theorem Set.mem_prod :
    ∀ {α : Type u} {β : Type v} {s : Set α} {t : Set β} {p : α × β}, p ∈ s ×ˢ t ↔ p.1 ∈ s ∧ p.2 ∈ t := by sorry

The theorem `Set.mem_prod` states that for any types `α` and `β`, and any sets `s` of type `α` and `t` of type `β`, and any pair `p` of type `(α, β)`, `p` is an element of the Cartesian product of sets `s` and `t` if and only if the first element of `p` is in `s` and the second element of `p` is in `t`. In mathematical terms, this can be represented as `(p ∈ s × t) ⇔ (p.1 ∈ s ∧ p.2 ∈ t)`, where `s × t` denotes the Cartesian product of sets `s` and `t`, `p.1` and `p.2` denote the first and second elements of the pair `p`, and `∈`, `∧`, and `⇔` denote elementhood, logical conjunction (and), and logical equivalence (if and only if), respectively.

The theorem `Set.mem_prod` asserts that for any sets `s` and `t` and pair `p`, `p ∈ s × t` if and only if `p.1 ∈ s` and `p.2 ∈ t`.


theorem continuous_zero :
    ∀ {M : Type u_3} {X : Type u_5} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace M] [inst_2 : Zero M],
      Continuous 0 :=
  by sorry

This theorem states that for any two types `M` and `X`, where `X` is a topological space, `M` is a topological space and also has a zero element, the zero function (which assigns the zero element of `M` to every element of `X`) is continuous. In the context of mathematics, a function is continuous if the preimage of every open set is open. Here, the zero function is such that regardless of the input from `X`, the output is always the zero element of `M`.

For any topological spaces `X` and `M` with a zero element, the zero function from `X` to `M` is continuous.


theorem Matrix.zero_mul :
    ∀ {l : Type u_1} {m : Type u_2} {n : Type u_3} {α : Type v} [inst : NonUnitalNonAssocSemiring α]
      [inst_1 : Fintype m] (M : Matrix m n α), 0 * M = 0 :=
  by sorry

The theorem `Matrix.zero_mul` states that for any type `α` that is a NonUnitalNonAssocSemiring, and for any types `l`, `m`, `n`, if `M` is a matrix of type `α` with rows indexed by `m` and columns indexed by `n`, then the product of `0` and `M` is `0`. Here, `Fintype m` denotes that `m` is a finite type. Essentially, this theorem is saying that for any matrix `M`, its multiplication by zero results in the zero matrix, similar to the mathematical principle that any number multiplied by zero equals zero.

For any non-unital, non-associative semiring type `α` and finite types `m` and `n`, the product of a matrix `M` of type `α` with rows indexed by `m` and columns indexed by `n`, and the scalar `0` of type `α`, is the zero matrix.


theorem List.Perm.subperm_left :
    ∀ {α : Type u_1} {l l₁ l₂ : List α}, List.Perm l₁ l₂ → (List.Subperm l l₁ ↔ List.Subperm l l₂) := by sorry

The theorem `List.Perm.subperm_left` states that for any type `α` and any three lists of this type `l`, `l₁`, and `l₂`, if `l₁` is a permutation of `l₂`, then `l` is a sublist of a permutation of `l₁` if and only if `l` is a sublist of a permutation of `l₂`. This theorem is a key property of the 'subperm' relation, which is analogous to the subset relation but takes into account the multiplicities of elements in the lists, and is used for the `≤` relation on multisets.

For any type `α`, if `l₁` is a permutation of `l₂`, then `l` is a sublist of a permutation of `l₁` if and only if `l` is a sublist of a permutation of `l₂`.


theorem Mathlib.Algebra.GroupWithZero.Basic._auxLemma.5 :
    ∀ {M₀ : Type u_2} [inst : MonoidWithZero M₀] {a : M₀} {n : ℕ} [inst_1 : NoZeroDivisors M₀] [inst_2 : Nontrivial M₀],
      (a ^ n = 0) = (a = 0 ∧ n ≠ 0) :=
  by sorry

This theorem, `Mathlib.Algebra.GroupWithZero.Basic._auxLemma.5`, states that for any type `M₀` that is a monoid with zero, given an element `a` of `M₀` and a natural number `n`, and assuming that there are no zero divisors and the domain is nontrivial, `a` raised to the power of `n` equals zero if and only if `a` equals zero and `n` is not zero. In mathematical terms, this is saying that in a monoid with no zero divisors, a power of a number is zero if and only if the base is zero and the exponent is non-zero.

In a monoid with no zero divisors and a nontrivial domain, an element raised to the power of a non-zero natural number equals zero if and only if the element is itself zero.


theorem Real.rpow_inv_rpow : ∀ {x y : ℝ}, 0 ≤ x → y ≠ 0 → (x ^ y⁻¹) ^ y = x := by sorry

This theorem states that for all real numbers 'x' and 'y', if 'x' is nonnegative and 'y' is nonzero, then raising 'x' to the power of the reciprocal of 'y', and then raising the result to the power of 'y', gives back 'x'. This equation can be expressed mathematically as: `(x^(1/y))^y = x`.

For all nonnegative real numbers x and nonzero y, (x^(1/y))^y = x.


theorem Nat.floor_le :
    ∀ {α : Type u_2} [inst : LinearOrderedSemiring α] [inst_1 : FloorSemiring α] {a : α}, 0 ≤ a → ↑⌊a⌋₊ ≤ a := by sorry

This theorem states that, for any type `α` that is a linearly ordered semiring and has a floor semiring structure, and for any non-negative element `a` of type `α`, the floor of `a` is less than or equal to `a`. Here, the floor function `⌊a⌋₊` is a function that rounds `a` down to the nearest whole number. In LaTeX mathematics notation, this is equivalent to saying ∀a ∈ α, 0 ≤ a → ⌊a⌋ ≤ a.

For any linearly ordered semiring `α` with a floor semiring structure, the floor function applied to any non-negative element `a` of `α` is less than or equal to `a`: `∀a ∈ α. 0 ≤ a → ⌊a⌋ ≤ a`.


theorem UniqueFactorizationMonoid.prime_of_factor :
    ∀ {α : Type u_1} [inst : CancelCommMonoidWithZero α] [inst_1 : UniqueFactorizationMonoid α] {a : α},
      ∀ x ∈ UniqueFactorizationMonoid.factors a, Prime x :=
  by sorry

The theorem `UniqueFactorizationMonoid.prime_of_factor` states that for any type `α` that forms a cancellation commutative monoid with zero and has unique factorization, every element `x` that is a factor (as determined by `UniqueFactorizationMonoid.factors`) of a given element `a` of `α`, is a prime element. Here, a prime element `p` is defined as an element that is not zero, is not a unit, and has the property that if it divides the product of two elements `a` and `b`, then it must divide either `a` or `b`.

If `α` is a cancellation commutative monoid with zero and unique factorization, then every non-zero, non-unit factor `x` of an element `a` in `α` is a prime element.


theorem Nat.choose_symm : ∀ {n k : ℕ}, k ≤ n → Nat.choose n (n - k) = Nat.choose n k := by sorry

This theorem states that for any two natural numbers `n` and `k`, where `k` is less than or equal to `n`, the number of `k`-element subsets in an `n`-element set (denoted as `Nat.choose n k`) is the same as the number of `(n - k)`-element subsets in the same `n`-element set (denoted as `Nat.choose n (n - k)`). In other words, the binomial coefficient ${n \choose k}$ is equal to ${n \choose n-k}$ for any `n` and `k` such that `k` is less than or equal to `n`. This represents the symmetry property of binomial coefficients.

For any natural number `n` and `k` with `k` less than or equal to `n`, the number of `k`-element subsets in an `n`-element set equals the number of `(n - k)`-element subsets, i.e., `Nat.choose n k = Nat.choose n (n - k)`.


Partrec.bind

theorem Partrec.bind :
    ∀ {α : Type u_1} {β : Type u_2} {σ : Type u_4} [inst : Primcodable α] [inst_1 : Primcodable β]
      [inst_2 : Primcodable σ] {f : α →. β} {g : α → β →. σ},
      Partrec f → Partrec₂ g → Partrec fun a => Part.bind (f a) (g a) :=
  by sorry

The theorem `Partrec.bind` states that for all types `α`, `β`, and `σ` that have instances of `Primcodable`, and for all partial functions `f` from `α` to `β` and `g` from `α` and `β` to `σ`, if `f` is a partial recursive function (`Partrec`) and `g` is a two argument partial recursive function (`Partrec₂`), then the function which, for each `a`, binds the result of `f(a)` to `g(a)` using the `Part.bind` operation, is also a partial recursive function. This means that the composition of two partial recursive functions via the bind operation retains the property of being partial recursive.

If `f` is a partial recursive function from `α` to `β` and `g` is a two-argument partial recursive function from `α × β` to `σ`, then the function `x ↔→ y. g (f x)` is partial recursive. (Here, `↔→` denotes the bind operation in Lean.)


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

The theorem `IsClosed.closure_subset` states that for any set `s` of type `X` in a topological space, if `s` is a closed set, then the closure of `s` is a subset of `s`. Here, the closure of a set is defined as the smallest closed set containing that set. This theorem essentially tells us that when our original set is already closed, its closure is not any larger than the set itself.

If `s` is a closed subset of a topological space, then its closure is contained in `s`.


theorem Nat.cast_withBot : ∀ (n : ℕ), ↑n = ↑n := by sorry

This theorem states that for any natural number `n`, the process of casting or converting `n` to another type and back to a natural number does not change the value of `n`. In other words, the cast operation is idempotent for natural numbers.

For all natural numbers `n`, converting `n` to another type and then back to a natural number results in the original natural number `n`.


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

This theorem, named `Set.pair_comm`, asserts the commutativity of a pair of elements from a given set in Lean 4. Specifically, for any type `α` and any two elements `a` and `b` of type `α`, the set `{a, b}` is equal to the set `{b, a}`. This means that the order of elements does not matter in the set formation - a mathematical concept that corresponds with the principle of commutativity in set theory.

For any set `α` and any two elements `a` and `b` in `α`, the sets `{a, b}` and `{b, a}` are equal.


/-- precompose an equation between morphisms by another morphism  -/
theorem CategoryTheory.whisker_eq :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z : C} (f : X ⟶ Y) {g h : Y ⟶ Z},
      g = h → CategoryTheory.CategoryStruct.comp f g = CategoryTheory.CategoryStruct.comp f h :=
  by sorry

The theorem `CategoryTheory.whisker_eq` states that for any category `C`, and given objects `X`, `Y`, and `Z` of the category, and a morphism `f` from `X` to `Y` and two morphisms `g` and `h` from `Y` to `Z`, if `g` equals `h`, then the composition of `f` with `g` is equal to the composition of `f` with `h`. In other words, if two morphisms from `Y` to `Z` are equal, precomposing them with the same morphism from `X` to `Y` results in equal morphisms from `X` to `Z`. This theorem is about the compatibility of morphism composition with equality in a category.

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


theorem covariantClass_le_of_lt :
    ∀ (M : Type u_1) (N : Type u_2) (μ : M → N → N) [inst : PartialOrder N]
      [inst_1 : CovariantClass M N μ fun x x_1 => x < x_1], CovariantClass M N μ fun x x_1 => x ≤ x_1 :=
  by sorry

This theorem states that for any two types `M` and `N` and a function `μ` from `M` to `N` to `N`, if `N` has a partial order and `μ` is a covariant class with respect to a strict order (`<`), then `μ` is also a covariant class with respect to a nonstrict order (`≤`). In other words, if the function `μ` preserves the strict order of elements in `N` when applied with elements from `M`, it also preserves the nonstrict order.

If `μ` is a covariant function from type `M` to type `N` with respect to the strict order `<` on `N`, then it is also covariant with respect to the non-strict order `≤` on `N`.


theorem add_vadd_comm :
    ∀ {α : Type u_6} {β : Type u_7} [inst : Add β] [inst_1 : VAdd α β] [inst_2 : VAddCommClass α β β] (s : α) (x y : β),
      x + (s +ᵥ y) = s +ᵥ (x + y) :=
  by sorry

This theorem states that for any types `α` and `β`, where `β` is an additive type and `α` and `β` form a vector addition structure that respects commutativity, the operation of adding a scalar `s` from `α` to a `β` value `y` and then adding that result to another `β` value `x` is the same as adding `x` and `y` first and then adding the scalar `s`. In mathematical notation, it asserts that for any `x`, `y` in `β` and `s` in `α`, we have `x + (s + y) = s + (x + y)`.

For any additive types `β` and scalars `α`, the distributive property holds: `x + (s + y) = s + (x + y)` for all `x, y in β` and `s in α`.


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

This theorem states that for any two types α and β, where both α and β are seminormed add groups, and there exists a zero-class scalar multiplication and bounded scalar multiplication between α and β; for any elements r of type α and x of type β, the non-negative seminorm of the scalar multiplication of r and x is less than or equal to the product of the non-negative seminorms of r and x. Here, ‖r‖₊ and ‖x‖₊ denote the non-negative seminorms of r and x respectively, and r • x denotes the scalar multiplication of r and x.

For any seminormed add groups α and β with compatible scalar multiplications, and for all elements r in α and x in β, the non-negative seminorm of their scalar product is less than or equal to the product of their non-negative seminorms: ||r • x||₊ ≤ ||r||₊ * ||x||₊.


theorem Finset.map_singleton : ∀ {α : Type u_1} {β : Type u_2} (f : α ↪ β) (a : α), Finset.map f {a} = {f a} := by sorry

The theorem `Finset.map_singleton` states that for any types `α` and `β`, for any embedding function `f` from `α` to `β`, and for any element `a` in `α`, the image finset of a singleton finset containing the element `a` under the function `f` is a singleton finset containing the image of `a` under `f`. In more mathematical terms, if we map a singleton set `{a}` in `α` via an embedding `f`, we will get a singleton set `{f(a)}` in `β`.

For any embedding function `f` and any element `a`, the image of the singleton finset `{a}` under `f` is the singleton finset `{f(a)}`.


theorem CategoryTheory.Limits.Multicoequalizer.π_desc :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (I : CategoryTheory.Limits.MultispanIndex C)
      [inst_1 : CategoryTheory.Limits.HasMulticoequalizer I] (W : C) (k : (b : I.R) → I.right b ⟶ W)
      (h :
        ∀ (a : I.L),
          CategoryTheory.CategoryStruct.comp (I.fst a) (k (I.fstFrom a)) =
            CategoryTheory.CategoryStruct.comp (I.snd a) (k (I.sndFrom a)))
      (b : I.R),
      CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.Multicoequalizer.π I b)
          (CategoryTheory.Limits.Multicoequalizer.desc I W k h) =
        k b :=
  by sorry

This theorem, `CategoryTheory.Limits.Multicoequalizer.π_desc`, states that for any category `C`, given a `MultispanIndex` `I`, if `I` has a multicoequalizer, and given an object `W` in `C` and a function `k` which assigns a morphism from `I.right b` to `W` for each `b` in `I.R`, such that for each `a` in `I.L` the composition of `I.fst a` with `k` of `I.fstFrom a` equals the composition of `I.snd a` with `k` of `I.sndFrom a`, then for any `b` in `I.R`, the composition of the multicoequalizer canonical map (from `I.right b` to the multicoequalizer of `I`) with the multicoequalizer desc map (from the multicoequalizer to `W`) equals `k b`. This essentially describes the universal property of the multicoequalizer in a category.

For any category `C`, given a multicoequalizer `(M, η, μ)` of a multispan `(I, L, R, fst, snd)` and a function `k : I.R → C` such that `k ∘ fst = k ∘ snd`, the diagram commutes: `η ∘ I.right → M ∣→ k = k`.


theorem Finset.mem_Ioi :
    ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : LocallyFiniteOrderTop α] {a x : α}, x ∈ Finset.Ioi a ↔ a < x := by
  sorry

The theorem `Finset.mem_Ioi` states that for any type `α` that has a preorder and a locally finite order top, and for any elements `a` and `x` of that type, `x` is an element of the finset `Ioi a` (which is the finset of elements greater than `a`) if and only if `a` is less than `x`. This theorem essentially provides a characterization of the membership of the finset `Ioi a` in terms of the less than relation.

For any type `α` with a preorder and locally finite order top, `x` is an element of the finset `Ioi a` if and only if `a` is strictly less than `x`.


theorem CategoryTheory.ShortComplex.liftCycles_i :
    ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
      (S : CategoryTheory.ShortComplex C) {A : C} (k : A ⟶ S.X₂) (hk : CategoryTheory.CategoryStruct.comp k S.g = 0)
      [inst_2 : CategoryTheory.ShortComplex.HasLeftHomology S],
      CategoryTheory.CategoryStruct.comp (CategoryTheory.ShortComplex.liftCycles S k hk)
          (CategoryTheory.ShortComplex.iCycles S) =
        k :=
  by sorry

This theorem `CategoryTheory.ShortComplex.liftCycles_i` states that in the context of a category `C` with zero morphisms and a short complex `S` within `C` that has left homology, for any object `A` of `C` and a morphism `k` from `A` to `S.X₂` such that the composition of `k` and the morphism `S.g` equals to the zero morphism, the composition of the lift of cycles of `S` with `k` and the inclusion function from `S.cycles` to `S.X₂` is equal to `k`.

In more mathematical terms, if we have `k : A ⟶ S.X₂` such that `k ≫ S.g = 0`, then `(liftCycles S k hk) ≫ iCycles S = k`, where `liftCycles` and `iCycles` are specific morphisms related to the structure of the short complex `S`.

Given a short complex `S` in a category `C` with zero morphisms and left homology, for any morphism `k : A ⟶ S.X₂` with `k ≫ S.g = 0`, the composition of the lift of cycles of `S` with `k` and the inclusion of cycles is equal to `k`.


theorem CochainComplex.prev_nat_zero : ComplexShape.prev (ComplexShape.up ℕ) 0 = 0 := by sorry

The theorem `CochainComplex.prev_nat_zero` states that for the `ComplexShape.up` shape, which is appropriate for cohomology and where the morphism `d : X i ⟶ X j` is only defined when `j = i + 1`, the "previous" index of 0, as defined by the `ComplexShape.prev` function, is 0. This is consistent with the idea that the `ComplexShape.up` shape is modeling cohomology, where there is no "previous" index for the starting point 0.

For the `ComplexShape.up` shape in Lean 4 cohomology, the `ComplexShape.prev` function returns 0 for the index 0.


/-- Sum of a list of elements in an `AddSubmonoid` is in the `AddSubmonoid`. -/
theorem list_sum_mem :
    ∀ {M : Type u_1} {B : Type u_3} [inst : AddMonoid M] [inst_1 : SetLike B M] [inst_2 : AddSubmonoidClass B M] {S : B}
      {l : List M}, (∀ x ∈ l, x ∈ S) → List.sum l ∈ S :=
  by sorry

The theorem `list_sum_mem` states that for any type `M` that forms an additive monoid, and any type `B` that behaves like a set of elements of `M`, if `B` is a class of additive submonoids of `M` and `S` is an instance of `B`, then for any list `l` of elements of `M`, if all elements of `l` are in `S`, the sum of the list `l` is also in `S`. In other words, the sum of a list of elements in an additive submonoid remains within the additive submonoid.

For any additive monoid `M` and set of additive submonoids `B` containing an additive submonoid `S`, if all elements of a list `l` belong to `S`, then the sum of `l` belongs to `S`.


theorem Set.image2_union_inter_subset_union :
    ∀ {α : Type u_1} {β : Type u_3} {γ : Type u_5} {f : α → β → γ} {s s' : Set α} {t t' : Set β},
      Set.image2 f (s ∪ s') (t ∩ t') ⊆ Set.image2 f s t ∪ Set.image2 f s' t' :=
  by sorry

This theorem states that for any types `α`, `β`, and `γ`, and any binary function `f : α → β → γ`, the image under `f` of the union of two sets `s` and `s'` in `α` and the intersection of two sets `t` and `t'` in `β` is a subset of the union of the images under `f` of `s` and `t` and `s'` and `t'`. In mathematical terms, this theorem is expressing the following subset relation: for any sets `s, s'` in `α` and `t, t'` in `β`, we have `f[(s ∪ s') × (t ∩ t')] ⊆ f[s × t] ∪ f[s' × t']`.

For any types `α`, `β`, and `γ`, and any binary function `f : α → β → γ`, the image of the Cartesian product of the union of two sets in `α` and the intersection of two sets in `β` is a subset of the union of the images of each set in `α` and `β` under `f`. In symbols: `f[(s ∪ s') × (t ∩ t')] ⊆ f[s × t] ∪ f[s' × t']`, for any sets `s, s'` in `α` and `t, t'` in `β`.


Asymptotics.IsLittleO.add

theorem Asymptotics.IsLittleO.add :
    ∀ {α : Type u_1} {F : Type u_4} {E' : Type u_6} [inst : Norm F] [inst_1 : SeminormedAddCommGroup E'] {g : α → F}
      {l : Filter α} {f₁ f₂ : α → E'}, f₁ =o[l] g → f₂ =o[l] g → (fun x => f₁ x + f₂ x) =o[l] g :=
  by sorry

The theorem `Asymptotics.IsLittleO.add` states that for any types `α`, `F`, and `E'`, where `F` is a normed space and `E'` is a seminormed additive commutative group, and for any functions `f₁`, `f₂`, `g` from `α` to `F` and a filter `l` on `α`, if `f₁` and `f₂` are both little-o of `g` at `l`, then their sum function `(fun x => f₁ x + f₂ x)` is also little-o of `g` at `l`. In other words, the little-o notation and the sum of functions obey a distributive law in Asymptotic analysis.

If `f₁` and `f₂` are little-o of `g` at filter `l` in the normed space `F` over the seminormed additive commutative group `E'`, then their sum `(fun x => f₁ x + f₂ x)` is also little-o of `g` at filter `l`.


theorem Filter.biInter_mem :
    ∀ {α : Type u} {f : Filter α} {β : Type v} {s : β → Set α} {is : Set β},
      Set.Finite is → (⋂ i ∈ is, s i ∈ f ↔ ∀ i ∈ is, s i ∈ f) :=
  by sorry

The theorem `Filter.biInter_mem` states that for any type `α`, any filter `f` of `α`, any type `β`, and any function `s` mapping from `β` to a set of `α`, and any set `is` of `β`, if the set `is` is finite, then the intersection over all `i` in `is` of the sets `s i` belongs to the filter `f` if and only if for all `i` in `is`, the set `s i` belongs to the filter `f`. In other words, all the sets `s i` for `i` in `is` are in the filter `f` if and only if their intersection is also in `f`, when `is` is a finite set.

If `f` is a filter on type `α`, `s` is a function from type `β` to `α`, and `is` is a finite set of `β`, then `∩ (map s is) ∈ f` if and only if `s i ∈ f` for all `i` in `is`.


theorem MeasureTheory.FiniteMeasure.ennreal_coeFn_eq_coeFn_toMeasure :
    ∀ {Ω : Type u_1} [inst : MeasurableSpace Ω] (ν : MeasureTheory.FiniteMeasure Ω) (s : Set Ω),
      ↑((fun s => (↑↑↑ν s).toNNReal) s) = ↑↑↑ν s :=
  by sorry

This theorem states that for any measurable space `Ω` and any finite measure `ν` on this space, the measure of any set `s` in `Ω` under `ν`, when converted to a non-negative real number and then lifted back into the extended non-negative real number type, is equivalent to the direct measure of the set `s` under `ν`. In other words, the process of measuring a set, converting this measure to a non-negative real number and then lifting back does not alter the measure value in the context of finite measures.

For any measurable space `(Ω, Σ)` and finite measure `ν:` ∀s ∈ Σ, ν(s) = ‛‛ν(s)‛‛ where `ν(s)` is the measure of `s` under `ν` as a real number and `ν(s)` as a non-negative real number under `ν`.


Module.Finite.equiv

theorem Module.Finite.equiv :
    ∀ {R : Type u_1} {M : Type u_4} {N : Type u_5} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
      [inst_3 : AddCommMonoid N] [inst_4 : Module R N] [inst_5 : Module.Finite R M], (M ≃ₗ[R] N) → Module.Finite R N :=
  by sorry

This theorem states that for any two Types `M` and `N`, if `M` is a finite module over a semiring `R`, then if there's a linear equivalence between `M` and `N` (denoted as `M ≃ₗ[R] N`), `N` must also be a finite module over the same semiring `R`. This theorem essentially captures the concept that the property of being a finite module is preserved under linear equivalence.

If `M` and `N` are Types, `M` is a finite module over semiring `R`, and `M ≃ₗ[R] N`, then `N` is also a finite module over semiring `R`.


theorem Mathlib.Analysis.Normed.Group.Basic._auxLemma.36 :
    ∀ {E : Type u_6} [inst : NormedAddGroup E] {a : E}, (‖a‖₊ = 0) = (a = 0) := by sorry

This theorem, from the Mathlib library in Analysis and Normed Group Basics, states that for any type `E` which forms a normed add group, the nonnegative real number norm (`‖a‖₊`) of an element `a` from `E` is equal to zero if and only if the element `a` itself is zero. It essentially connects the concepts of zero norm and the zero element in the context of normed add groups.

For any normed add group `E`, the element `a` in `E` has norm 0 if and only if `a` is the additive identity of `E`.


theorem Finset.sum_boole :
    ∀ {α : Type u_3} {β : Type u_4} {s : Finset α} {p : α → Prop} [inst : AddCommMonoidWithOne β]
      [inst_1 : DecidablePred p], (Finset.sum s fun x => if p x then 1 else 0) = ↑(Finset.filter p s).card :=
  by sorry

The theorem `Finset.sum_boole` states that for any finite set `s` of elements of an arbitrary type `α` and a decidable predicate `p` on `α`, and given the type `β` is an additive commutative monoid with one, the sum over `s` of the function which returns 1 if `p x` holds and 0 otherwise is equal to the cardinality of the subset of `s` for which `p x` holds. In other words, it's calculating the count of elements in the set `s` that satisfy the predicate `p` by summing up 1 for each element that satisfy `p`.

For any finite set `s` of elements from a type `α` and a decidable predicate `p` on `α`, the sum of 1 for each element in `s` for which `p` holds equals the cardinality of the subset of `s` satisfying `p`.


theorem summable_nat_add_iff :
    ∀ {G : Type u_2} [inst : AddCommGroup G] [inst_1 : TopologicalSpace G] [inst_2 : TopologicalAddGroup G] {f : ℕ → G}
      (k : ℕ), (Summable fun n => f (n + k)) ↔ Summable f :=
  by sorry

The theorem `summable_nat_add_iff` states that for any type `G` which forms an additive commutative group, a topological space, and also a topological additive group, and for any function `f` from natural numbers to `G`, and for any natural number `k`, the statement that the function `f` shifted by `k` (i.e., `f(n + k)` for all natural numbers `n`) is summable if and only if the original function `f` is summable. Here, a function is said to be summable if the series formed by its values has a sum in the topological space.

For any additive commutative group G that is a topological space and topological additive group, and for any function f from natural numbers to G, the shifted function f(n + k) is summable if and only if the original function f is summable.


theorem Nat.lt_pred_iff : ∀ {a b : ℕ}, a < Nat.pred b ↔ Nat.succ a < b := by sorry

This theorem, `Nat.lt_pred_iff`, establishes a relationship between the 'less than' operation on natural numbers and the predecessor function. It states that for any two natural numbers `a` and `b`, `a` is less than the predecessor of `b` if and only if the successor of `a` is less than `b`. The predecessor function returns the preceding natural number or zero if the input is zero, while the successor function returns the succeeding natural number.

For all natural numbers a and b, a < Suc(b) if and only if Suc(a) < b, where Suc denotes the successor function.


theorem Real.rpow_add' : ∀ {x y z : ℝ}, 0 ≤ x → y + z ≠ 0 → x ^ (y + z) = x ^ y * x ^ z := by sorry

This theorem states that for any real numbers `x`, `y`, and `z`, given that `x` is nonnegative and the sum of `y` and `z` is nonzero, the power of `x` raised to the sum of `y` and `z` is equal to the product of `x` raised to `y` and `x` raised to `z`. This is essentially the property of exponents $x^{y + z} = x^y * x^z$, extended to real numbers with some restrictions.

For real numbers `x` > 0 and `y`, `z` such that `y + z` ≠ 0, `x^(y + z)` = `x^y * x^z`.


theorem Polynomial.coeff_mul_C :
    ∀ {R : Type u} [inst : Semiring R] (p : Polynomial R) (n : ℕ) (a : R),
      Polynomial.coeff (p * Polynomial.C a) n = Polynomial.coeff p n * a :=
  by sorry

This theorem states that for any semiring `R`, polynomial `p` in `R`, natural number `n`, and element `a` of `R`, the coefficient of `X^n` in the polynomial resulting from multiplying `p` with the constant polynomial `a` is equal to the product of the coefficient of `X^n` in `p` and `a`. In mathematical terms, if `p` is a polynomial and `a` is a constant, then the coefficient of `X^n` in `(p * a)` is `(coefficient of X^n in p) * a`.

For any semiring `R`, polynomial `p(X)` in `R[X]`, and natural number `n`, the coefficient of `X^n` in the product `p(X) * a` is equal to the product of the coefficient of `X^n` in `p(X)` and `a`.


theorem WithTop.not_top_le_coe : ∀ {α : Type u_1} [inst : LE α] (a : α), ¬⊤ ≤ ↑a := by sorry

This theorem states that for any type `α` that has a less than or equal to (`≤`) operation, and any instance `a` of that type, the "top" element (represented by `⊤`) is not less than or equal to the coerced version of `a` (represented by `↑a`). In other words, there's no instance of a type that's greater than or equal to the top element in the "WithTop" type augmentation of `α`. This is somewhat analogous to saying that there's no real number greater than or equal to infinity.

For any type `α` with a `≤` relation and any `a : α`, the top element `⊤` of `WithTop α` is not less than or equal to the coerced `↑a`. In symbols: `∀ (α : Type) [DecidableRelation ≤ α], ∀ a : α, ⊤ : WithTop α <≤ ↑a`.