theorem le_div_iff' : ∀ {α : Type u_2} [inst : LinearOrderedSemifield α] {a b c : α}, 0 < c → (a ≤ b / c ↔ c * a ≤ b) :=
  by sorry

This theorem states that for any type `α` that is a linear ordered semifield and any three elements `a`, `b`, and `c` of this type with `c` being positive, `a` is less than or equal to `b` divided by `c` if and only if `c` times `a` is less than or equal to `b`. Essentially, it is expressing a property of division in the context of ordered fields.

For any linear ordered semifield type `α` and positive elements `a`, `b`, and `c` of `α`, `a ≤ b / c` if and only if `c * a ≤ b`.


theorem Mathlib.Data.Int.CharZero._auxLemma.2 :
    ∀ {α : Type u_1} [inst : AddGroupWithOne α] [inst_1 : CharZero α] {m n : ℤ}, (↑m = ↑n) = (m = n) := by sorry

The theorem states that for any type 'α', if 'α' forms an additive group with unity (a mathematical structure with addition operation, a neutral element "one", and inverse elements), and if 'α' has characteristic zero (in other words, no natural number is equivalent to zero unless it is zero itself), then for any two integers 'm' and 'n', the equality of 'm' and 'n' as elements of 'α' (expressed by ↑m = ↑n) is equivalent to the equality of 'm' and 'n' as integers. Essentially, this theorem bridges the equality in integers and the equality in the abstract type 'α'.

In an additive group with unity and characteristic zero 'α', the equality of integers 'm' and 'n' is equivalent to the equality of their corresponding elements in 'α' (i.e., ↑m = ↑n).


theorem Set.iInter_subset : ∀ {β : Type u_2} {ι : Sort u_4} (s : ι → Set β) (i : ι), ⋂ i, s i ⊆ s i := by sorry

This theorem states that for all types `β` and `ι`, and for a function `s` mapping `ι` to a set of `β`, and for any element `i` of type `ι`, the intersection over all `i` of the sets `s i` is a subset of `s i`. This is a formalization of the standard set theory fact that any set is a subset of its superset, or in other words, any set is included in the union of all sets.

For any function `s` mapping type `ι` to sets of type `β`, and for all `i` in `ι`, the intersection of `s i` over all `i` is a subset of `s i`.


theorem Real.zero_rpow : ∀ {x : ℝ}, x ≠ 0 → 0 ^ x = 0 := by sorry

This theorem states that for any real number 'x' which is not equal to zero, the real number zero raised to the power of 'x' results in zero. In mathematical notation, this is expressed as `0^x = 0` for all `x ≠ 0`.

For any non-zero real number x, 0 raised to the power x equals 0.


Real.IsConjExponent.symm

theorem Real.IsConjExponent.symm : ∀ {p q : ℝ}, Real.IsConjExponent p q → Real.IsConjExponent q p := by sorry

This theorem states that for any two real numbers `p` and `q`, if `p` and `q` are conjugate exponents, then `q` and `p` are also conjugate exponents. That is, the "conjugate exponent" relation is symmetric. In other words, the relation "being conjugate exponents" is reciprocally valid between any pair of real numbers.

If real numbers `p` and `q` are conjugate exponents, then `q` and `p` are also conjugate exponents. (The relation "being conjugate exponents" is symmetric.)


theorem Nat.mul_div_cancel : ∀ (m : ℕ) {n : ℕ}, 0 < n → m * n / n = m := by sorry

This theorem states that for all natural numbers `m` and `n`, if `n` is greater than 0, then the result of multiplying `m` and `n` and then dividing by `n` is equal to `m`. This means that, within the set of natural numbers, multiplication and division by a non-zero number are inverse operations to each other.

For all natural numbers m and n with n > 0, m * (1/n) = m.


theorem Real.cos_periodic : Function.Periodic Real.cos (2 * Real.pi) := by sorry

The theorem `Real.cos_periodic` states that the real cosine function `Real.cos` is periodic with a period of `2 * Real.pi`. In mathematical terms, this means for all real numbers `x`, `Real.cos (x + 2 * Real.pi) = Real.cos x`. This mirrors the well-known property of the cosine function in trigonometry, where the function repeats its values every `2π` intervals.

The real cosine function is periodic with a period of 2π, i.e., Real.cos(x + 2π) = Real.cos(x) for all real numbers x.


theorem Set.mulIndicator_of_mem :
    ∀ {α : Type u_1} {M : Type u_4} [inst : One M] {s : Set α} {a : α},
      a ∈ s → ∀ (f : α → M), Set.mulIndicator s f a = f a :=
  by sorry

This theorem states that for any types `α` and `M`, where `M` is a type with a defined `One` instance, any set `s` of type `α`, and any element `a` of type `α`, if `a` is an element of `s`, then the result of the `mulIndicator` function applied to `s`, a function `f` from `α` to `M`, and `a` is simply `f(a)`. In other words, when `a` belongs to the `s` set, `Set.mulIndicator s f a` is equal to `f a`.

For any set `s` of type `α`, function `f` from `α` to a type `M` with a defined `One` instance, if `a` is an element of `s`, then `Set.mulIndicator s f a = f a`.


OrderBot.bddBelow

/-- When there is a global minimum, every set is bounded below.  -/
theorem OrderBot.bddBelow : ∀ {α : Type u} [inst : Preorder α] [inst_1 : OrderBot α] (s : Set α), BddBelow s := by sorry

This theorem states that, given any type `α` with a preorder and a global minimum (denoted by `OrderBot α`), every set of elements of type `α` is bounded below. In other words, for any set `s` of elements from a type `α` that has a predefined order and a lowest possible value, there exists at least one element in `α` that is less than or equal to every element in `s`. This element represents a lower bound of the set `s`.

Given a preordered type `α` with a global minimum `OrderBot α`, every subset of `α` has a least lower bound.


CategoryTheory.IsSplitMono.mk'

/-- A constructor for `IsSplitMono f` taking a `SplitMono f` as an argument  -/
theorem CategoryTheory.IsSplitMono.mk' :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X Y : C} {f : X ⟶ Y},
      CategoryTheory.SplitMono f → CategoryTheory.IsSplitMono f :=
  by sorry

This theorem provides a constructor for `IsSplitMono f` in the context of Category Theory. It takes as an argument `SplitMono f`. Specifically, for any category `C` with objects of type `X` and `Y` and a morphism `f : X ⟶ Y`, if `f` is a split monomorphism (indicated by `SplitMono f`), then `f` is also an isomorphism in the category `C` where the morphism splits or, in other words, `f` is a split monomorphism (`IsSplitMono f`).

If `f : X ⟶ Y` is a split monomorphism in a category `C`, then `f` is an isomorphism in `C`.


theorem mul_lt_mul_right :
    ∀ {α : Type u_1} {a b c : α} [inst : Mul α] [inst_1 : Zero α] [inst_2 : Preorder α] [inst_3 : MulPosStrictMono α]
      [inst_4 : MulPosReflectLT α], 0 < a → (b * a < c * a ↔ b < c) :=
  by sorry

The theorem `mul_lt_mul_right` states that for any strictly ordered semiring `α`, given three elements `a`, `b`, and `c` of `α`, if `a` is positive, then `b * a` is less than `c * a` if and only if `b` is less than `c`. This theorem asserts the property of preserving order under multiplication by a positive element on the right, and that the order can be reflected through the same operation. This is a characteristic property of strict ordered semirings.

In a strictly ordered semiring, for all positive elements `a`, `b`, and `c`, `b < c` if and only if `b * a < c * a`.


theorem MeasureTheory.iUnion_spanningSets :
    ∀ {α : Type u_1} {m0 : MeasurableSpace α} (μ : MeasureTheory.Measure α) [inst : MeasureTheory.SigmaFinite μ],
      ⋃ i, MeasureTheory.spanningSets μ i = Set.univ :=
  by sorry

The theorem `MeasureTheory.iUnion_spanningSets` states that for any type `α` and a measurable space `m0` defined on it, along with a measure `μ` that is sigma finite, the union of the spanning sets of `μ` indexed by all natural numbers equals the universal set. In other words, if we construct a sequence of sets using `MeasureTheory.spanningSets μ i` for all `i ∈ ℕ`, then the union of all these sets encompasses the entire universe of the type `α`. This theorem is a critical step in demonstrating that we can cover the whole space using sets with finite measure, an important concept in measure theory.

For any measurable space `(α, m0)` with a sigma-finite measure `μ`, the union of the spanning sets of `μ` is equal to the universal set of `α`.


theorem Finset.union_subset : ∀ {α : Type u_1} [inst : DecidableEq α] {s t u : Finset α}, s ⊆ u → t ⊆ u → s ∪ t ⊆ u :=
  by sorry

The `Finset.union_subset` theorem states that for any type `α` that has decidable equality, and for any three finite sets `s`, `t`, and `u` of type `α`, if `s` is a subset of `u` and `t` is a subset of `u`, then the union of `s` and `t` is also a subset of `u`. This is a fundamental property of subsets in set theory.

If `s` and `t` are finite subsets of type `α` with decidable equality, and `s ⊆ u` and `t ⊆ u` hold, then `s ∪ t ⊆ u`.


theorem Complex.arg_zero : Complex.arg 0 = 0 := by sorry

The theorem `Complex.arg_zero` states that the argument of the complex number 0 is 0. This is derived from the definition of the argument of a complex number, which defaults to 0 when the complex number is 0.

The argument of the complex number 0 is 0.


Computable.snd

theorem Computable.snd :
    ∀ {α : Type u_1} {β : Type u_2} [inst : Primcodable α] [inst_1 : Primcodable β], Computable Prod.snd := by sorry

The theorem `Computable.snd` asserts that for any two types `α` and `β` which are Primcodable (i.e., they have an instance of the Primcodable type class), the second projection function `Prod.snd` is computable. In other words, given any pair of elements of types `α` and `β`, the function that returns the second element of the pair is always computable.

For any two Primcodable types `α` and `β`, the second projection function `Prod.snd` on their product type is a computable function.


theorem Finset.image₂_singleton_left :
    ∀ {α : Type u_1} {β : Type u_3} {γ : Type u_5} [inst : DecidableEq γ] {f : α → β → γ} {t : Finset β} {a : α},
      Finset.image₂ f {a} t = Finset.image (fun b => f a b) t :=
  by sorry

This theorem, `Finset.image₂_singleton_left`, states that for all types `α`, `β`, and `γ` where `γ` has decidable equality, for any binary function `f : α → β → γ`, any finite set `t : Finset β`, and any value `a : α`, the image of the function `f` when applied to the singleton finite set containing only `a` and the finite set `t` is equal to the image of the function `(fun b => f a b)` when applied to the finite set `t`. In mathematical terms, it asserts that applying `f` to the Cartesian product of `{a}` and `t` is the same as mapping `f a` over `t`.

For any types `α`, `β`, and `γ` with decidable equality, and for any binary function `f : α → β → γ`, the image of `f` applied to the singleton set `{a}` and finite set `t` is equal to the image of the function `x mapsto f a x` applied to `t`.


theorem Polynomial.leadingCoeff_ne_zero :
    ∀ {R : Type u} [inst : Semiring R] {p : Polynomial R}, Polynomial.leadingCoeff p ≠ 0 ↔ p ≠ 0 := by sorry

The theorem `Polynomial.leadingCoeff_ne_zero` states that for any semiring `R` and any polynomial `p` with coefficients in `R`, the leading coefficient of `p` is not zero if and only if the polynomial `p` is not the zero polynomial. Here, the leading coefficient of a polynomial is defined as the coefficient of the highest power of `X` in the polynomial.

For any semiring R and polynomial p with coefficients in R, the leading coefficient of p is non-zero if and only if p is not the zero polynomial.


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

This theorem states that for all natural numbers 'a' and 'b', if 'a' is less than 'b', then 'a' is not equal to 'b'. This is a fundamental property in the number theory of natural numbers, asserting that a smaller number cannot be equal to a larger number.

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


theorem Finset.sum_eq_single :
    ∀ {α : Type u_3} {β : Type u_4} [inst : AddCommMonoid β] {s : Finset α} {f : α → β} (a : α),
      (∀ b ∈ s, b ≠ a → f b = 0) → (a ∉ s → f a = 0) → (Finset.sum s fun x => f x) = f a :=
  by sorry

The theorem `Finset.sum_eq_single` states that for any type `α`, `β` with `β` being an Additive Commutative Monoid, a finite set `s` of type `α`, a function `f` from `α` to `β`, and an element `a` of type `α`, the sum of the function `f` over all elements in `s` equals `f(a)` if and only if two conditions are satisfied: first, for every element `b` in `s` which is not equal to `a`, `f(b)` is zero; second, if `a` is not in `s`, then `f(a)` is also zero. Essentially, this theorem is saying that the sum of function values over a finite set is determined by the function value at a specific point, given that all other function values are zero or the specific point is not in the set and its function value is zero.

For any Additive Commutative Monoid type `β`, finite set `s` of type `α`, function `f` from `α` to `β`, and `α` element `a`, if `f(b) = 0` for all `b ∈ s ∖ {a}` and `f(a) = 0` when `a ∉ s`, then `∑ₕ i in s, f i = f a`.


theorem Equiv.Perm.apply_inv_self : ∀ {α : Type u} (f : Equiv.Perm α) (x : α), f (f⁻¹ x) = x := by sorry

The theorem `Equiv.Perm.apply_inv_self` states that for any type `α`, any permutation (bijection) `f` from `α` to itself, and any element `x` of type `α`, applying `f` to the inverse of `x` under `f` gives `x` back. In other words, the inverse function undoes the effect of the function. This is essentially the property that characterizes bijections; they are invertible and applying a function followed by its inverse results in the original value.

For any type `α` and bijection `f` from `α` to itself, `f (f⁻¹ x) = x` for all `x` in `α`.


theorem Init.Data.Nat.Basic._auxLemma.1 : ∀ (n : ℕ), (0 ≤ n) = True := by sorry

This theorem states that for any natural number `n`, the statement "0 is less than or equal to `n`" is always true. This is a basic property of natural numbers in mathematical principles, where 0 is the minimum value and every natural number is either this minimum value or greater.


theorem Finset.coe_sdiff : ∀ {α : Type u_1} [inst : DecidableEq α] (s₁ s₂ : Finset α), ↑(s₁ \ s₂) = ↑s₁ \ ↑s₂ := by
  sorry

This theorem states that for any type `α` with decidable equality, given two finite sets `s₁` and `s₂` of type `α`, the set difference operation (represented as `\`) when applied to `s₁` and `s₂` and then coerced to a set (using `↑` operation) results in the same set as when set difference operation is applied to the coerced sets `s₁` and `s₂`. In mathematical terms, for all finite sets `s₁` and `s₂`, \(↑(s₁ \ s₂) = ↑s₁ \ ↑s₂\). Here, the `↑` operation is a type coercion from `Finset` to `Set`, and `\` is the set difference operation.

For any finite sets `s₁` and `s₂` of type `α` with decidable equality, `↑(s₁ \ s₂) = ↑s₁ \ ↑s₂`. (Where `\` is set difference, `↑` is set coercion from `Finset` to `Set`, and `α` is any type with decidable equality.)


/-- The length of the list to which a vector of length `n` maps is `n`.  -/
theorem Vector.toList_length : ∀ {α : Type u} {n : ℕ} (v : Vector α n), List.length (Vector.toList v) = n := by sorry

The theorem `Vector.toList_length` asserts that for any vector `v` which is of length `n` and has elements of type `α`, when the vector is converted to a list using the function `Vector.toList`, the length of the resulting list is `n`. In other words, the transformation of a vector into a list preserves the size.

For any vector `v` of length `n` and type `α`, the length of `Vector.toList v` is equal to `n`.


/-- A nonempty set is scaled by zero to the singleton set containing 0.  -/
theorem Set.zero_smul_set :
    ∀ {α : Type u_2} {β : Type u_3} [inst : Zero α] [inst_1 : Zero β] [inst_2 : SMulWithZero α β] {s : Set β},
      Set.Nonempty s → 0 • s = 0 :=
  by sorry

The theorem `Set.zero_smul_set` states that for any nonempty set `s` of type `β` in a scalar multiplication with zero structure (`SMulWithZero α β`), if `α` and `β` are types with zero, then the scaling of the set `s` by zero results in a singleton set containing only the zero element of `β`. In other words, regardless of the elements in the nonempty set `s`, when you multiply `s` by zero, you get a set that only contains `0` from type `β`.

For any nonempty set `s` in a scalar multiplication structure with types `α` and `β` having zero elements, the set `s` multiplied by zero is a singleton set containing the zero element of `β`.


theorem ContinuousMap.coe_one :
    ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] [inst_2 : One β],
      ⇑1 = 1 :=
  by sorry

This theorem states that for any types `α` and `β`, where `α` is a topological space and `β` is both a topological space and has a defined multiplicative identity (1), the application of the multiplicative identity function (denoted as `⇑1`) is equal to the multiplicative identity itself. In other words, applying the identity function to any element in this context will yield the same element.

For any topological spaces `α` and `β` with a multiplicative identity `1` in `β`, the application of the identity function `⇑1` to any element in `β` is equal to the multiplicative identity itself.


theorem Set.uIcc_of_le : ∀ {α : Type u_1} [inst : Lattice α] {a b : α}, a ≤ b → Set.uIcc a b = Set.Icc a b := by sorry

The theorem `Set.uIcc_of_le` states that for any type `α` that has a `Lattice` structure, and for any two elements `a` and `b` of this type, if `a` is less than or equal to `b`, then the universal bounded lattice of `a` and `b`, denoted by `Set.uIcc a b`, is equal to the closed interval between `a` and `b`, denoted by `Set.Icc a b`. Here, `Set.uIcc a b` represents the set of all elements lying between `a` and `b` with both `a` and `b` included, and `Set.Icc a b` represents the left-closed right-closed interval from `a` to `b`.

For any type `α` with a `Lattice` structure and elements `a` and `b`, if `a ≤ b`, then `Set.uIcc a b = Set.Icc a b`.


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

This theorem states that for any type `α`, along with a relation `r` on `α` that forms a well-order, and for any element `a` of `α`, the ordinal type of `a` with respect to the relation `r` (`Ordinal.typein r a`) is strictly less than the ordinal type of the well-ordered set itself (`Ordinal.type r`). In other words, the order type of an element in a well-ordered set is always less than the order type of the entire well-ordered set.

For any well-ordered type `(α, r)`, the ordinal type of any element `a` is strictly less than the ordinal type of the well-ordered set `α` with respect to the relation `r`.


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

The theorem `Polynomial.map_add` states that for any two polynomials `p` and `q` over a semiring `R`, and a ring homomorphism `f` from `R` to another semiring `S`, the map of the sum of `p` and `q` under `f` equals to the sum of the maps of `p` and `q` under `f`. In other words, the map operation preserves the addition operation of polynomials, which is a fundamental property related to the homomorphism between two algebraic structures.

For any semiring homomorphism $f$ and polynomials $p, q$ over a semiring $R$, we have $f(p + q) = f(p) + f(q)$.


UniformEquiv.uniformContinuous

theorem UniformEquiv.uniformContinuous :
    ∀ {α : Type u} {β : Type u_1} [inst : UniformSpace α] [inst_1 : UniformSpace β] (h : α ≃ᵤ β),
      UniformContinuous ⇑h :=
  by sorry

The theorem `UniformEquiv.uniformContinuous` asserts that for any two types `α` and `β`, both equipped with a uniform space structure, if there exists a uniform equivalence `h` between `α` and `β` (i.e., a bijection which is uniformly continuous in both directions), then the function `h` (casting from `α` to `β`) is uniformly continuous. That is, given any pair of points `x` and `y` close to each other in `α`, their images under `h` are close in `β` irrespective of the specific locations of `x` and `y` in `α`.

If `h` is a uniform equivalence between uniform spaces `(α, δα)` and `(β, δβ)`, then `h` is a uniformly continuous function from `(α, δα)` to `(β, δβ)`.


theorem Function.Injective.of_comp :
    ∀ {α : Sort u_1} {β : Sort u_2} {γ : Sort u_3} {f : α → β} {g : γ → α},
      Function.Injective (f ∘ g) → Function.Injective g :=
  by sorry

The theorem `Function.Injective.of_comp` states that for all types `α`, `β`, and `γ`, and for all functions `f` from `α` to `β` and `g` from `γ` to `α`, if the composite function `f ∘ g` (meaning `f` after `g`) is injective (i.e., it never maps distinct inputs to the same output), then the function `g` is also injective. This is a property of function composition in mathematical logic.

If `f ∘ g` is injective for functions `f: α -> β` and `g: γ -> α`, then `g` is injective.


theorem Ideal.subset_span : ∀ {α : Type u} [inst : Semiring α] {s : Set α}, s ⊆ ↑(Ideal.span s) := by sorry

The theorem `Ideal.subset_span` states that for any type `α` that is a semiring, and for any set `s` of elements of that type, `s` is a subset of the ideal generated by `s`. In other words, every element of `s` is also an element of the ideal spanned by `s`. This ideal is formed by the collection of all combinations of elements of `s` that can be obtained through the operations of the semiring `α`.

For any semiring `α` and set `s` of its elements, `s` is contained in the ideal generated by `s`.


theorem AddMonoidHom.mem_ker :
    ∀ {G : Type u_1} [inst : AddGroup G] {M : Type u_7} [inst_1 : AddZeroClass M] (f : G →+ M) {x : G},
      x ∈ AddMonoidHom.ker f ↔ f x = 0 :=
  by sorry

The theorem `AddMonoidHom.mem_ker` states that for any `AddGroup` G, any `AddZeroClass` M, and any additive monoid homomorphism `f` from G to M, an element `x` from G belongs to the kernel of `f` if and only if the result of applying `f` to `x` is 0. The kernel of the homomorphism `f` is defined as the subgroup of elements from G that, when mapped by `f`, result in the additive identity in M.

For any additive monoid homomorphism from an add group to an additive semigroup with additive identity, an element in the domain maps to the additive identity in the codomain if and only if it belongs to the kernel of the homomorphism.


theorem Polynomial.add_comp :
    ∀ {R : Type u} [inst : Semiring R] {p q r : Polynomial R},
      Polynomial.comp (p + q) r = Polynomial.comp p r + Polynomial.comp q r :=
  by sorry

This theorem states that for any type `R` that forms a semiring, and for any polynomials `p`, `q`, and `r` over `R`, the composition of polynomial `r` with the sum of polynomials `p` and `q` is equal to the sum of the composition of `r` with `p` and the composition of `r` with `q`. Essentially, it establishes the distributive property of composition over addition for polynomials.

For any semiring `R` and polynomials `p`, `q`, and `r` over `R`, the composition of `r` with the sum of `p` and `q` equals the sum of the compositions of `r` with `p` and `q`: `r * (p + q) = r * p + r * q`.


theorem GaloisConnection.le_u :
    ∀ {α : Type u} {β : Type v} [inst : Preorder α] [inst_1 : Preorder β] {l : α → β} {u : β → α},
      GaloisConnection l u → ∀ {a : α} {b : β}, l a ≤ b → a ≤ u b :=
  by sorry

The theorem `GaloisConnection.le_u` states that for any types `α` and `β` that have a Preorder structure, and for any functions `l : α → β` and `u : β → α`, if `l` and `u` form a Galois connection, then for all elements `a` of type `α` and `b` of type `β`, if `l a` is less than or equal to `b`, then `a` is less than or equal to `u b`.

For any Preorder types α and β and Galois connection functions l : α → β and u : β → α, if l(a) ≤ b holds then a ≤ u(b).


theorem Submodule.mem_span_singleton_self :
    ∀ {R : Type u_1} {M : Type u_4} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] (x : M),
      x ∈ Submodule.span R {x} :=
  by sorry

This theorem states that for any semiring `R`, any additive commutative monoid `M`, and any module structure on `M` over `R`, any element `x` of `M` is contained in the submodule of `M` generated by the singleton set that consists only of `x`. In mathematical terms, if you have a semiring `R` and an `R`-module `M`, then any element in `M` is always included in the span of the set containing only that element.

For any semiring R, additive commutative monoid M with an R-module structure, and any x in M, the submodule of M generated by {x} contains x.


theorem Ideal.span_le : ∀ {α : Type u} [inst : Semiring α] {s : Set α} {I : Ideal α}, Ideal.span s ≤ I ↔ s ⊆ ↑I := by
  sorry

The theorem `Ideal.span_le` states that for any type `α` equipped with a semiring structure, any set `s` of elements of type `α`, and any ideal `I` of the semiring, the ideal generated by `s` (denoted by `Ideal.span s`) is a subset of `I` if and only if the set `s` itself is a subset of `I`. In other words, this theorem establishes a criterion for an ideal generated by a set to be contained within another ideal: this containment holds if and only if the generating set is contained within the other ideal.

For any semiring type `α`, set `s` of elements from `α`, and ideal `I` of `α`, `Ideal.span s ⊆ I` if and only if `s ⊆ I`.


theorem Nat.lt_or_ge : ∀ (n m : ℕ), n < m ∨ n ≥ m := by sorry

This theorem, `Nat.lt_or_ge`, states that for any two natural numbers `n` and `m`, either `n` is less than `m`, or `n` is greater than or equal to `m`. In other words, given any two natural numbers, one is always either smaller than or at least as large as the other. This relationship is a fundamental property of the natural numbers.

For all natural numbers n and m, either n < m or n >= m.


theorem CategoryTheory.Iso.hom_inv_id_app_assoc :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂}
      [inst_1 : CategoryTheory.Category.{v₂, u₂} D] {F G : CategoryTheory.Functor C D} (α : F ≅ G) (X : C) {Z : D}
      (h : F.obj X ⟶ Z),
      CategoryTheory.CategoryStruct.comp (α.hom.app X) (CategoryTheory.CategoryStruct.comp (α.inv.app X) h) = h :=
  by sorry

The theorem `CategoryTheory.Iso.hom_inv_id_app_assoc` states that for any two functors `F` and `G` from a category `C` to another category `D`, given a natural isomorphism `α : F ≅ G`, and for any object `X` in `C`, and morphism `h : F.obj X ⟶ Z`, the composition of `α.hom.app X` and the composition of `α.inv.app X` with `h` is equal to `h`. In other words, the homomorphism of `α` for `X`, followed by the inverse of the homomorphism of `α` for `X` then `h`, is equal to `h`. This is an instance of the property that the composition of an isomorphism and its inverse acts as an identity.

Given functors F and G between categories, a natural isomorphism α : F ≅ G, and an object X in the domain category and a morphism h : F X → Z, we have α.hom.app X * α.inv.app X * h = h.


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

This theorem expresses the principle of induction over finite sets in type theory. In more detail, it states that for any type `α` and any property `p` on finite sets of type `α`, if the property holds for the empty set and it also holds for any set when an element not already in the set is added, then the property holds for all finite sets of type `α`.

If a property holds for the empty set and is preserved under set augmentation, then it holds for all finite sets.


theorem neg_vadd_vadd :
    ∀ {α : Type u} {β : Type v} [inst : AddGroup α] [inst_1 : AddAction α β] (c : α) (x : β), -c +ᵥ (c +ᵥ x) = x := by
  sorry

This theorem, `neg_vadd_vadd`, states that for any types `α` and `β` where `α` is an additive group and there exists an additive action of `α` on `β`, for any elements `c` of type `α` and `x` of type `β`, the negative of `c` added with the vector sum of `c` and `x` is equal to `x`. In essence, it's showing an identity in the context of an additive group and its action on another type, similar to how in basic algebra, adding a number to its negation yields the identity element (0 for addition).

For any additive group `α` acting on a type `β`, and for any elements `c` in `α` and `x` in `β`, we have `-c + x + c = x`.


theorem nonempty_subtype : ∀ {α : Sort u_2} {p : α → Prop}, Nonempty (Subtype p) ↔ ∃ a, p a := by sorry

The theorem `nonempty_subtype` states that for any type `α` and any predicate `p` on `α`, there exists a nonempty subtype `Subtype p` if and only if there exists an element `a` of `α` for which the predicate `p` holds true. Essentially, this theorem relates the existence of a nonempty subtype (a subset of a type where the elements satisfy a certain condition) to the existence of an element in the original type that satisfies the same condition.

For any type `α` and predicate `p` on `α`, there exists a nonempty subtype `Subtype p` if and only if there exists an element `a` in `α` such that `p(a)` holds.


theorem LieSubmodule.coe_toSubmodule_eq_iff :
    ∀ {R : Type u} {L : Type v} {M : Type w} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : AddCommGroup M]
      [inst_3 : Module R M] [inst_4 : LieRingModule L M] (N N' : LieSubmodule R L M), ↑N = ↑N' ↔ N = N' :=
  by sorry

This theorem states that for any two Lie Submodules `N` and `N'` of a Module `M` over a Commutative Ring `R` with a Lie Ring `L`, the coercion of `N` to a Submodule is equal to the coercion of `N'` to a Submodule if and only if `N` is equal to `N'`. Here, the module `M` is equipped with the structure of a Lie Ring Module over `L`. This connects the equivalence of Lie Submodules with their equivalence as Submodules when coerced.

For any Lie Submodules N and N' of a Lie Ring Module M over a commutative ring R, the coercions of N and N' to Submodules of M are equal if and only if N = N'.


theorem Filter.tendsto_snd :
    ∀ {α : Type u_1} {β : Type u_2} {f : Filter α} {g : Filter β}, Filter.Tendsto Prod.snd (f ×ˢ g) g := by sorry

The theorem `Filter.tendsto_snd` states that for all types `α` and `β`, and for any filters `f` of `α` and `g` of `β`, the function `Prod.snd` (which takes a pair and returns its second element) tends to `g` when applied to the Cartesian product of `f` and `g`. In other words, for every neighborhood of `g`, the preimage of this neighborhood under the function `Prod.snd` is a neighborhood of the Cartesian product filter `f ×ˢ g`. This describes the behavior of the second projection function on the product of two filters.

For all filters $f$ on type $\alpha$ and $g$ on type $\beta$, the second projection function `Prod.snd` tends to $g$ when applied to the Cartesian product of $f$ and $g$, i.e., the preimage of every neighborhood of $g$ under `Prod.snd` is a neighborhood of $f \times g$.


theorem ENNReal.coe_nnreal_eq : ∀ (r : NNReal), ↑r = ENNReal.ofReal ↑r := by sorry

This theorem states that for every nonnegative real number `r` (denoted as `NNReal`), the coercion of `r` to extended nonnegative real numbers (`ENNReal`) is equal to the result of applying the `ENNReal.ofReal` function to the coercion of `r` to real numbers. In mathematical terms, for all `r` in nonnegative real numbers, we have that the image of `r` under the inclusion map into the extended nonnegative real numbers is the same as the image of `r` under the map `ENNReal.ofReal`, after `r` has been identified with its corresponding real number.

For every non-negative real number `r`, `ENNReal.ofReal (coercion r to Real) = coercion r to ENNReal`.


Function.comp.assoc

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

This theorem states that for any four types `α`, `β`, `φ`, and `δ`, and for any three functions `f` from `φ` to `δ`, `g` from `β` to `φ`, and `h` from `α` to `β`, the composition of functions is associative. That is, composing `f` with `g` and then composing the result with `h` (`(f ∘ g) ∘ h`) is the same as composing `f` with the composition of `g` and `h` (`f ∘ (g ∘ h)`). This means that we can change the grouping of the composition without changing the overall result.

For any types `α`, `β`, `φ`, and functions `f : φ -> δ`, `g : β -> φ`, and `h : α -> β`, the associativity of function composition holds: `(f ∘ g) ∘ h = f ∘ (g ∘ h)`.


Subalgebra.ext

theorem Subalgebra.ext :
    ∀ {R : Type u} {A : Type v} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A]
      {S T : Subalgebra R A}, (∀ (x : A), x ∈ S ↔ x ∈ T) → S = T :=
  by sorry

This theorem states that for any two subalgebras 'S' and 'T' of a given algebra 'A' over a commutative semiring 'R', if every element 'x' of the algebra 'A' belongs to 'S' if and only if it belongs to 'T', then the two subalgebras 'S' and 'T' are equal. The algebra 'A' is a semiring and it becomes an algebra over 'R' with additional structure from 'R'.

If two subalgebras S and T of a commutative semiring R-algebra A have the same elements, then they are equal.


theorem Finsupp.total_single :
    ∀ {α : Type u_1} {M : Type u_2} (R : Type u_5) [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
      {v : α → M} (c : R) (a : α), ((Finsupp.total α M R v) fun₀ | a => c) = c • v a :=
  by sorry

The `Finsupp.total_single` theorem states that for any types `α`, `M`, and `R`, where `R` is a semiring, `M` is an additive commutative monoid and a module over `R`, and for any function `v` from `α` to `M`, and any elements `c` of `R` and `a` of `α`, applying the function `Finsupp.total α M R v` to the function that maps `a` to `c` and other elements of `α` to zero, is equal to the scalar multiplication of `c` and `v a`. In essence, it says that in the linear combination represented by `Finsupp.total`, individual terms are just the scalars times the corresponding vector.

For any semiring `R`, additive commutative monoid and `R`-module `M`, function `v` from type `α` to `M`, and elements `c` of `R` and `a` of `α`, `Finsupp.total α M R v (λ x => if x = a then c else 0) = c * v a`.


Int.ofNat.inj

theorem Int.ofNat.inj : ∀ {a a_1 : ℕ}, Int.ofNat a = Int.ofNat a_1 → a = a_1 := by sorry

The theorem `Int.ofNat.inj` states that for any two natural numbers `a` and `a_1`, if their corresponding integer representations obtained by the function `Int.ofNat` are equal, then `a` and `a_1` are also equal. In other words, `Int.ofNat` is an injective function from the set of natural numbers to the set of integers.

The function `Int.ofNat` maps distinct natural numbers to distinct integers.


StrictAnti.strictAntiOn

theorem StrictAnti.strictAntiOn :
    ∀ {α : Type u} {β : Type v} [inst : Preorder α] [inst_1 : Preorder β] {f : α → β},
      StrictAnti f → ∀ (s : Set α), StrictAntiOn f s :=
  by sorry

The theorem `StrictAnti.strictAntiOn` states that for all types `α` and `β` (with pre-defined preorders) and for all function `f` from `α` to `β`, if the function `f` is strictly antitone (meaning that if `a` is less than `b`, then `f(b)` is less than `f(a)`), then for any set `s` of type `α`, the function `f` is also strictly antitone on the set `s`. In other words, for any elements `a` and `b` in the set `s`, if `a` is less than `b`, then `f(b)` is less than `f(a)`.

If `f` is a strictly antitone function from type `α` to type `β` with pre-defined preorders, then `f` is strictly antitone on any set `s` of type `α`.


theorem ContinuousMap.coe_nsmul :
    ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] [inst_2 : AddMonoid β]
      [inst_3 : ContinuousAdd β] (f : C(α, β)) (n : ℕ), ⇑(n • f) = n • ⇑f :=
  by sorry

This theorem states that for any continuous map `f` from a topological space `α` to an additive monoid `β` (which is also a topological space and supports continuous addition), the action of scalar multiplication `n • f` on `f` corresponds to scalar multiplication `n • ⇑f` applied to the pointwise application of `f`. This is true for all natural numbers `n`. In other words, scalar multiplication of the continuous map can be distributed through to the pointwise application of the map.

For any continuous map `f` from a topological space `α` to an additive monoid `β` (and topological space), scalar multiplication `n • f` equals the pointwise application of `n • ⇑f` to `f`, for all natural numbers `n`.


theorem Mathlib.Data.Set.Pointwise.Basic._auxLemma.2 : ∀ {α : Type u_2} [inst : Zero α] {a : α}, (a ∈ 0) = (a = 0) := by
  sorry

This theorem, `Mathlib.Data.Set.Pointwise.Basic._auxLemma.2`, states that for any type `α` that has a zero element (denoted by `0`), for any element `a` of type `α`, the assertion that `a` is in `0` is equivalent to the assertion that `a` equals `0`. This is typically applied in the context of algebraic structures like rings and fields where `0` represents the additive identity.

For any type `α` with a zero element `0`, the equality `a = 0` is equivalent to `a ∈ 0` for any `a` in `α`.


theorem Polynomial.isUnit_C : ∀ {R : Type u} [inst : Semiring R] {x : R}, IsUnit (Polynomial.C x) ↔ IsUnit x := by sorry

This theorem, `Polynomial.isUnit_C`, states that for any type `R` that is a semiring, and for any element `x` of type `R`, the polynomial constant `x` is a unit if and only if `x` itself is a unit. Here, a unit is an element of a monoid that has a two-sided inverse. In other words, an element `x` is a unit in the semiring `R` if and only if the polynomial constant `x` is a unit in the ring of polynomials over `R`.

For any semiring `R` and element `x` in `R`, the polynomial constant `x` is a unit in the ring of polynomials over `R` if and only if `x` is a unit in `R`.


theorem NNReal.coe_nat_cast : ∀ (n : ℕ), ↑↑n = ↑n := by sorry

This theorem states that for all natural numbers `n`, the double coercion of `n` to a non-negative real number (denoted by `↑↑n`) is equal to the single coercion of `n` to a real number (denoted by `↑n`). In simpler terms, it means that the processes of casting a natural number to a non-negative real number and then to a real number, and directly casting a natural number to a real number, yield the same result.

For all natural numbers `n`, the double coercion `↑↑n` equals the single coercion `↑n`.


theorem OrderEmbedding.le_iff_le :
    ∀ {α : Type u_2} {β : Type u_3} [inst : Preorder α] [inst_1 : Preorder β] (f : α ↪o β) {a b : α},
      f a ≤ f b ↔ a ≤ b :=
  by sorry

This theorem states that for any two types `α` and `β` that are both preordered, and for any order embedding `f` from `α` to `β`, `f(a)` is less than or equal to `f(b)` if and only if `a` is less than or equal to `b`. This theorem essentially validates that the order embedding `f` correctly preserves the order from `α` to `β`.

For any preordered types `α` and `β` and order embedding `f` from `α` to `β`, `f(a) ≤ f(b)` if and only if `a ≤ b` for all `a, b` in `α`.


theorem Asymptotics.IsBigO.trans_isLittleO :
    ∀ {α : Type u_1} {E : Type u_3} {G : Type u_5} {F' : Type u_7} [inst : Norm E] [inst_1 : Norm G]
      [inst_2 : SeminormedAddCommGroup F'] {l : Filter α} {f : α → E} {g : α → F'} {k : α → G},
      f =O[l] g → g =o[l] k → f =o[l] k :=
  by sorry

This theorem, `Asymptotics.IsBigO.trans_isLittleO`, states that for any types `α`, `E`, `G`, and `F'`, where `E`, `G`, and `F'` have a norm (i.e., they are normed spaces), and `F'` is a seminormed additive commutative group, and given a filter `l` and functions `f`, `g`, and `k` from `α` to `E`, `F'`, and `G` respectively, if `f` is Big-O of `g` (the function `f` is asymptotically no more than `g` times a constant, as we approach a limit along filter `l`), and `g` is little-o of `k` (the function `g` becomes insignificant compared to `k` along filter `l`), then `f` is also little-o of `k` (the function `f` becomes insignificant compared to `k` along filter `l`). In effect, it is a transitivity rule for Big-O and little-o asymptotic notations.

If `f` is Big-O of `g` and `g` is little-o of `k` along a filter `l`, then `f` is little-o of `k` along `l`. (Transitivity rule for Big-O and little-o asymptotic notations in the context of normed spaces and seminormed additive commutative groups.)


theorem Int.induction_on :
    ∀ {p : ℤ → Prop} (i : ℤ), p 0 → (∀ (i : ℕ), p ↑i → p (↑i + 1)) → (∀ (i : ℕ), p (-↑i) → p (-↑i - 1)) → p i := by
  sorry

This theorem, `Int.induction_on`, states that for any predicate `p` that applies to integers, if `p` holds for the integer `0`, and if for any natural number `i`, `p` holding for `i` implies that `p` holds for `i+1`, and also if `p` holding for `-i` implies that `p` holds for `-i-1`, then `p` holds for every integer `i`. In other words, it's an induction principle for integers, including both non-negative and negative numbers.

The theorem `Int.induction_on` asserts that a predicate on integers holds for all integers if it holds for zero and is closed under successor and predecessor.


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

This theorem states that for any type `α` that is a pseudo-metric space, the distance `dist` between any two elements `x` and `y` of `α` is equal to the real number representation (`.toReal`) of the extended distance `edist` between `x` and `y`. In simpler terms, it links the concepts of distance and extended distance in a pseudo-metric space, stating that they are essentially the same, but represented in different ways (standard vs extended, or real numbers vs extended real numbers).

For any pseudo-metric space `α` and elements `x` and `y` in `α`, `dist x y` equals the real number representation of the extended distance `edist x y`.


theorem Set.univ_nonempty : ∀ {α : Type u} [inst : Nonempty α], Set.Nonempty Set.univ := by sorry

This theorem, `Set.univ_nonempty`, states that for all types `α`, given an instance asserting that `α` is not empty (i.e. there exists at least one element of type `α`), the universal set on `α`, denoted as `Set.univ`, is also nonempty. In other words, if there is at least one element of some type `α`, then the set of all elements of type `α` also contains at least one element.

If `α` is a non-empty type, then `Set.univ α` is also a non-empty set.


AddCommute.refl

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

This theorem states that for any type `S` that has an addition operation, any element `a` of type `S` commutes with itself. In the context of addition, "commuting" means that the order of the operands does not affect the result, hence `a + a = a + a`. This is a universal property, applicable to all elements of any type that allows addition.

For any type `S` with an addition operation, the commutative law holds: `a + a = a + a` for all `a` in `S`.


CategoryTheory.Localization.inverts

theorem CategoryTheory.Localization.inverts :
    ∀ {C : Type u_1} {D : Type u_2} [inst : CategoryTheory.Category.{u_4, u_1} C]
      [inst_1 : CategoryTheory.Category.{u_5, u_2} D] (L : CategoryTheory.Functor C D)
      (W : CategoryTheory.MorphismProperty C) [inst_2 : CategoryTheory.Functor.IsLocalization L W],
      CategoryTheory.MorphismProperty.IsInvertedBy W L :=
  by sorry

The theorem `CategoryTheory.Localization.inverts` states that for any category `C` and `D`, a functor `L` from `C` to `D`, and a morphism property `W` in `C`, if the functor `L` is a localization of `W`, then all morphisms in `W` are mapped to isomorphisms in `D` by `L`. In other words, if `L` is a localization of `W`, then `W` is inverted by `L`.

If functor `L` is a localization of morphism property `W` in category `C`, then for any morphism `f` in `W`, `L(f)` is an isomorphism in category `D`.


theorem isCompact_empty : ∀ {X : Type u} [inst : TopologicalSpace X], IsCompact ∅ := by sorry

The theorem `isCompact_empty` states that for any type `X` with a topology (that is, `X` is a topological space), the empty set in `X` is compact. In other words, if you take any nontrivial filter `f` that contains the empty set, there will always exist a point in the empty set such that every set of `f` intersects every neighborhood of that point. However, since the empty set has no elements, this condition is vacuously true.

The empty set in a topological space is compact.


theorem compl_surjective : ∀ {α : Type u} [inst : BooleanAlgebra α], Function.Surjective compl := by sorry

The theorem `compl_surjective` states that for all types `α` that have a `BooleanAlgebra` instance, the complement function `compl` is surjective. In other words, for every element in the Boolean algebra, there exists another element such that when the complement operation is applied to the latter, we get the former. This is a property of the Boolean algebra structure, where the complement of any element always exists.

For every element in a Boolean algebra with a given instance, there exists an element whose complement is that element.


theorem Init.Core._auxLemma.1 :
    ∀ {α : Type u_1} [inst : BEq α] [inst_1 : LawfulBEq α] (a b : α), ((a == b) = true) = (a = b) := by sorry

This theorem, named `Init.Core._auxLemma.1`, states that for any type `α` that has an instance of binary equality (`BEq α`) and is lawfully binary equal (`LawfulBEq α`), the binary equality comparison of any two elements `a` and `b` of this type, expressed as `(a == b) = true`, is equivalent to stating that `a` and `b` are equal in the standard sense `(a = b)`. This means that the binary equality operation correctly reflects the true equality of elements in the type `α`.

For types endowed with lawful binary equality and instance of binary equality, binary equality implies standard equality.


theorem Ideal.mem_comap :
    ∀ {R : Type u} {S : Type v} {F : Type u_1} [inst : Semiring R] [inst_1 : Semiring S] [inst_2 : FunLike F R S]
      [rc : RingHomClass F R S] {f : F} {K : Ideal S} {x : R}, x ∈ Ideal.comap f K ↔ f x ∈ K :=
  by sorry

The theorem `Ideal.mem_comap` states that for any semirings `R` and `S`, any term `f` of type `F` which behaves like a function from `R` to `S`, any ideal `K` of `S`, and any element `x` of `R`, the element `x` is in the preimage of the ideal `K` under the function `f` if and only if the value of `f` at `x` is in the ideal `K`. This means that the preimage of an ideal under a ring homomorphism is characterized by the fact that an element belongs to it if and only if its image under the homomorphism belongs to the original ideal.

For any semirings R and S, function f : R → S, ideal K of S, and x ∈ R, x ∈ f⁁⁃(K) if and only if f x ∈ K.


theorem ENNReal.ofReal_ne_top : ∀ {r : ℝ}, ENNReal.ofReal r ≠ ⊤ := by sorry

The theorem `ENNReal.ofReal_ne_top` states that for every real number `r`, the function `ENNReal.ofReal` applied to `r` never equals `∞` (infinity). In other words, when any real number is passed into the `ENNReal.ofReal` function (which returns the number itself if it is nonnegative, or `0` if it's negative), the outcome will never be infinity.

For all real numbers r, ENNReal.ofReal r is finite.


theorem CategoryTheory.isIso_of_mono_of_epi :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Balanced C] {X Y : C} (f : X ⟶ Y)
      [inst_2 : CategoryTheory.Mono f] [inst_3 : CategoryTheory.Epi f], CategoryTheory.IsIso f :=
  by sorry

This theorem states that in any balanced category `C`, for any objects `X` and `Y` in `C`, if `f` is a morphism from `X` to `Y` which is both a monomorphism (i.e., left-cancellable) and an epimorphism (i.e., right-cancellable), then `f` is an isomorphism. A balanced category is one in which every morphism that is both a monomorphism and an epimorphism is an isomorphism. Thus, the theorem essentially asserts that the definition of a balanced category is upheld for any given pair of objects and morphism in that category.

In a balanced category, any morphism that is both a monomorphism and an epimorphism is an isomorphism.


theorem MeasureTheory.lintegral_zero_measure :
    ∀ {α : Type u_1} {m : MeasurableSpace α} (f : α → ENNReal), ∫⁻ (a : α), f a ∂0 = 0 := by sorry

The theorem `MeasureTheory.lintegral_zero_measure` states that for any type `α` and any measurable space `m` over `α`, the Lebesgue integral (denoted by `∫⁻`) of any function `f` from `α` to the extended nonnegative real numbers (`ENNReal`, usually denoted as [0, ∞]) with respect to the zero measure (denoted by ∂0) is equal to zero. In essence, it is saying that if we measure a function over a space where the measure of every set is zero, then the total "amount" of the function, as measured by the Lebesgue integral, is zero.

For any measurable space with zero measure and any measurable function to the extended nonnegative reals, the Lebesgue integral equals zero.


StrictMono.comp

theorem StrictMono.comp :
    ∀ {α : Type u} {β : Type v} {γ : Type w} [inst : Preorder α] [inst_1 : Preorder β] [inst_2 : Preorder γ] {g : β → γ}
      {f : α → β}, StrictMono g → StrictMono f → StrictMono (g ∘ f) :=
  by sorry

The theorem `StrictMono.comp` states that for all types `α`, `β`, and `γ` with preorder relations, if a function `g` from `β` to `γ` and a function `f` from `α` to `β` are both strictly monotone (that is, for any two elements `a` and `b` such that `a < b`, `f a < f b` and `g a < g b`), then the composition of `g` and `f` (denoted by `g ∘ f`) is also strictly monotone. In other words, the property of being strictly monotone is preserved under function composition.

If functions `f: α → β` and `g: β → γ` are strictly monotone, then their composition `g ∘ f: α → γ` is also strictly monotone.


theorem forall_and : ∀ {α : Sort u_1} {p q : α → Prop}, (∀ (x : α), p x ∧ q x) ↔ (∀ (x : α), p x) ∧ ∀ (x : α), q x := by
  sorry

This theorem states that for any type `α` and two properties `p` and `q` defined over `α`, the statement "for every `x` of type `α`, `p x` and `q x` hold" is logically equivalent to "for every `x` of type `α`, `p x` holds and for every `x` of type `α`, `q x` holds". In other words, it says that universal quantification distributes over conjunction.

For any type `α` and properties `p` and `q` over `α`, the statement "∀x : α, p x ∧ q x" is logically equivalent to "∀x : α, p x" ∧ "∀x : α, q x".


theorem Set.exists_range_iff :
    ∀ {α : Type u_1} {ι : Sort u_4} {f : ι → α} {p : α → Prop}, (∃ a ∈ Set.range f, p a) ↔ ∃ i, p (f i) := by sorry

This theorem states that for any type `α`, sort `ι`, function `f` from `ι` to `α`, and property `p` on `α`, there exists an element `a` in the range of `f` such that `p(a)` holds if and only if there exists an element `i` such that `p(f(i))` holds. Essentially, this means that a property holds for some value in the range of a function if and only if it holds for the image of some input to the function.

For any function `f: ι -> α` and property `p` on `α`, the existence of an `a ∈ range f` with `p(a)` is equivalent to the existence of an `i ∈ ι` with `p(f(i))`.


theorem Set.iUnion_exists :
    ∀ {α : Type u_1} {ι : Sort u_4} {p : ι → Prop} {f : Exists p → Set α},
      ⋃ (x : Exists p), f x = ⋃ i, ⋃ (h : p i), f ⋯ :=
  by sorry

The theorem `Set.iUnion_exists` states that for any type `α` and any indexed type `ι`, given a predicate `p` on `ι` and a function `f` from the existentially quantified predicate `p` to the set of `α`, the union over all sets `f x`, where `x` is an existing `p`, is the same as the union over all elements `i` of the union over all `h` such that `p i` holds of `f h`. In simpler terms, this theorem is about equivalent ways of forming unions of sets, where the sets are generated by a function `f` applied to indices that satisfy a certain property `p`.

For any type `α` and indexed type `ι`, if `p` is a predicate on `ι` and `f` is a function from `p` to `α`, then `⋃(x : ι | p x) ≈ ⋃(i : ⋃h, p h) . f h`.


theorem Nat.div_eq_of_lt : ∀ {a b : ℕ}, a < b → a / b = 0 := by sorry

This theorem states that for any two natural numbers 'a' and 'b', if 'a' is less than 'b', then the result of dividing 'a' by 'b' is zero. This is based on the property of integer division where the quotient of a division operation between two natural numbers is zero if the dividend is less than the divisor.

For all natural numbers a and b, if a < b then (a / b) = 0.


theorem Finset.card_image_le :
    ∀ {α : Type u_1} {β : Type u_2} {s : Finset α} {f : α → β} [inst : DecidableEq β],
      (Finset.image f s).card ≤ s.card :=
  by sorry

The theorem `Finset.card_image_le` states that for any types `α` and `β`, any finite set `s` of type `α`, and any function `f` from `α` to `β` where `β` has decidable equality, the cardinality (or size) of the image of `s` under `f` is less than or equal to the cardinality of `s` itself. This corresponds to the intuitive idea that applying a function to a set cannot result in a larger set, since multiple elements in the original set may map to the same element in the image.

For any finite type `α`, type `β` with decidable equality, finite set `s` of type `α`, and function `f` from `α` to `β`, the cardinality of `f''s` (image of `s` under `f`) is less than or equal to the cardinality of `s`.


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

This theorem, `LE.le.trans_lt'`, states that for any given type `α` that has a preorder structure, if we have three elements `a`, `b`, and `c` of this type such that `b` is less than or equal to `c` (`b ≤ c`) and `a` is strictly less than `b` (`a < b`), then `a` is strictly less than `c` (`a < c`). In essence, it is a statement about the transitivity of the "less than" relation in the context of preordered sets.

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


theorem CategoryTheory.eq_of_inv_eq_inv :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} {f g : X ⟶ Y} [inst_1 : CategoryTheory.IsIso f]
      [inst_2 : CategoryTheory.IsIso g], CategoryTheory.inv f = CategoryTheory.inv g → f = g :=
  by sorry

This theorem states that in any category `C`, for any objects `X` and `Y` in `C`, if `f` and `g` are morphisms from `X` to `Y` and both `f` and `g` are isomorphisms, then if the inverse of `f` is equal to the inverse of `g`, it follows that `f` is equal to `g`. In essence, it asserts the uniqueness of inverses in a category.

In any category, if two morphisms between objects have equal sources and targets and are mutually inverse to isomorphic morphisms, then they are equal.


OrderIso.monotone

theorem OrderIso.monotone :
    ∀ {α : Type u_2} {β : Type u_3} [inst : Preorder α] [inst_1 : Preorder β] (e : α ≃o β), Monotone ⇑e := by sorry

This theorem states that for any types `α` and `β` with a preorder relation, and for any order isomorphism `e` from `α` to `β`, the function `e` is monotone. In other words, if `a` and `b` are elements of `α` such that `a` is less than or equal to `b`, then the image of `a` under `e` is less than or equal to the image of `b` under `e`. This property holds for all order isomorphisms between preordered sets, which reflect the order structure of one set onto another.

For any preordered types `α` and `β` and order isomorphism `e` from `α` to `β`, `e (a ≤ b)` implies `e(a) ≤ e(b)` for all `a, b` in `α`.


theorem Finsupp.sum_single :
    ∀ {α : Type u_1} {M : Type u_8} [inst : AddCommMonoid M] (f : α →₀ M), Finsupp.sum f Finsupp.single = f := by sorry

The theorem `Finsupp.sum_single` is about finite support functions in Lean. It states that for any type `α` and any type `M` which is an additive commutative monoid, given a function `f` from `α` to `M` with finite support, the sum of the function `Finsupp.single` over the support of `f` is equal to `f` itself. Therefore, this theorem reveals a kind of 'self-reversibility' of the `Finsupp.single` function under the `Finsupp.sum` operation.

For any additive commutative monoid type `M` and type `α` with finite support function `f` from `α` to `M`, `Finsupp.sum (Finsupp.single x hx : Finsupp α M) = f x` for all `x : α` in the support of `f`.


theorem List.map_reverse :
    ∀ {α : Type u} {β : Type v} (f : α → β) (l : List α), List.map f (List.reverse l) = List.reverse (List.map f l) :=
  by sorry

This theorem states that for any function 'f' from type 'α' to type 'β' and any list 'l' of type 'α', mapping 'f' over the reverse of 'l' yields the same result as reversing the list obtained by mapping 'f' over 'l'. In simple terms, it says that reversing a list and then applying a function to each element is the same as applying the function first and then reversing the list.

For any function f from type α to type β and any list l of type α, the list obtained by applying f to the reverse of l is the reverse of the list obtained by applying f to each element of l.


theorem ENNReal.toReal_pos : ∀ {a : ENNReal}, a ≠ 0 → a ≠ ⊤ → 0 < a.toReal := by sorry

The theorem `ENNReal.toReal_pos` asserts that for any extended nonnegative real number `a`, if `a` is not equal to zero and `a` is not equal to positive infinity, then the real representation of `a` (denoted as `a.toReal`) is strictly greater than zero. In other words, any non-zero, finite extended nonnegative real number, when converted to a real number, is positive.

For any non-zero, finite extended nonnegative real number `a`, its real representation `a.toReal` is strictly positive.


/-- The subring generated by a set includes the set.  -/
theorem Subring.subset_closure : ∀ {R : Type u} [inst : Ring R] {s : Set R}, s ⊆ ↑(Subring.closure s) := by sorry

The theorem `Subring.subset_closure` states that for any type `R` that forms a Ring, and for any set `s` of elements of the type `R`, the set `s` is a subset of the subring generated by `s` itself. In other words, all the elements of `s` are contained within the subring produced by the `Subring.closure` operation on `s`.

For any ring `R` and subset `s` of `R`, `s` is included in the subring generated by `s` (i.e., `Subring.closure s`).


theorem Array.toList_eq : ∀ {α : Type u_1} (arr : Array α), Array.toList arr = arr.data := by sorry

This theorem states that for all types `α` and for any array of `α` termed `arr`, the operation of converting the array to a list using the `Array.toList` function is equivalent to obtaining the underlying data of the array. In other words, the function `Array.toList` simply returns the data from the array `arr` in list form.

For all types `α` and arrays `arr` of length `n` in `α`, `Array.toList arr` is equal to the list `[a_1, ..., a_n]` where `a_1, ..., a_n` are the elements of `arr`.


theorem le_iff_le_iff_lt_iff_lt :
    ∀ {α : Type u} {β : Type u_3} [inst : LinearOrder α] [inst_1 : LinearOrder β] {a b : α} {c d : β},
      (a ≤ b ↔ c ≤ d) ↔ (b < a ↔ d < c) :=
  by sorry

This theorem states that for any two types `α` and `β` that have a linear order, and for any elements `a`, `b` of type `α` and `c`, `d` of type `β`, the statement that `a` is less than or equal to `b` is equivalent to the statement that `c` is less than or equal to `d` if and only if the statement that `b` is less than `a` is equivalent to the statement that `d` is less than `c`. In mathematical terms, it's saying $(a \leq b) \Leftrightarrow (c \leq d)$ if and only if $(b < a) \Leftrightarrow (d < c)$.

For any linear orders on types `α` and `β`, the order relation `≤` on `α` is isomorphic to the order relation on `β` if and only if the reversed order relation `<` on `α` is isomorphic to the order relation on `β`.


Set.EqOn.symm

theorem Set.EqOn.symm :
    ∀ {α : Type u_1} {β : Type u_2} {s : Set α} {f₁ f₂ : α → β}, Set.EqOn f₁ f₂ s → Set.EqOn f₂ f₁ s := by sorry

This theorem states that for any types `α` and `β`, any set `s` of elements of type `α`, and any two functions `f₁` and `f₂` from `α` to `β`, if `f₁` and `f₂` are equal on `s` (meaning for all elements `x` in `s`, `f₁(x)` is equal to `f₂(x)`), then `f₂` and `f₁` are also equal on `s`. In other words, the property of two functions being equal on a set is symmetric.

If functions `f₁` and `f₂` from type `α` to type `β` are equal on a set `s` of elements from `α`, then they are equal.


Path.source

theorem Path.source : ∀ {X : Type u_1} [inst : TopologicalSpace X] {x y : X} (γ : Path x y), γ 0 = x := by sorry

This theorem states that for any given path `γ` between two points `x` and `y` in a topological space `X`, the source of the path (i.e., the point at which the path begins) is `x`. Specifically, when parameter `0` is given to the path `γ`, it returns the starting point `x`.

For any path γ : X → X between points x and y in a topological space X, γ 0 = x.


theorem Mathlib.Order.Filter.Basic._auxLemma.12 : ∀ {α : Type u} {s t : Set α}, (s ∈ Filter.principal t) = (t ⊆ s) := by
  sorry

This theorem states that for any type `α` and any two sets `s` and `t` of type `α`, `s` is in the principal filter of `t` if and only if `t` is a subset of `s`. In other words, `s` is a member of all supersets of `t` (which is what the principal filter of `t` represents) if and only if every element of `t` is also an element of `s`.

For any type `α` and sets `s` and `t` of type `α`, `s` is the principal filter of `t` if and only if `t` is a subset of `s`.


theorem QuotientAddGroup.induction_on' :
    ∀ {α : Type u_1} [inst : AddGroup α] {s : AddSubgroup α} {C : α ⧸ s → Prop} (x : α ⧸ s), (∀ (z : α), C ↑z) → C x :=
  by sorry

This theorem, named `QuotientAddGroup.induction_on'`, is about induction on elements of the quotient of an Additive Group `α` by an Additive Subgroup `s`. It states that, given any type `α` which has an `AddGroup` structure, any Additive Subgroup `s` of `α`, and any property `C` that applies to elements of the quotient group `α ⧸ s`, if `C` holds for all representatives `z` of equivalence classes (i.e., for all `z` in `α`), then `C` must hold for any element `x` in the quotient group `α ⧸ s`.

If `C` is a property that holds for the representatives of every equivalence class in the quotient group `α / s` of an additive group `α` by an additive subgroup `s`, then `C` holds for every element in the quotient group.


theorem CategoryTheory.ShortComplex.LeftHomologyData.f'_i :
    ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
      {S : CategoryTheory.ShortComplex C} (h : CategoryTheory.ShortComplex.LeftHomologyData S),
      CategoryTheory.CategoryStruct.comp (CategoryTheory.ShortComplex.LeftHomologyData.f' h) h.i = S.f :=
  by sorry

The theorem `CategoryTheory.ShortComplex.LeftHomologyData.f'_i` states that for any category `C` with zero morphism, and any short complex `S` within this category, if `h` is a left homology data of `S`, then the composition of the morphism `f'` from the left homology data `h` and the morphism `i` from `h` is equal to the morphism `f` from the short complex `S`. In more informal terms, this theorem is about the specific way in which morphisms in the category theory concept of a short complex can be composed.

For any short complex `S` in a category with zero morphism and any left homology data `h` of `S`, we have `f' ∘ i = f` in `S`.


theorem CategoryTheory.Limits.biproduct.lift_π :
    ∀ {J : Type w} {C : Type u} [inst : CategoryTheory.Category.{v, u} C]
      [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] {f : J → C} [inst_2 : CategoryTheory.Limits.HasBiproduct f]
      {P : C} (p : (b : J) → P ⟶ f b) (j : J),
      CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.biproduct.lift p)
          (CategoryTheory.Limits.biproduct.π f j) =
        p j :=
  by sorry

The theorem `CategoryTheory.Limits.biproduct.lift_π` states that for any category `C` with zero morphisms and a function `f : J → C` that has a biproduct, given a collection of morphisms `p : (b : J) → P ⟶ f b` from some object `P` in `C` to the objects in the image of `f`, if we first apply the lift operation to `p` to obtain a morphism from `P` to the biproduct of `f` and then apply the projection onto the `j`-th summand of the biproduct, the result is the same as applying the `j`-th morphism in the collection `p`. This theorem asserts a fundamental property of biproducts in a category, namely, the property that makes the lift operation a left inverse to the family of projection operations.

For any category with zero morphisms and a biproduct, the lift of a collection of morphisms to the biproduct and subsequent projection onto a summand is equivalent to applying the corresponding morphism in the collection.


theorem add_lie :
    ∀ {L : Type v} {M : Type w} [inst : LieRing L] [inst_1 : AddCommGroup M] [inst_2 : LieRingModule L M] (x y : L)
      (m : M), ⁅x + y, m⁆ = ⁅x, m⁆ + ⁅y, m⁆ :=
  by sorry

This theorem, `add_lie`, states that for any types `L` and `M`, where `L` is a Lie ring, `M` is an additive commutative group, and `M` is also a module over `L`, the Lie bracket of the sum of two elements `x` and `y` in `L` with an element `m` in `M` equals the sum of the Lie brackets of `x` and `m` and of `y` and `m`. In the language of mathematics, this can be represented as: ∀x, y ∈ L and m ∈ M, [x + y, m] = [x, m] + [y, m]. This property is a key aspect of the structure of Lie rings and their modules.

For any Lie ring `L`, additive commutative group and `L`-module `M`, the Lie bracket of a sum of elements in `L` with an element in `M` equals the sum of the Lie brackets of each element with that element in `M`.


theorem Finset.sup_image :
    ∀ {α : Type u_2} {β : Type u_3} {γ : Type u_4} [inst : SemilatticeSup α] [inst_1 : OrderBot α]
      [inst_2 : DecidableEq β] (s : Finset γ) (f : γ → β) (g : β → α),
      Finset.sup (Finset.image f s) g = Finset.sup s (g ∘ f) :=
  by sorry

The theorem `Finset.sup_image` states that for any types `α`, `β`, and `γ`, given a semi-lattice structure and a bottom element on `α`, and a decidable equality on `β`, for any finite set `s` of type `γ`, a function `f` from `γ` to `β`, and a function `g` from `β` to `α`, the supremum of the image of `s` under `f` with respect to `g` is equal to the supremum of `s` with respect to the composition of `g` and `f`. In other words, we can either take the supremum after applying the function `f` or we can take the supremum first and then apply the function `f`; both ways will give us the same result.

For any semi-lattice `α` with bottom element, decidable equality on `β`, finite set `s` of type `γ`, functions `f: γ -> β` and `g: β -> α`, the image of `s` under `f` supremum-mapped by `g` equals the supremum of `s` supremum-mapped by the composition `g ∘ f`.


LE.le.absolutelyContinuous

/-- **Alias** of `MeasureTheory.Measure.absolutelyContinuous_of_le`. -/
theorem LE.le.absolutelyContinuous :
    ∀ {α : Type u_1} {m0 : MeasurableSpace α} {μ ν : MeasureTheory.Measure α},
      μ ≤ ν → MeasureTheory.Measure.AbsolutelyContinuous μ ν :=
  by sorry

The theorem `LE.le.absolutelyContinuous` states that for any type `α`, given a measurable space `m0` and two measures `μ` and `ν` on that space, if `μ` is less than or equal to `ν` (in the sense that for every set, the measure of the set according to `μ` is less than or equal to its measure according to `ν`), then `μ` is absolutely continuous with respect to `ν`. In other words, whenever `ν` assigns measure zero to a set, `μ` also assigns measure zero to the same set. This is an alias of the theorem `MeasureTheory.Measure.absolutelyContinuous_of_le`.

If `μ` is a measure that is less than or equal to another measure `ν` on a measurable space `(α, m0)`, then `μ` is absolutely continuous with respect to `ν`.


theorem Real.sqrt_nonneg : ∀ (x : ℝ), 0 ≤ Real.sqrt x := by sorry

This theorem, `Real.sqrt_nonneg`, states that the square root of any real number is always nonnegative. In other words, for all real numbers `x`, the square root of `x` is greater than or equal to zero. This is expressed in mathematical terms as: ∀ (x : ℝ), 0 ≤ sqrt(x). Here, ℝ denotes the set of all real numbers. This result follows from the fact that the square root of a number is defined as a nonnegative number whose square is the original number.


theorem List.cons_bind :
    ∀ {α : Type u_1} {β : Type u_2} (x : α) (xs : List α) (f : α → List β),
      List.bind (x :: xs) f = f x ++ List.bind xs f :=
  by sorry

This theorem, `List.cons_bind`, states that for any types `α` and `β`, an element `x` of type `α`, a list `xs` of type `α`, and a function `f` from `α` to a list of `β`, the result of using the `bind` operation on the list that starts with `x` and continues with `xs`, with the function `f`, is the same as concatenating the result of applying `f` to `x` and the result of using the `bind` operation on `xs` with the function `f`. Essentially, it is stating a property about how the `bind` operation distributes over list concatenation.

For any types `α` and `β`, given an element `x` of type `α`, a list `xs` of type `List α`, and a function `f : α → List β`, the laws `(x :: xs).bind(f) = f x @ (xs.bind(f))` and `(xs.bind(λ x => x :: List.nil)).bind(f) = xs.bind(f)` hold.


Measurable.aestronglyMeasurable

/-- In a space with second countable topology, measurable implies ae strongly measurable.  -/
theorem Measurable.aestronglyMeasurable :
    ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace β] {f : α → β} {x : MeasurableSpace α}
      {μ : MeasureTheory.Measure α} [inst_1 : MeasurableSpace β] [inst_2 : TopologicalSpace.PseudoMetrizableSpace β]
      [inst_3 : SecondCountableTopology β] [inst_4 : OpensMeasurableSpace β],
      Measurable f → MeasureTheory.AEStronglyMeasurable f μ :=
  by sorry

This theorem states that in a space with a second-countable topology, if a function `f` is measurable, then it is also almost everywhere (a.e.) strongly measurable with respect to a measure `μ`. Here, a function is said to be measurable if the preimage of every measurable set is also measurable. A function is almost everywhere strongly measurable if it is almost everywhere equal to the limit of a sequence of simple functions. The space in question must be pseudometrizable and the open sets in this space must be measurable.

In a second-countable, pseudometrizable space with measurable open sets, every measurable function is almost everywhere strongly measurable.


theorem Set.not_disjoint_iff : ∀ {α : Type u} {s t : Set α}, ¬Disjoint s t ↔ ∃ x ∈ s, x ∈ t := by sorry

The theorem `Set.not_disjoint_iff` states that for any type `α` and any two sets `s` and `t` of type `α`, the sets `s` and `t` are not disjoint if and only if there exists an element `x` which belongs to both `s` and `t`. In other words, the negation of the disjointness of two sets is equivalent to the existence of a common element in the two sets. This is a generalization of the concept of disjoint sets in set theory, where two sets are said to be disjoint if they have no elements in common.

For any type `α` and sets `s` and `t` of type `α`, `s` and `t` are not disjoint if and only if there exists an element `x` in `α` that belongs to both `s` and `t`.


theorem map_nsmul :
    ∀ {G : Type u_7} {H : Type u_8} {F : Type u_9} [inst : FunLike F G H] [inst_1 : AddMonoid G] [inst_2 : AddMonoid H]
      [inst_3 : AddMonoidHomClass F G H] (f : F) (n : ℕ) (a : G), f (n • a) = n • f a :=
  by sorry

The theorem `map_nsmul` states that for any types `G`, `H`, and `F`, given that `F` is a function-like type from `G` to `H`, and both `G` and `H` are additive monoids, and `F` is a homomorphism class from `G` to `H`, then for any function `f` of type `F`, natural number `n`, and element `a` of `G`, the result of applying `f` to the `n`-fold self-addition of `a` is equal to the `n`-fold self-addition of the result of applying `f` to `a`. In mathematical terms, if `F` is a homomorphism between the additive monoids `G` and `H`, then `f(na) = nf(a)` for all `n` in the natural numbers and `a` in `G`.

For any homomorphism `F` between additive monoids `G` and `H`, `F(na) = nF(a)` for all natural numbers `n` and elements `a` in `G`.


Measurable.stronglyMeasurable

/-- In a space with second countable topology, measurable implies strongly measurable.  -/
theorem Measurable.stronglyMeasurable :
    ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {mα : MeasurableSpace α} [inst : MeasurableSpace β]
      [inst_1 : TopologicalSpace β] [inst_2 : TopologicalSpace.PseudoMetrizableSpace β]
      [inst_3 : SecondCountableTopology β] [inst_4 : OpensMeasurableSpace β],
      Measurable f → MeasureTheory.StronglyMeasurable f :=
  by sorry

This theorem states that in a space with a second-countable topology, if a function is measurable, then it is also strongly measurable. More specifically, given a function `f` from an arbitrary type `α` to a type `β`, where `β` has a topological space structure, a pseudo-metrizable space structure, a second-countable topology, and an open measurable space, and both `α` and `β` have measurable space structures, if `f` is a measurable function (meaning that the preimage of every measurable set in `β` is a measurable set in `α`), then `f` is also a strongly measurable function (meaning that it is the limit of a sequence of simple functions).

In a second-countable, pseudo-metrizable space with a measurable space structure, a measurable function from a measurable space to the space is also strongly measurable.


theorem sSup_eq_iSup' : ∀ {α : Type u_1} [inst : SupSet α] (s : Set α), sSup s = ⨆ a, ↑a := by sorry

The theorem `sSup_eq_iSup'` states that for any type 'α' and for any set 's' of this type, where 'α' is equipped with a supremum operation (expressed by the `SupSet α` typeclass), the supremum of the set 's' (denoted by `sSup s`) is equal to the supremum over all elements 'a' of the set 's' (expressed by `⨆ a, ↑a`). Here, `⨆` symbol is used to represent the supremum operation and `↑a` denotes the inclusion of the element 'a' in the set 's'. The statement essentially reflects the property that the supremum of a set is the largest element in that set.

For any type 'α' with a supremum operation and any set 's' of 'α', the supremum of 's' equals the supremum of its elements. In Lean notation: `sSup s = ⨆ a ∈ s, ↑a`.


theorem div_div : ∀ {α : Type u_1} [inst : DivisionCommMonoid α] (a b c : α), a / b / c = a / (b * c) := by sorry

This theorem, `div_div`, states that for any type `α` that has a structure of a commutative division monoid, for any three elements `a`, `b`, and `c` of this type, dividing `a` by `b`, and then the result by `c`, is equivalent to dividing `a` directly by the product of `b` and `c`. In mathematical notation, this would be expressed as $\frac{\frac{a}{b}}{c} = \frac{a}{b \cdot c}$.

For any commutative division monoid type `α`, the quotient of `a` divided by `b` and then divided by `c` equals the quotient of `a` divided by the product of `b` and `c`. In Lean 4, this is expressed as the theorem `div_div : (∀ (α : Type) [CommMonoid α], ∀ (a b c : α), (a / b) / c = a / (b * c))`.


theorem LinearMap.map_sub :
    ∀ {R : Type u_1} {S : Type u_6} {M : Type u_9} {M₂ : Type u_11} [inst : Semiring R] [inst_1 : Semiring S]
      [inst_2 : AddCommGroup M] [inst_3 : AddCommGroup M₂] {module_M : Module R M} {module_M₂ : Module S M₂}
      {σ : R →+* S} (f : M →ₛₗ[σ] M₂) (x y : M), f (x - y) = f x - f y :=
  by sorry

The theorem `LinearMap.map_sub` states that for any two elements `x` and `y` of a module `M` over a semiring `R`, and a linear map `f` from `M` to another module `M₂` over a semiring `S`, the image of the difference `x - y` under `f` is equal to the difference of the images of `x` and `y`. In other words, the linear map `f` preserves subtraction. This holds under the condition that there exists a ring homomorphism from `R` to `S`.

For any linear map $f$ between modules $M$ and $M\_2$ over semirings $R$ and $S$, respectively, with a ring homomorphism $h : R \rightarrow S$, we have $f(x - y) = f(x) - f(y)$ for all $x, y \in M$.


theorem Set.inter_iUnion : ∀ {β : Type u_2} {ι : Sort u_4} (s : Set β) (t : ι → Set β), s ∩ ⋃ i, t i = ⋃ i, s ∩ t i :=
  by sorry

This theorem states that for any set `s` of elements of type `β` and any indexed collection `t` of sets of elements of type `β` (indexed by elements of type `ι`), the intersection of `s` with the union of the `t` sets (over all `ι`) is equal to the union of the intersections of `s` with each `t` set (over all `ι`). In mathematical notation, this would be expressed as \(s \cap (\bigcup_i t_i) = \bigcup_i (s \cap t_i)\). This is a statement about the distributive property of intersection over union in the context of sets.

The theorem asserts that for any set `s` and indexed family `t` of sets, the intersection of `s` with the union of the `t` sets equals the union of the intersections of `s` with each `t` set. In mathematical notation: \(s \cap (\bigcup\_{i} t\_i) = \bigcup\_{i} (s \cap t\_i)\).


theorem Set.image2_singleton_right :
    ∀ {α : Type u_1} {β : Type u_3} {γ : Type u_5} {f : α → β → γ} {s : Set α} {b : β},
      Set.image2 f s {b} = (fun a => f a b) '' s :=
  by sorry

This theorem states that, for any types `α`, `β`, and `γ`, any binary function `f` from `α` and `β` to `γ`, any set `s` of type `α`, and any element `b` of type `β`, the image of the binary function `f` when applied to the set `s` and the singleton set containing `b` is the same as the image of the function that maps each element `a` of `s` to `f a b`. In mathematical terms, it's saying that the image under `f` of `s` and the singleton set `{b}` is the same as the image under the function `a ↦ f(a, b)` of `s`.

For any functions $f : \alpha \times \beta \to \gamma$, sets $s \subseteq \alpha$, and elements $b \in \beta$, the set $f''(s \times \{b\}) = \{f(a, b) \mid a \in s\}$.


Set.Finite.measurableSet

theorem Set.Finite.measurableSet :
    ∀ {α : Type u_1} [inst : MeasurableSpace α] [inst_1 : MeasurableSingletonClass α] {s : Set α},
      Set.Finite s → MeasurableSet s :=
  by sorry

This theorem states that for any type `α` with a measurable space structure and a measurable singleton class structure, any finite set `s` of type `α` is also a measurable set. In other words, given a finite set in a measurable space, we can always regard it as a measurable set. This is achieved under the assumption that the singletons (sets with only one element) in the space are measurable.

Given a measurable space `(α, Σ)` with measurable singletons, every finite set `s ⊆ α` belongs to `Σ`.


theorem sigma_mk_injective : ∀ {α : Type u_1} {β : α → Type u_4} {i : α}, Function.Injective (Sigma.mk i) := by sorry

The theorem `sigma_mk_injective` states that for any type `α`, for any type function `β` that maps from `α`, and for any instance `i` of `α`, the mapping function `Sigma.mk i` is injective. In other words, given two elements from the type `β i`, if they are mapped to the same value by the function `Sigma.mk i`, then they must have been the same element to begin with.

For any type `α` and type function `β : α → Type`, the function `Sigma.mk : ∀ i : α, β i → Σ i, x ∈ β i ↦ Sigma.mk i x = Sigma.mk i y ↔ x = y` is a function identity.


IsGreatest.isLUB

theorem IsGreatest.isLUB : ∀ {α : Type u} [inst : Preorder α] {s : Set α} {a : α}, IsGreatest s a → IsLUB s a := by
  sorry

The theorem `IsGreatest.isLUB` states that for all types `α` with a preorder structure, for any set `s` of type `α` and any element `a` of type `α`, if `a` is the greatest element of the set `s`, then `a` is also the least upper bound of the set `s`. In other words, if an element is the greatest element in a set (with respect to a given preorder), then it also serves as the least upper bound for that set.

If `α` is a type with a preorder structure, and `a` is the greatest element of a set `s` in `α`, then `a` is the least upper bound of `s`.


theorem Mathlib.Algebra.Star.SelfAdjoint._auxLemma.5 :
    ∀ {R : Type u_1} [inst : Star R] {x : R}, IsSelfAdjoint x = (star x = x) := by sorry

The theorem `Mathlib.Algebra.Star.SelfAdjoint._auxLemma.5` states that for any type `R` equipped with a star operation (denoted by `Star R`), and any element `x` of `R`, this element `x` is self-adjoint (as defined by the function `IsSelfAdjoint`) if and only if `x` is equal to its star operation (`star x = x`). In other words, the theorem is saying that an element is self-adjoint if it is equal to its own complex conjugate in the context of complex numbers.

An element in a type equipped with a star operation is self-adjoint if and only if it is equal to its complex conjugate (star operation).


Continuous.aestronglyMeasurable

/-- A continuous function from `α` to `β` is ae strongly measurable when one of the two spaces is
second countable.  -/
theorem Continuous.aestronglyMeasurable :
    ∀ {α : Type u_1} {β : Type u_2} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} [inst : TopologicalSpace β]
      {f : α → β} [inst_1 : TopologicalSpace α] [inst_2 : OpensMeasurableSpace α]
      [inst_3 : TopologicalSpace.PseudoMetrizableSpace β] [inst_4 : SecondCountableTopologyEither α β],
      Continuous f → MeasureTheory.AEStronglyMeasurable f μ :=
  by sorry

The theorem states that for any continuous function `f` from a measurable space `α` to a topological space `β`, the function is almost everywhere strongly measurable with respect to a measure `μ`, provided one of the two spaces, either `α` or `β`, has a second-countable topology. Here, a function is called almost everywhere strongly measurable if it is almost everywhere equal to the limit of a sequence of simple functions. A space having a second-countable topology means that it has a countable base for its topology. The conditions that `α` is an open measurable space and `β` is a pseudo-metrizable space are also required.

If `α` is an open measurable space, `β` is a pseudo-metrizable space, and one of them has a second-countable topology, then every continuous function `f` from `α` to `β` is almost everywhere strongly measurable with respect to any measure `μ` on `α`.


theorem neg_nsmul : ∀ {α : Type u_1} [inst : SubtractionMonoid α] (a : α) (n : ℕ), n • -a = -(n • a) := by sorry

This theorem states that for all types `α` (assuming `α` is a subtraction monoid), for any element `a` of `α` and any natural number `n`, the negation of `a` n-times scaled is equal to the negation of `a` scaled n-times. In other words, it expresses that scaling a negative number `n` times is equivalent to negating the number first and then scaling it `n` times. This is a property of subtraction monoids, a kind of algebraic structure.

For any subtraction monoid type `α` and element `a` in `α`, negating and scaling `a` by a natural number `n` is equivalent: `-(a * n) = (-a) * n`.


theorem Unique.forall_iff : ∀ {α : Sort u_1} [inst : Unique α] {p : α → Prop}, (∀ (a : α), p a) ↔ p default := by sorry

This theorem states that for any sort `α`, given that `α` has a unique instance, and considering a property `p` that applies to all elements of `α`, it is equivalent to say that `p` holds for all elements of `α` and to say that `p` holds for the default element of `α`. In other words, if there's only one instance of a sort, proving a property about all instances is the same as proving it about the default instance.

For any sort `α` with a unique instance and property `p`, proving `p` for all elements of `α` is equivalent to proving `p` for the default element of `α`.


theorem CategoryTheory.Iso.inv_hom_id_app_assoc :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂}
      [inst_1 : CategoryTheory.Category.{v₂, u₂} D] {F G : CategoryTheory.Functor C D} (α : F ≅ G) (X : C) {Z : D}
      (h : G.obj X ⟶ Z),
      CategoryTheory.CategoryStruct.comp (α.inv.app X) (CategoryTheory.CategoryStruct.comp (α.hom.app X) h) = h :=
  by sorry

This theorem, titled `CategoryTheory.Iso.inv_hom_id_app_assoc`, states that for any categories `C` and `D` with functors `F` and `G` between them, if `α` is a natural isomorphism between `F` and `G` and `X` is an object of `C`, then for any morphism `h` from `G.obj X` to some object `Z` in `D`, the composition of the inverse of the component of `α` at `X` with the composition of the component of `α` at `X` and `h` is equal to `h`. In other words, it demonstrates that the inverse of a natural isomorphism, when composed with the original isomorphism, results in the identity, in accordance with the properties of an isomorphism in category theory.

Given categories `C`, `D` with functors `F` and `G` between them, a natural isomorphism `α: F ≅ G`, and an object `X` in `C` and a morphism `h: G(X) → Z` in `D`, the composition of `h` with `α.inv (X)` and `α (X)` is equal to `h`.


theorem Finsupp.single_add :
    ∀ {α : Type u_1} {M : Type u_5} [inst : AddZeroClass M] (a : α) (b₁ b₂ : M),
      (fun₀ | a => b₁ + b₂) = (fun₀ | a => b₁) + fun₀ | a => b₂ :=
  by sorry

This theorem states that for any type `α`, a second type `M` that forms an additive monoid, and any elements `a` from `α`, `b₁` and `b₂` from `M`, the finitely supported function `fun₀` that maps `a` to the sum of `b₁` and `b₂` is equal to the sum of the finitely supported function `fun₀` that maps `a` to `b₁` and the finitely supported function `fun₀` that maps `a` to `b₂`. That is, the function behaves linearly with respect to addition in `M`. The `Finsupp.single_add` theorem essentially captures the distributive law for functions.

For any type `α`, any additive monoid `M`, and any `a` in `α` and `b₁, b₂` in `M`, the finitely supported function mapping `a` to `b₁ + b₂` is equal to the sum of the functions mapping `a` to `b₁` and `a` to `b₂`.


theorem isMin_bot : ∀ {α : Type u} [inst : Preorder α] [inst_1 : OrderBot α], IsMin ⊥ := by sorry

The theorem `isMin_bot` states that for any type `α` that has a pre-order (a binary relation that is reflexive and transitive) and a least element (defined by `OrderBot α`), the least element, denoted by `⊥`, is a minimal element. In other words, there is no other element in `α` that is strictly less than the least element. This property is characterized by `IsMin`, meaning that if any element `b` of `α` is less than or equal to `⊥`, then `⊥` is less than or equal to `b`.

For any type `α` with a pre-order and a least element `⊥`, `⊥` is the unique minimal element, i.e., for all `b` in `α`, `⊥ ≤ b` implies `b ≤ ⊥`.


theorem Metric.nhds_basis_closedBall :
    ∀ {α : Type u} [inst : PseudoMetricSpace α] {x : α},
      Filter.HasBasis (nhds x) (fun ε => 0 < ε) (Metric.closedBall x) :=
  by sorry

This theorem states that for any point `x` in a space of type `α` that has a pseudometric space structure, the neighborhood filter at `x` has a basis consisting of closed balls around `x`. Specifically, the basis sets are those closed balls `Metric.closedBall x ε` such that `ε` is a positive real number. In mathematical terms, this means that any neighborhood of `x` can be represented as a union of such closed balls, providing a fundamental structure for the topology of the pseudometric space.

For any point in a pseudometric space, the neighborhood filter has a basis consisting of closed balls around that point with positive real radii.


QuadraticForm.ext

theorem QuadraticForm.ext :
    ∀ {R : Type u_3} {M : Type u_4} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
      {Q Q' : QuadraticForm R M}, (∀ (x : M), Q x = Q' x) → Q = Q' :=
  by sorry

This theorem, `QuadraticForm.ext`, states that for any commutative semiring `R` and any additive commutative monoid `M` that is also a module over `R`, if we have two quadratic forms `Q` and `Q'` on `M` such that for every element `x` of `M`, the value of `Q` at `x` equals the value of `Q'` at `x`, then `Q` and `Q'` are actually the same quadratic form. In other words, two quadratic forms are equal if and only if they agree on all elements of the module.

Two quadratic forms on a commutative `R`-module `M` are equal if and only if they yield identical values for all elements of `M`.


Filter.Tendsto.congr

theorem Filter.Tendsto.congr :
    ∀ {α : Type u} {β : Type v} {f₁ f₂ : α → β} {l₁ : Filter α} {l₂ : Filter β},
      (∀ (x : α), f₁ x = f₂ x) → Filter.Tendsto f₁ l₁ l₂ → Filter.Tendsto f₂ l₁ l₂ :=
  by sorry

The theorem `Filter.Tendsto.congr` states that for any two functions `f₁` and `f₂` from a type `α` to a type `β`, and any two filters `l₁` over `α` and `l₂` over `β`, if every output of `f₁` equals the output of `f₂` for all inputs, then if `f₁` tends to the limit `l₂` under the filter `l₁`, `f₂` also tends to the same limit under the same filter. In other words, this theorem asserts that if two functions are equivalent, their limits at a point, if exist, are also equivalent.

If functions `f₁` and `f₂` map the same output for all inputs in filters `l₁` over `α` and `l₂` over `β`, then `f₁` tends to the limit `l₂` if and only if `f₂` tends to the same limit under `l₁`.


theorem Set.mem_Icc : ∀ {α : Type u_1} [inst : Preorder α] {a b x : α}, x ∈ Set.Icc a b ↔ a ≤ x ∧ x ≤ b := by sorry

The theorem `Set.mem_Icc` states that for any type `α` that has a preorder (a binary relation that is reflexive and transitive), and any elements `a`, `b`, and `x` of `α`, `x` is in the interval from `a` to `b` (including both `a` and `b`) if and only if `x` is greater than or equal to `a` and less than or equal to `b`. In other words, `x` belongs to the closed interval `[a, b]` precisely when `a ≤ x ≤ b`.

For any preorder relation on type `α`, an element `x` lies in the interval `[a, b]` if and only if `a ≤ x ≤ b`.


theorem Set.inclusion_injective : ∀ {α : Type u_1} {s t : Set α} (h : s ⊆ t), Function.Injective (Set.inclusion h) := by
  sorry

The theorem `Set.inclusion_injective` states that for any type `α` and for any two sets `s` and `t` of type `α`, if `s` is a subset of `t` (denoted as `s ⊆ t`), then the function `Set.inclusion h` is injective. In other words, `Set.inclusion h` maps distinct elements of `s` to distinct elements of `t`. Here, `Set.inclusion h` is a function that acts like the identity for elements in `s`, but each element is viewed as an element of `t` due to the subset relation.

If `s` is a subset of `t` in type `α`, then the function `Set.inclusion h` mapping elements of `s` to their respective elements in `t` is an injection.


theorem intervalIntegral.integral_same :
    ∀ {E : Type u_3} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {a : ℝ} {f : ℝ → E}
      {μ : MeasureTheory.Measure ℝ}, ∫ (x : ℝ) in a..a, f x ∂μ = 0 :=
  by sorry

This theorem states that for any normed additivity commutative group `E`, and any normed space `E` over the real numbers, the integral of any real-valued function `f` over the interval from `a` to `a` (i.e., an interval with the same lower and upper bound) with respect to a given measure `μ` is always equal to zero. This is essentially stating that the integral over an interval of zero width is zero, regardless of the function and the measure used.

For any normed additive commutative group `E` over the real numbers, any normed space `E` with real-valued function `f`, and any measure `μ` on an interval `[a, a]`, ∫(f dμ) = 0.


theorem Real.cos_pi_div_two : Real.cos (Real.pi / 2) = 0 := by sorry

This theorem states that the cosine of pi divided by two, when calculated on the set of real numbers, equals zero. In other words, it formalizes the well-known trigonometric property that $\cos(\pi / 2) = 0$ in the context of real numbers.

cos (pi / 2) = 0 on the set of real numbers.


theorem RatFunc.denom_ne_zero : ∀ {K : Type u} [inst : Field K] (x : RatFunc K), RatFunc.denom x ≠ 0 := by sorry

The theorem `RatFunc.denom_ne_zero` states that for any rational function `x` over a generic field `K`, the denominator of `x`, when normalized to be monic, is not equal to zero. This means, the monic normalization of the denominator of any rational function in any field never results in the zero polynomial.

For any rational function over a field, the normalized denominator is never the zero polynomial.


theorem Submodule.span_eq :
    ∀ {R : Type u_1} {M : Type u_4} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
      (p : Submodule R M), Submodule.span R ↑p = p :=
  by sorry

The theorem `Submodule.span_eq` states that for any semiring `R`, any commutative additive monoid `M`, and any module `M` over `R`, for any submodule `p` of `M`, the span of the set of elements in `p` (denoted as `Submodule.span R ↑p`) is equal to `p` itself. In other words, the smallest submodule that contains all elements of `p` is `p`.

For any semiring `R`, commutative additive monoid `M`, and module `M` over `R`, the submodule generated by a submodule `p` of `M` (denoted as `Submodule.span R p`) equals `p` itself.


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

This theorem, `Function.mem_support`, states that for all types `α` and `M` with `M` having an instance of the `Zero` class, and for any function `f` from `α` to `M` and any element `x` of `α`, `x` is an element of the support of the function `f` if and only if the function `f` applied to `x` is not equal to zero. In mathematical terms, this can be written as \(x \in \text{supp}(f) \iff f(x) \neq 0\), where \(\text{supp}(f)\) represents the support of the function `f`.

The support of a function from type `α` to a type `M` with `M` having an instance of the `Zero` class, contains an element `x` of `α` if and only if the function applied to `x` is non-zero.


theorem symmDiff_comm :
    ∀ {α : Type u_2} [inst : GeneralizedCoheytingAlgebra α] (a b : α), symmDiff a b = symmDiff b a := by sorry

This theorem states that for any type `α` that is a Generalized Coheyting Algebra, the symmetric difference operation is commutative. In other words, given any two elements `a` and `b` of this type, the symmetric difference of `a` and `b` is the same as the symmetric difference of `b` and `a`. The symmetric difference operation being referred to here is defined as the union of the difference of `a` and `b` and the difference of `b` and `a`.

For any type `α` that is a Generalized Coalgebra, the symmetric difference of two elements `a` and `b` is commutative, i.e., `a \\ b = b \\ a`.


theorem Fintype.card_le_of_injective :
    ∀ {α : Type u_1} {β : Type u_2} [inst : Fintype α] [inst_1 : Fintype β] (f : α → β),
      Function.Injective f → Fintype.card α ≤ Fintype.card β :=
  by sorry

The theorem `Fintype.card_le_of_injective` states that for any two types `α` and `β`, both of which have a finite number of elements (i.e., they are `Fintype`s), if we have a function `f` from `α` to `β` that is injective (meaning no two different elements in `α` map to the same element in `β`), then the number of elements in `α` (denoted by `Fintype.card α`) is less than or equal to the number of elements in `β` (denoted by `Fintype.card β`). This aligns with the intuitive idea that an injective function cannot map more unique inputs to unique outputs than there are outputs available.

If `α` and `β` are finite types and `f: α → β` is an injective function, then `Fintype.card α ≤ Fintype.card β`.


theorem funext₂ :
    ∀ {α : Sort u_1} {β : α → Sort u_2} {γ : (a : α) → β a → Sort u_3} {f g : (a : α) → (b : β a) → γ a b},
      (∀ (a : α) (b : β a), f a b = g a b) → f = g :=
  by sorry

This theorem, `funext₂`, is a generalized statement of function extensionality in Lean 4. It states that for all types `α`, `β` (which is dependent on `α`), and `γ` (which is dependent on both `α` and `β`), and for all functions `f` and `g` that map a pair of values from `α` and `β` to `γ`, if `f` and `g` are pointwise equal (i.e., for all `a` from `α` and `b` from `β`, `f a b` equals `g a b`), then `f` is identical to `g`. In simpler terms, two functions are the same if they give the same output for every input.

For all types `α`, `β`, and dependent types `γ`, if two functions `f` and `g` from `α × β` to `γ` agree on all inputs, then they are equal.


theorem Option.map₂_coe_right :
    ∀ {α : Type u_1} {β : Type u_3} {γ : Type u_2} (f : α → β → γ) (a : Option α) (b : β),
      Option.map₂ f a (some b) = Option.map (fun a => f a b) a :=
  by sorry

This theorem, `Option.map₂_coe_right`, states that for any types `α`, `β`, and `γ`, any binary function `f : α → β → γ`, any optional value `a : Option α`, and any value `b : β`, applying the binary function `f` to the optional value `a` and the option-wrapped value `some b` using `Option.map₂` is equivalent to applying a function to `a` using `Option.map`, where the function applies `f` to its argument and `b`. Essentially, this theorem asserts that the process of mapping a binary function over an optional value and a certain value (wrapped in `Option`) can be rewritten as mapping a function over the optional value alone, where the function is the partial application of the binary function to the certain value.

For any types `α`, `β`, and `γ`, and any binary function `f : α → β → γ`, `Option.map₂ f (some x) (some y) = Option.map (λ a, f a y) (some x)`.


theorem ENNReal.coe_rpow_of_nonneg : ∀ (x : NNReal) {y : ℝ}, 0 ≤ y → ↑x ^ y = ↑(x ^ y) := by sorry

This theorem states that for any non-negative real number 'x', and any real number 'y' where 'y' is non-negative, the real number equivalent (or coercion) of 'x' raised to the power 'y' is equal to the real number equivalent of 'x' raised to the power 'y'. In other words, when 'y' is non-negative, the operation of exponentiation commutes with the operation of converting a non-negative real number to a real number.

For any non-negative real numbers x and y, x^y = (reals x)^y.


theorem ZMod.val_nat_cast : ∀ {n : ℕ} (a : ℕ), ZMod.val ↑a = a % n := by sorry

This theorem, `ZMod.val_nat_cast`, states that for any natural number `n` and `a`, the value of `a` in the `ZMod n` structure, obtained using the `ZMod.val` function, is equal to the remainder of `a` divided by `n`. In mathematical terms, if we treat `ZMod.val` as a function mapping `ZMod n` to `ℕ`, then for any natural number `a`, `ZMod.val ↑a = a mod n`.

For any natural number `n` and `a`, `ZMod.val (ZMod.ofNat a) = a mod n`.


theorem CategoryTheory.Functor.congr_obj :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂}
      [inst_1 : CategoryTheory.Category.{v₂, u₂} D] {F G : CategoryTheory.Functor C D},
      F = G → ∀ (X : C), F.obj X = G.obj X :=
  by sorry

This theorem states that for any two functors `F` and `G` from a category `C` to a category `D`, if `F` equals `G`, then the object `F.obj X` is equal to the object `G.obj X` for every object `X` in the category `C`. In other words, two equivalent functors map the same object in the domain category to the same object in the codomain category.

For any functors F and G from a category C to a category D, if F is equal to G, then for all objects X in C, F.obj X = G.obj X.