theorem List.ofFn_succ :
    ∀ {α : Type u} {n : ℕ} (f : Fin (Nat.succ n) → α), List.ofFn f = f 0 :: List.ofFn fun i => f (Fin.succ i) := by
  sorry

The theorem `List.ofFn_succ` states that for any given type `α`, natural number `n`, and function `f` from `Fin (Nat.succ n)` to `α`, creating a list of function's results via `List.ofFn f` is equivalent to having the first element as `f 0` and the rest of the list generated by applying `f` to the successor of each `i` in `Fin n`. In other words, it states that the list generated by applying `f` to each element in `Fin (Nat.succ n)` is the same as the list obtained by prepending `f 0` to the list generated by applying `f` to the successor of each element in `Fin n`.

For any type `α`, natural number `n`, and function `f` from `Fin (Nat.succ n)` to `α`, the list `[f 0 :: List.map succ (List.map f (Fin.range n))]` equals `List.ofFn f (Fin.range (Nat.succ n))`.


theorem invOf_eq_inv : ∀ {α : Type u} [inst : GroupWithZero α] (a : α) [inst_1 : Invertible a], ⅟a = a⁻¹ := by sorry

This theorem states that for any type `α` that forms a group with a zero element (meaning it has operations for addition, multiplication, and a distinguished "zero" element, and these satisfy certain mathematical properties), if a given element `a` from this group is invertible (meaning that it has a multiplicative inverse), then its multiplicative inverse is equal to its inverse from the GroupWithZero structure. In other words, the notation `⅟a` (often used for the multiplicative inverse of `a`) is equivalent to `a⁻¹` (the notation for the inverse of `a` within a group structure).

For any group with zero `α` and invertible element `a`, `⅟a = a⁻¹`.


theorem Real.exp_add : ∀ (x y : ℝ), Real.exp (x + y) = Real.exp x * Real.exp y := by sorry

The `Real.exp_add` theorem states that for all real numbers `x` and `y`, the exponential of the sum `x + y` is equal to the product of the exponentials of `x` and `y`. In mathematical notation, this can be written as $e^{x+y} = e^x * e^y$. This corresponds to the well known property of exponentiation in the field of real numbers.

The `Real.exp_add` theorem asserts that for all real numbers `x` and `y`, $e^{x+y} = e^x \cdot e^y$.


Nat.Prime.prime

/-- **Alias** of the forward direction of `Nat.prime_iff`. -/
theorem Nat.Prime.prime : ∀ {p : ℕ}, Nat.Prime p → Prime p := by sorry

The theorem `Nat.Prime.prime` states that for every natural number `p`, if `p` is a prime number (according to the `Nat.Prime` definition which means `p` is a natural number at least 2 and the only divisors are `p` and `1`), then `p` is also a prime element in the context of a `CommMonoidWithZero` (according to the `Prime` definition which means `p` is not zero, is not a unit, and if `p` divides the product of `a` and `b`, then `p` must divide either `a` or `b`). This is essentially a translation between two different definitions of primality, each applicable in different mathematical settings.

For every natural number `p` that is a prime number according to the `Nat.Prime` definition, it is also a prime element in the context of a `CommMonoidWithZero`.


MulEquiv.injective

theorem MulEquiv.injective :
    ∀ {M : Type u_6} {N : Type u_7} [inst : Mul M] [inst_1 : Mul N] (e : M ≃* N), Function.Injective ⇑e := by sorry

The theorem `MulEquiv.injective` states that for any two types `M` and `N` where `M` and `N` are equipped with a multiplication operation (i.e., they are instances of the `Mul` typeclass), any multiplicative equivalence `e` between `M` and `N` is an injective function. In other words, if `e` is such a multiplicative equivalence, then for any two elements `a₁` and `a₂` in `M`, if `e` of `a₁` equals `e` of `a₂`, it implies that `a₁` equals `a₂`. This theorem doesn't provide a proof, it's represented as `by sorry`.

Given types `M` and `N` with multiplication operations, any multiplicative equivalence between `M` and `N` is a function with the property that if `e(a₁) = e(a₂)`, then `a₁ = a₂`.


theorem CategoryTheory.Abelian.exact_iff :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.Abelian C] {X Y Z : C}
      (f : X ⟶ Y) (g : Y ⟶ Z),
      CategoryTheory.Exact f g ↔
        CategoryTheory.CategoryStruct.comp f g = 0 ∧
          CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.kernel.ι g) (CategoryTheory.Limits.cokernel.π f) =
            0 :=
  by sorry

This theorem, `CategoryTheory.Abelian.exact_iff`, states that for any given category `C` with Abelian properties (`CategoryTheory.Abelian C`), and any three objects in the category: `X`, `Y`, `Z`, and any two morphisms `f: X ⟶ Y` and `g: Y ⟶ Z`, the sequence `f, g` is exact (i.e., `CategoryTheory.Exact f g`) if and only if two conditions are met:

1) The composition of `f` and `g` (i.e., `f ≫ g`) is a zero morphism, and
2) The composition of the map from the kernel of `g` to `X` and the map from `Y` to the cokernel of `f` (i.e., `CategoryTheory.Limits.kernel.ι g ≫ CategoryTheory.Limits.cokernel.π f`) is also a zero morphism.

In simpler terms, this theorem defines the exactness property in Abelian categories, which essentially states that the image of one morphism is the kernel of the next.

In an Abelian category, a sequence of morphisms is exact if and only if its composition is zero and the composition of the kernel of the last morphism with the cokernel of the first morphism is zero.


theorem Real.sqrt_eq_rpow : ∀ (x : ℝ), Real.sqrt x = x ^ (1 / 2) := by sorry

The theorem `Real.sqrt_eq_rpow` states that for every real number `x`, the square root of `x` is equivalent to `x` raised to the power of `1/2`. In mathematical terms, this theorem verifies the principle that the square root function (√x) and the fractional exponentiation function (x^(1/2)) are the same for any given real number `x`.

For all real numbers x, sqrt(x) = x^(1/2).


/-- **Krull's theorem**: if `I` is an ideal that is not the whole ring, then it is included in some
maximal ideal.  -/
theorem Ideal.exists_le_maximal :
    ∀ {α : Type u} [inst : Semiring α] (I : Ideal α), I ≠ ⊤ → ∃ M, Ideal.IsMaximal M ∧ I ≤ M := by sorry

**Krull's Theorem:** For any given semiring `α` and an ideal `I` in `α` that is not the entire semiring, there exists a maximal ideal `M` such that `I` is included in `M`. In other words, for any ideal `I` that doesn't span the whole semiring, we can always find a bigger ideal `M` that contains `I` and is maximal in the sense that there are no other ideals situated between `M` and the entire semiring.

For any semiring `α` and ideal `I` that is properly contained in `α`, there exists a maximal ideal `M` that contains `I`.


/-- **Alias** of the forward direction of `dense_iff_closure_eq`. -/
theorem Dense.closure_eq : ∀ {X : Type u} {s : Set X} [inst : TopologicalSpace X], Dense s → closure s = Set.univ := by
  sorry

This theorem, referred to as `Dense.closure_eq`, states that for any type `X` and any set `s` of that type, in the context of a topological structure over `X`, if the set `s` is dense in that topology, then the closure of `s` is equal to the universal set. In other words, when a set is dense in a given topological space, the smallest closed set that contains all its elements coincides with the set of all elements in the space.

In a topological space, if a set is dense then its closure is equal to the universal set.


theorem le_zero_of_zero_ge : ∀ {α : Type u_1} [inst : Zero α] [inst_1 : LE α] {a : α}, 0 ≥ a → a ≤ 0 := by sorry

This theorem, `le_zero_of_zero_ge`, states that for any type `α` which has a zero and an order relation (denoted by `LE`), if zero is greater than or equal to a number `a` of type `α` (expressed as `0 ≥ a`), then it follows that `a` must be less than or equal to zero (expressed as `a ≤ 0`). Essentially, it's a way of enforcing that if `0` is not less than `a`, then `a` must not be more than `0`, considering the properties of the ordering on the type `α`.

If `α` is a type with a zero and `LE` order relation, then `0 ≥ a` implies `a ≤ 0`.


theorem mul_left_injective :
    ∀ {G : Type u_3} [inst : Mul G] [inst_1 : IsRightCancelMul G] (a : G), Function.Injective fun x => x * a := by sorry

This theorem states that for any type `G` that has a multiplication operation and satisfies the property of right cancellation, multiplication from the left by a fixed element `a` of type `G` is an injective function. In other words, if `x * a = y * a` then `x = y`. Here, right cancellation means that for any `x`, `y` and `a` in `G`, if `x * a = y * a`, then `x = y`.

For any type `G` with right cancellation and multiplication operation, multiplication by a fixed element `a` from the left is an injection.


theorem isGLB_biInf :
    ∀ {α : Type u_1} {β : Type u_2} [inst : CompleteLattice α] {s : Set β} {f : β → α}, IsGLB (f '' s) (⨅ x ∈ s, f x) :=
  by sorry

The theorem `isGLB_biInf` states that for any types `α` and `β`, where `α` is a complete lattice, along with a set `s` of type `β` and a function `f` from `β` to `α`, the greatest lower bound of the image of the set `s` under the function `f` is equal to the infimum of the set of all values of `f(x)` for `x` in `s`. In other words, it asserts that the greatest lower bound of the set of all function values at elements of `s` is the infimum of these function values.

For any complete lattice α, set s of type β, and function f from β to α, the greatest lower bound of the image of s under f equals the infimum of the values in the range of f over s.


theorem Real.two_pi_pos : 0 < 2 * Real.pi := by sorry

This theorem states that the product of 2 and π (pi), where π is defined as twice a zero of cosine in the interval [1,2], is a positive real number. In mathematical notation, this is expressed as 0 < 2 * π.

The theorem asserts that the product of 2 and the real number π, defined as twice a zero of cosine in the interval [1, 2], is a positive real number. In mathematical notation, 2 * π > 0.


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

This theorem states that for any type `α`, and any normed additive commutative group `G` that is also a normed space over the real numbers, given a measurable space `m` and a measure `μ` on that space, the integral over all `x` in `α` of the constant function 0 with respect to the measure `μ` is 0. In simpler terms, it's stating that if you integrate the constant zero function over any measure space, you'll always get zero irrespective of the space and the measure.

For any normed additive commutative group `G` over the real numbers, and any measurable space `(α, m)`, the integral of the constant function 0 with respect to measure `μ` is equal to 0.


theorem inf_bot_eq : ∀ {α : Type u} [inst : SemilatticeInf α] [inst_1 : OrderBot α] (a : α), a ⊓ ⊥ = ⊥ := by sorry

This theorem states that for any type `α` which is a semilattice with respect to the operation of infimum (also known as 'meet' or 'greatest lower bound') and has a bottom element (the least element in the set), the infimum of any element `a` of type `α` and the bottom element is always the bottom element. In other words, in a meet-semilattice with a least element, the greatest lower bound of any element and the least element is always the least element itself.

In a semilattice with a bottom element, the infimum of any element with the bottom element is the bottom element itself.


theorem continuous_coinduced_rng : ∀ {α : Type u} {β : Type v} {f : α → β} {t : TopologicalSpace α}, Continuous f := by
  sorry

This theorem states that for any given types `α` and `β`, a function `f` from `α` to `β`, and a topological space `t` on `α`, the function `f` is continuous. In mathematical terms, this theorem is asserting that under the coinduced topology on the range of a function, the function is always continuous.

For any types `α`, `β`, and a continuous function `f` from `α` to `β`, the function `f` is continuous with respect to any topology on `α`.


theorem Set.indicator_apply :
    ∀ {α : Type u_1} {M : Type u_4} [inst : Zero M] (s : Set α) (f : α → M) (a : α) [inst_1 : Decidable (a ∈ s)],
      Set.indicator s f a = if a ∈ s then f a else 0 :=
  by sorry

The theorem `Set.indicator_apply` states that for any set `s` of some type `α`, a function `f` from `α` to another type `M` that has a zero element (denoted by `[Zero M]`), and an element `a` of type `α`, if it is decidable whether `a` belongs to the set `s` (denoted by `[Decidable (a ∈ s)]`), then applying the `Set.indicator` function on `s`, `f`, and `a` yields the same result as checking whether `a` belongs to `s`: if `a` does belong, it returns the result of applying `f` on `a`; if `a` does not belong, it returns the zero element of `M`.

If `s` is a set of type `α` with a decidable membership relation and `f: α → M` is a function with a zero element, then `Set.indicator s f` is the characteristic function of `s` with respect to `f`.


theorem Set.forall_image2_iff :
    ∀ {α : Type u_1} {β : Type u_3} {γ : Type u_5} {f : α → β → γ} {s : Set α} {t : Set β} {p : γ → Prop},
      (∀ z ∈ Set.image2 f s t, p z) ↔ ∀ x ∈ s, ∀ y ∈ t, p (f x y) :=
  by sorry

This theorem `Set.forall_image2_iff` states that for any types `α`, `β`, and `γ`; for any binary function `f: α → β → γ`; for any sets `s: Set α`, `t: Set β`; and for any property `p: γ → Prop`, the property `p` holds for all elements in the image of the function `f` applied to sets `s` and `t` if and only if the property `p` holds for all possible results of the function `f` applied to any element from `s` and any element from `t`. In simple terms, if you apply `f` to every possible pair of elements from `s` and `t` and the property `p` holds for all these results, then `p` also holds for all elements in the set generated by applying `f` to the sets `s` and `t`.

For any types α, β, γ, function f: α → β → γ, sets s: Set α, t: Set β, and property p: γ → Prop, the function image of p under f applied to sets s and t is equal to {x : γ | ∃ a: α, ∃ b: β, a ∈ s ∧ b ∈ t ∧ p(f a b)}.


Path.ext

theorem Path.ext : ∀ {X : Type u_1} [inst : TopologicalSpace X] {x y : X} {γ₁ γ₂ : Path x y}, ⇑γ₁ = ⇑γ₂ → γ₁ = γ₂ := by
  sorry

This theorem, `Path.ext`, states that for any type `X` that has a `TopologicalSpace` instance and for any two points `x` and `y` in `X`, if we have two paths `γ₁` and `γ₂` from `x` to `y`, and if the continuous maps from the unit interval [0, 1] to `X` induced by `γ₁` and `γ₂` are equal (i.e., `⇑γ₁ = ⇑γ₂`), then the two paths `γ₁` and `γ₂` themselves are equal (i.e., `γ₁ = γ₂`). This theorem basically tells us that the equality of paths in a topological space can be determined by the equality of their induced continuous maps.

In a topological space, if two continuous paths from one point to another have equal induced continuous maps from the unit interval, then they are equal as paths.


theorem FirstOrder.Language.Substructure.gc_map_comap :
    ∀ {L : FirstOrder.Language} {M : Type w} {N : Type u_1} [inst : FirstOrder.Language.Structure L M]
      [inst_1 : FirstOrder.Language.Structure L N] (f : FirstOrder.Language.Hom L M N),
      GaloisConnection (FirstOrder.Language.Substructure.map f) (FirstOrder.Language.Substructure.comap f) :=
  by sorry

The theorem `FirstOrder.Language.Substructure.gc_map_comap` states that for any first-order language `L`, and any types `M` and `N` that have a `FirstOrder.Language.Structure` over `L`, and for any homomorphism `f` from `M` to `N` in the language `L`, there is a Galois connection between the operation of mapping substructures along `f` and the operation of taking preimages of substructures along `f`. In other words, for a given substructure `S` of `M` and a substructure `T` of `N`, the image of `S` under `f` is a subset of `T` if and only if `S` is a subset of the preimage of `T` under `f`. This is a fundamental property connecting the map and comap operations in the theory of first-order language structures.

For any first-order language L, types M and N with structures over L, and homomorphism f from M to N, the mapping of substructures along f and the taking of preimages of substructures along f form a Galois connection.


theorem Mathlib.Data.Part._auxLemma.19 :
    ∀ {α : Type u_1} {β : Type u_2} {f : Part α} {g : α → Part β} {b : β}, (b ∈ Part.bind f g) = ∃ a ∈ f, b ∈ g a := by
  sorry

The theorem `Mathlib.Data.Part._auxLemma.19` states that for any two types `α` and `β`, a partial function `f` from `Part α`, a function `g` from `α` to `Part β`, and an element `b` of type `β`, the element `b` is in the result of binding `f` and `g` (i.e., `b ∈ Part.bind f g`) if and only if there exists an element `a` in `f` such that `b` is in `g a`. In other words, the theorem is defining the conditions under which a value `b` is a member of the result of the `bind` operation on `f` and `g`.

For any partial functions `f` from `α` to `Part β` and `g` from `α` to `β`, and any `b` in `β`, `b` is in the result of binding `f` and `g` (`b ∈ Part.bind f g`) if and only if there exists an `a` in `α` such that `b` is in `g a`.


theorem Polynomial.revAt_le : ∀ {N i : ℕ}, i ≤ N → (Polynomial.revAt N) i = N - i := by sorry

The theorem `Polynomial.revAt_le` states that for any natural numbers `N` and `i`, if `i` is less than or equal to `N`, then applying the `Polynomial.revAt` function to `i` (with `N` as the parameter) will result in `N - i`. This theorem essentially confirms the behavior of the `Polynomial.revAt` function for numbers `i` less than or equal to `N`, as stated in the function's definition.

For any natural number `N` and `i` less than or equal to `N`, `Polynomial.revAt i N = N - i`.


theorem Equiv.nonempty_congr : ∀ {α : Sort u} {β : Sort v}, α ≃ β → (Nonempty α ↔ Nonempty β) := by sorry

This theorem, `Equiv.nonempty_congr`, states that for any two sorts (essentially type classes in Lean) `α` and `β`, if `α` is equivalent to `β`, denoted by `α ≃ β`, then the statement "there exists an element in `α`" (represented by `Nonempty α`) is logically equivalent to the statement "there exists an element in `β`" (represented by `Nonempty β`). In other words, if `α` and `β` are equivalent sorts, then `α` is nonempty if and only if `β` is nonempty.

If `α` is equivalent to `β`, then `Nonempty α` is logically equivalent to `Nonempty β`.


theorem List.prod_replicate :
    ∀ {M : Type u_5} [inst : Monoid M] (n : ℕ) (a : M), List.prod (List.replicate n a) = a ^ n := by sorry

The theorem states that for any type `M` which forms a Monoid (a mathematical structure with an associative binary operation and an identity element), any natural number `n`, and any element `a` of `M`, the product of a list created by replicating `a` `n` times is equal to `a` raised to the power of `n`. That is, if you create a list by repeating `a` `n` times and then find the product of this list, it will be the same as the monoid operation of `a` with itself `n` times (i.e., `a^n`).

For any monoid `M` and natural number `n`, the repeated multiplication of an element `a` in `M` equals the power `a^n` in `M`.


theorem Mathlib.Data.Finset.Basic._auxLemma.166 :
    ∀ {α : Type u_1} {s t : Multiset α}, (s ⊆ t) = ∀ ⦃x : α⦄, x ∈ s → x ∈ t := by sorry

This theorem, named `Mathlib.Data.Finset.Basic._auxLemma.166`, states that for any type `α` and any two multisets `s` and `t` of this type, `s` is a subset of `t` if and only if for every element `x` of type `α`, if `x` is an element of `s`, then `x` is also an element of `t`. Here, a multiset is considered as a type of finite sets where duplicates are allowed, and it is implemented as the quotient of a list by list permutation.

For any type `α`, multisets `s` and `t` of type `α`, `s ⊆ t` if and only if for all `x` in `α`, `x` in `s` implies `x` in `t`.


Filter.Frequently.mono

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

This theorem states that if there exists a filter `f` in a type `α` such that a predicate `p` holds frequently within `f`, and if for all `x` of type `α` `p x` implies `q x`, then `q x` also holds frequently within the filter `f`. In other words, the theorem asserts the preservation of frequency under a filter for a property when that property implies another one.

If a filter `f` in type `α` has property `p` holding frequently and `p(x)` implies `q(x)` for all `x` in `α`, then property `q` holds frequently within filter `f`.


Part.ext'

/-- `Part` extensionality  -/
theorem Part.ext' :
    ∀ {α : Type u_1} {o p : Part α}, (o.Dom ↔ p.Dom) → (∀ (h₁ : o.Dom) (h₂ : p.Dom), o.get h₁ = p.get h₂) → o = p := by
  sorry

This theorem, `Part.ext'`, expresses an extensionality property for partial functions in Lean 4. Specifically, it asserts that for any two partial functions `o` and `p` of the same type `α`, if their domains are equivalent (i.e., `o.Dom` if and only if `p.Dom`) and for every element in their domains, the function values are equal (i.e., `o.get h₁` equals `p.get h₂`), then `o` must be equal to `p`.

If two partial functions `o` and `p` from type `α` have equivalent domains and agree on their common domain elements (i.e., `o (h ∈ o.dom) = p (h)` for all `h ∈ o.dom`), then `o` equals `p`.


MeasureTheory.MeasurePreserving.symm

theorem MeasureTheory.MeasurePreserving.symm :
    ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] [inst_1 : MeasurableSpace β] (e : α ≃ᵐ β)
      {μa : MeasureTheory.Measure α} {μb : MeasureTheory.Measure β},
      MeasureTheory.MeasurePreserving (⇑e) μa μb → MeasureTheory.MeasurePreserving (⇑e.symm) μb μa :=
  by sorry

This theorem states that for any measure-preserving map `e` between two measure spaces `α` and `β`, the inverse map `e.symm` is also measure-preserving. Specifically, if `e` is a measurable equivalence (i.e., a bijective map where both `e` and its inverse are measurable) from `α` to `β`, and if `e` preserves the measure `μa` from `α` to the measure `μb` in `β`, then the inverse map `e.symm` preserves the measure `μb` from `β` to the measure `μa` in `α`.

If `e: α → β` is a measure-preserving measurable equivalence, then `e.symm: β → α` is also measure-preserving.


theorem Mathlib.Data.Finset.LocallyFinite.Basic._auxLemma.15 :
    ∀ {α : Type u_1} {s₁ s₂ : Finset α}, (s₁ ⊆ s₂) = (↑s₁ ⊆ ↑s₂) := by sorry

The theorem `Mathlib.Data.Finset.LocallyFinite.Basic._auxLemma.15` states that for all types `α` and for any two finite sets `s₁` and `s₂` of type `α`, `s₁` is a subset of `s₂` if and only if the coercion of `s₁` to a set is a subset of the coercion of `s₂` to a set. In the context of Lean 4, the coercion `↑` is used to treat a `Finset` (finite set) as a `Set`.

For any type α and finite sets s₁ and s₂ of type α, s₁ is a subset of s₂ if and only if the coerced finite set s₁ is contained in the coerced finite set s₂ as sets.


theorem PartialEquiv.image_source_eq_target :
    ∀ {α : Type u_1} {β : Type u_2} (e : PartialEquiv α β), ↑e '' e.source = e.target := by sorry

This theorem states that for every partial equivalence `e` between two types `α` and `β`, the image of the source set of `e` under the partial equivalence `e` is equal to the target set of `e`. In other words, if you take every element in the source of the partial equivalence and map it using `e`, you will get exactly the target set. This is a property that holds for every partial equivalence between two types.

For every partial equivalence relation `e` between types `α` and `β`, the images of `α` under `e` and `e.eq` are equal, where `e.eq` is the equivalence classes formed by `e`. (Or, more succinctly: The source and target sets of a partial equivalence relation are equal.)


theorem Int.negSucc_lt_zero : ∀ (n : ℕ), Int.negSucc n < 0 := by sorry

This theorem states that for any natural number `n`, the negative of the successor of `n` (represented as `Int.negSucc n` in Lean 4) is less than zero. In other words, if you take any natural number, increment it by one, and then take the negative of the result, the final result will always be a negative integer, i.e., less than zero.

For any natural number `n`, `- (Suc n) < 0`, where `Suc` represents the successor function.


theorem MeasureTheory.IsProbabilityMeasure.ne_zero :
    ∀ {α : Type u_1} {m0 : MeasurableSpace α} (μ : MeasureTheory.Measure α)
      [inst : MeasureTheory.IsProbabilityMeasure μ], μ ≠ 0 :=
  by sorry

In natural language, this theorem states that for any type `α` and any measurable space 'm0' over `α`, if `μ` is a probability measure, then `μ` is not equal to zero. In other words, all probability measures are non-zero in the context of the measurable space.

For any measurable space (α, m\_,) and probability measure μ on (α, m\_), μ ≠ 0.


theorem CategoryTheory.Limits.CoconeMorphism.ext :
    ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃}
      [inst_1 : CategoryTheory.Category.{v₃, u₃} C] {F : CategoryTheory.Functor J C}
      {c c' : CategoryTheory.Limits.Cocone F} (f g : c ⟶ c'), f.hom = g.hom → f = g :=
  by sorry

This theorem states that in the context of category theory, given two categories `J` and `C`, and a functor `F` from `J` to `C`, if we have two cocones `c` and `c'` over `F`, and two morphisms `f` and `g` from `c` to `c'`, then if the morphism `f.hom` is equal to `g.hom`, it implies that `f` is equal to `g`. In simpler terms, it states that two cocone morphisms between the same pair of cocones are equal if their underlying morphisms are equal.

In category theory, if two cocones over the same functor have equal morphisms between them, then the cocones are equal.


theorem Set.eq_singleton_iff_unique_mem : ∀ {α : Type u} {a : α} {s : Set α}, s = {a} ↔ a ∈ s ∧ ∀ x ∈ s, x = a := by
  sorry

This theorem, `Set.eq_singleton_iff_unique_mem`, states that for any given type `α`, any element `a` of type `α`, and any set `s` of type `α`, the set `s` is equal to a singleton set containing only the element `a` if and only if `a` is an element of `s` and for all elements `x` in `s`, `x` is equal to `a`. In other words, a set is a singleton set containing a certain element if and only if that element is in the set and all other elements in the set are equal to that element.

A set equals the singleton set consisting of an element if and only if that element is in the set and belongs to no other element.


theorem CategoryTheory.ShortComplex.LeftHomologyMapData.leftHomologyMap'_eq :
    ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
      {S₁ S₂ : CategoryTheory.ShortComplex C} {φ : S₁ ⟶ S₂} {h₁ : CategoryTheory.ShortComplex.LeftHomologyData S₁}
      {h₂ : CategoryTheory.ShortComplex.LeftHomologyData S₂}
      (γ : CategoryTheory.ShortComplex.LeftHomologyMapData φ h₁ h₂),
      CategoryTheory.ShortComplex.leftHomologyMap' φ h₁ h₂ = γ.φH :=
  by sorry

This theorem states that in the context of a category `C` with zero morphisms and given two short complexes `S₁` and `S₂` in `C`, and a morphism `φ` from `S₁` to `S₂`, along with left homology data `h₁` and `h₂` for `S₁` and `S₂` respectively, for any left homology map data `γ` generated by `φ`, `h₁`, and `h₂`, the left homology map generated by `φ`, `h₁`, and `h₂` is equal to the homology map component of `γ`. This equality creates a link between the concept of a left homology map and the homology map component of a left homology map data.

Given a category `C` with zero morphisms, two short complexes `S₁` and `S₂`, a morphism `φ` from `S₁` to `S₂`, and left homology data `h₁` and `h₂` for `S₁` and `S₂` respectively, the homology map generated by `φ`, `h₁`, and `h₂` equals the homology map component of the left homology map data `γ` generated by `φ`, `h₁`, and `h₂`.


theorem pi_congr :
    ∀ {α : Sort u_5} {β β' : α → Sort u_1}, (∀ (a : α), β a = β' a) → ((a : α) → β a) = ((a : α) → β' a) := by sorry

This theorem, "pi_congr", states that for any sort `α` and for any two sorts `β` and `β'` that depend on `α`, if for every element `a` of `α` the dependent sort `β a` is equal to `β' a`, then the type of functions from `α` to `β a` is equal to the type of functions from `α` to `β' a`. In other words, if two dependent types are equal for every value in their common domain, then the spaces of functions from the domain to each of the dependent types are also equal.

If for all elements `a` of sort `α`, the dependent types `β a` and `β' a` are equal, then the types of functions from `α` to `β a` and functions from `α` to `β' a` are equal.


IsCompact.prod

theorem IsCompact.prod :
    ∀ {X : Type u} {Y : Type v} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {s : Set X} {t : Set Y},
      IsCompact s → IsCompact t → IsCompact (s ×ˢ t) :=
  by sorry

The theorem `IsCompact.prod` states that for any two types `X` and `Y` each equipped with a topological space structure, and for any two sets `s` of type `X` and `t` of type `Y`, if `s` is compact and `t` is compact, then the cartesian product of `s` and `t`, denoted by `s ×ˢ t`, is also compact. In other words, the compactness property is preserved under the formation of cartesian products in topological spaces.

If `X` and `Y` are topological spaces with compact sets `s` and `t`, then the cartesian product `s ×ˢ t` is also compact.


theorem Subtype.coe_preimage_self : ∀ {α : Type u_1} (s : Set α), Subtype.val ⁻¹' s = Set.univ := by sorry

The theorem `Subtype.coe_preimage_self` states that for any set `s` of a type `α`, the preimage of `s` under the function `Subtype.val` (which maps each subtype to its underlying base type element) is the universal set. In other words, for all elements in the universal set, their corresponding `Subtype.val` exist in the original set `s`.

For any subtype `s : Set α`, the image of `s` under the function `Subtype.val` is equal to the universe `α`.


/-- The tail of a vector obtained by prepending is the vector prepended. to  -/
theorem Vector.tail_cons : ∀ {α : Type u} {n : ℕ} (a : α) (v : Vector α n), Vector.tail (a ::ᵥ v) = v := by sorry

This theorem, `Vector.tail_cons`, states that for any type `α` and a non-negative integer `n`, if an element `a` of type `α` is prepended to a vector `v` of length `n` and type `α`, then taking the tail of the new vector results in the original vector `v`. In other words, prepending a value to a vector and immediately removing it leaves the original vector unchanged.

For any type `α` and non-negative integer `n`, prepending an element `a` to a vector `v` of length `n` results in a vector `x` such that `x.tail = v`.


theorem Filter.map_principal :
    ∀ {α : Type u} {β : Type v} {s : Set α} {f : α → β},
      Filter.map f (Filter.principal s) = Filter.principal (f '' s) :=
  by sorry

The theorem `Filter.map_principal` states that for every type `α` and `β`, for every set `s` of type `α`, and for every function `f` that maps from `α` to `β`, mapping `f` over the principal filter of `s` results in the principal filter of the image of `s` under `f`. In other words, if we first form the collection of all supersets of `s` (principal filter of `s`), and then apply the function `f` to all elements in this collection, we get the same result as if we first applied `f` to each element in `s` and then formed the collection of all supersets of the resulting set. This emphasizes the preserving nature of the function `f` and the consistency of filter operations across different types.

For any type `α`, set `s` of type `α`, and function `f` from `α` to `β`, the image of the principal filter of `s` under `f` is equal to the principal filter of the image of `s` under `f`.


theorem Mathlib.Data.ENNReal.Basic._auxLemma.20 : ∀ {r q : NNReal}, (↑r < ↑q) = (r < q) := by sorry

The theorem `Mathlib.Data.ENNReal.Basic._auxLemma.20` states that for any two nonnegative real numbers `r` and `q`, the inequality of their real number counterparts (`↑r < ↑q`) is equivalent to the inequality of the original nonnegative real numbers (`r < q`). In other words, the process of converting nonnegative real numbers to real numbers preserves the order of inequality.

For any nonnegative real numbers r and q, the inequality r < q is equivalent to the inequality ↑r < ↑q, where ↑ is the function that lifts nonnegative real numbers to real numbers.


theorem Mathlib.Data.ENNReal.Basic._auxLemma.14 : (0 = ⊤) = False := by sorry

This theorem, `Mathlib.Data.ENNReal.Basic._auxLemma.14`, states that zero is not equal to infinity. In other words, it denies the equality between zero and infinity in the context of extended non-negative real numbers.

Zero is not equal to infinity in the context of extended non-negative real numbers.


theorem LinearMap.mem_range_self :
    ∀ {R : Type u_1} {R₂ : Type u_3} {M : Type u_9} {M₂ : Type u_12} [inst : Semiring R] [inst_1 : Semiring R₂]
      [inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid M₂] [inst_4 : Module R M] [inst_5 : Module R₂ M₂]
      {τ₁₂ : R →+* R₂} {F : Type u_20} [inst_6 : FunLike F M M₂] [inst_7 : SemilinearMapClass F τ₁₂ M M₂]
      [inst_8 : RingHomSurjective τ₁₂] (f : F) (x : M), f x ∈ LinearMap.range f :=
  by sorry

This theorem states that for any semiring `R`, another semiring `R₂`, an additive commutative monoid `M`, another additive commutative monoid `M₂`, a module structure over `R` on `M`, a module structure over `R₂` on `M₂`, a ring homomorphism `τ₁₂` from `R` to `R₂`, a type `F` such that terms of type `F` have an injective coercion to functions from `M` to `M₂`, and a semilinear map from `M` to `M₂` compatible with `τ₁₂`, where `τ₁₂` is surjective, for every `f` of type `F` and `x` of type `M`, the image of `x` under `f` is in the range of `f`. In other words, any value you get from applying a function `f` to an element `x` is indeed in the set of possible outputs of that function `f`.

Given semirings `R` and `R₂`, additive commutative monoids `M` and `M₂`, module structures over `R` and `R₂`, a surjective ring homomorphism `τ₁₂` from `R` to `R₂`, a semilinear map `f` from `M` to `M₂` compatible with `τ₁₂`, and an injective coercion from terms of type `F` to functions `M -> M₂`, for all `x in M` and `f of type F`, we have `f x in Im f`.


theorem Finset.card_mono : ∀ {α : Type u_1}, Monotone Finset.card := by sorry

The theorem `Finset.card_mono` states that for any type `α`, the function `Finset.card` is monotone. This means that if you have two finite sets `a` and `b` of the same type, and `a` is a subset of `b` (in other words `a ≤ b`), then the cardinality of `a` (how many elements `a` contains) is less than or equal to the cardinality of `b` (how many elements `b` contains). This is represented by `Finset.card a ≤ Finset.card b`.

For any type `α`, the function `Finset.card` on finite sets of type `α` is monotone, i.e., `Finset.card a ≤ Finset.card b` whenever `a ≤ b` are finite sets of type `α`.


theorem Finset.card_empty : ∀ {α : Type u_1}, ∅.card = 0 := by sorry

This theorem states that for all types `α`, the cardinality (or size) of an empty `Finset` (or finite set) is equal to 0. In other words, there are no elements in an empty set, no matter what the type of the elements is supposed to be.

The cardinality of an empty finite set is 0.


/-- Two linearly equivalent vector spaces have the same dimension.  -/
theorem LinearEquiv.rank_eq :
    ∀ {R : Type u} {M M₁ : Type v} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : AddCommGroup M₁]
      [inst_3 : Module R M] [inst_4 : Module R M₁], (M ≃ₗ[R] M₁) → Module.rank R M = Module.rank R M₁ :=
  by sorry

This theorem states that if two vector spaces, M and M₁, are linearly equivalent over a ring R, then they have the same dimension. It applies to any types M and M₁ that form additive commutative groups and are modules over the ring R. The operator ≃ₗ[R] denotes a linear equivalence between the vector spaces. The dimension of a vector space is represented by the function `Module.rank`.

If two additive commutative groups M and M₁ are linearly equivalent modules over a ring R, then they have equal dimensions.


theorem Finset.mem_image₂_of_mem :
    ∀ {α : Type u_1} {β : Type u_3} {γ : Type u_5} [inst : DecidableEq γ] {f : α → β → γ} {s : Finset α} {t : Finset β}
      {a : α} {b : β}, a ∈ s → b ∈ t → f a b ∈ Finset.image₂ f s t :=
  by sorry

The theorem `Finset.mem_image₂_of_mem` states that for any types `α`, `β`, and `γ` where `γ` has decidable equality, given a binary function `f : α → β → γ`, two finite sets `s : Finset α` and `t : Finset β`, and elements `a : α` and `b : β`, if `a` is an element of `s` and `b` is an element of `t`, then the application of the function `f` to `a` and `b` (i.e., `f a b`) is an element of the image of the function `f` applied to `s` and `t` (i.e., `f a b` is in the set `Finset.image₂ f s t`). In other words, this theorem asserts that the result of applying a function to elements of two sets belongs to the image of the function on these sets.

For functions between finite sets with decidable equality, if an element of the first set is in the first set and an element of the second set is in the second set, then the application of the function to those elements is in the image of the function applied to the two sets.


theorem Int.units_eq_one_or : ∀ (u : ℤˣ), u = 1 ∨ u = -1 := by sorry

This theorem states that for any unit `u` in the set of integers, `u` is either equal to 1 or -1. So, in the language of integers, the only unit (an element with a multiplicative inverse) elements are 1 and -1.

In the realm of integers, only 1 and -1 are units (have multiplicative inverses).


theorem Localization.smul_mk :
    ∀ {M : Type u_1} [inst : CommMonoid M] {S : Submonoid M} {R : Type u_4} [inst_1 : SMul R M]
      [inst_2 : IsScalarTower R M M] (c : R) (a : M) (b : ↥S), c • Localization.mk a b = Localization.mk (c • a) b :=
  by sorry

The theorem `Localization.smul_mk` states that for any commutative monoid `M`, a submonoid `S` of `M`, a scalar multiplication operation `SMul` on `M` by a scalar `R`, and a scalar tower structure `IsScalarTower` on `M` (which implies that the scalar multiplication on `M` is associative), for any scalar `c` from `R`, any element `a` from `M`, and any element `b` from `S`, the scalar multiplication of the localization of `a` and `b` by `c` is equivalent to the localization of the scalar multiplication of `a` by `c` and `b`. In mathematical terms, this theorem says if we have a localization $(a,b)$, and we scalar multiply the entire localization by a scalar `c`, we get the same result as if we had just multiplied `a` by `c`.

For any commutative monoid `M` with a submonoid `S`, scalar multiplication `SMul` by a scalar `R`, and an associative scalar tower structure `IsScalarTower` on `M`, the localization of `a * c` and `b` is equal to the localization of `a` multiplied by `c` for all `a` in `M` and `b` in `S`.


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

This theorem, `lt_div_iff`, states that for any type `α` that forms a `LinearOrderedSemifield`, given any three elements `a`, `b`, and `c` of this type where `c` is greater than zero, `a` is less than `b` divided by `c` if and only if `a` multiplied by `c` is less than `b`.

For any `LinearOrderedSemifield` type `α` and elements `a`, `b`, and `c` (with `c > 0`), `a` is less than `b / c` if and only if `a * c` is less than `b`.


theorem CategoryTheory.Limits.limit.conePointUniqueUpToIso_hom_comp :
    ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] {C : Type u} [inst_1 : CategoryTheory.Category.{v, u} C]
      {F : CategoryTheory.Functor J C} [inst_2 : CategoryTheory.Limits.HasLimit F] {c : CategoryTheory.Limits.Cone F}
      (hc : CategoryTheory.Limits.IsLimit c) (j : J),
      CategoryTheory.CategoryStruct.comp
          (CategoryTheory.Limits.IsLimit.conePointUniqueUpToIso hc (CategoryTheory.Limits.limit.isLimit F)).hom
          (CategoryTheory.Limits.limit.π F j) =
        c.π.app j :=
  by sorry

The theorem `CategoryTheory.Limits.limit.conePointUniqueUpToIso_hom_comp` asserts that in the context of a category with limits, for any functor `F` and any limit cone `c` of `F`, the composition of the morphism from the cone point of `c` to the limit of `F` and the projection from the limit of `F` to a value of the functor `F` is equal to the morphism from the cone point of `c` to a value of the functor. In particular, this expresses the universal property of the category-theoretic limit, which states that every cone to `F` factors uniquely through the limit cone.

In a category with limits, for any functor and limit cone, the composition of the morphism from the cone point to the limit and the projection from the limit to a value of the functor is equal to the morphism from the cone point to that value of the functor.


theorem Finset.eq_of_subset_of_card_le : ∀ {α : Type u_1} {s t : Finset α}, s ⊆ t → t.card ≤ s.card → s = t := by sorry

This theorem states that for any two finite sets `s` and `t` of any type `α`, if `s` is a subset of `t` and the cardinality of `t` is less than or equal to the cardinality of `s`, then `s` must be equal to `t`. In other words, if a set `s` is completely contained within another set `t`, and `t` has equal or fewer elements than `s`, then the two sets are identical.

If `s` is a subset of `t` and the cardinality of `s` is greater than or equal to that of `t`, then `s` equals `t`.


theorem Nat.factors_zero : Nat.factors 0 = [] := by sorry

The theorem `Nat.factors_zero` states that the prime factorization of zero is an empty list. This is because zero is not considered to have any prime factors in the context of this prime factorization function.

The prime factorization of zero is the empty list.


theorem exists_nat_gt :
    ∀ {α : Type u_1} [inst : StrictOrderedSemiring α] [inst_1 : Archimedean α] (x : α), ∃ n, x < ↑n := by sorry

This theorem states that for any value `x` of a type `α`, there exists a natural number `n` such that `x` is less than `n`. Here, `α` is a type that forms a strictly ordered semiring and also satisfies the Archimedean property. The Archimedean property is a property of ordered or normed fields and rings, which roughly states that there are no infinitesimally small or infinitely large elements. In a more concrete sense, given an arbitrary element `x`, you can always find a natural number `n` that is greater than `x`, which is the essence of this theorem.

For any element `x` in a type `α` that forms a strictly ordered semiring and satisfies the Archimedean property, there exists a natural number `n` such that `x` is less than `n`.


theorem Mathlib.Data.Polynomial.Basic._auxLemma.18 :
    ∀ {R : Type u} [inst : Semiring R] {p q : Polynomial R}, (Polynomial.coeff p = Polynomial.coeff q) = (p = q) := by
  sorry

This theorem, named `Mathlib.Data.Polynomial.Basic._auxLemma.18`, states that for any type `R` that forms a semiring, and for any two polynomials `p` and `q` over `R`, the equality of the coefficient functions of `p` and `q` (i.e., `Polynomial.coeff p` and `Polynomial.coeff q`) implies the equality of the polynomials `p` and `q` themselves. Here, the coefficient function of a polynomial `p` is a function that takes a natural number `n` and returns the coefficient of `X^n` in `p`.

If two polynomials over a semiring have equal coefficient functions, then they are equal.


theorem Polynomial.aeval_C :
    ∀ {R : Type u} {A : Type z} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A] (x : A) (r : R),
      (Polynomial.aeval x) (Polynomial.C r) = (algebraMap R A) r :=
  by sorry

The `Polynomial.aeval_C` theorem states that for all types `R` and `A`, where `R` is a commutative semiring, `A` is a semiring, and `A` is an `R`-algebra, for any `x` in `A` and `r` in `R`, applying the `aeval` function (which is an `R`-algebra homomorphism) to `x` on the constant polynomial `C` of `r` equals the result of applying the algebra map from `R` to `A` on `r`. In other words, if you evaluate the constant polynomial `C` at `x` using `aeval`, you get the same result as if you simply mapped `r` from `R` to `A` using the algebra structure of `A`. This is equivalent to the mathematical statement that for any algebra $A$ over a commutative ring $R$, the evaluation homomorphism at any element $x \in A$ applied to a constant polynomial $C(r)$ is equal to the image of $r$ under the given ring homomorphism from $R$ to $A$.

For any commutative semiring R, semiring A as an R-algebra, and x in A, the evaluation of the constant polynomial C(r) at x using aeval is equal to the application of the algebra map from R to A on r.


theorem Set.iUnion_iUnion_eq_left :
    ∀ {α : Type u_1} {β : Type u_2} {b : β} {s : (x : β) → x = b → Set α}, ⋃ x, ⋃ (h : x = b), s x h = s b ⋯ := by sorry

The theorem `Set.iUnion_iUnion_eq_left` states that for any types `α` and `β`, a given value `b` of type `β`, and a function `s` which maps each value `x` of type `β` and a proof `h` that `x` equals `b` to a set of `α`, the union over all `x` of the union over all proofs `h` that `x` equals `b` of `s x h` is equal to the set `s b` determined by any proof. In simpler terms, this theorem is about simplifying the union of unions when the inner union is over proofs of a specific equality. The resulting set is just the one associated with the specific value and any proof of its identity.

For any types `α` and `β`, given a value `b` of type `β` and a function `s : β → Set α`, the set `s b` is equal to the union over all proofs `h : b = x` of the union of `s x h`.


/-- The fundamental property of the operator norm of a continuous multilinear map:
`‖f m‖` is bounded by `‖f‖` times the product of the `‖m i‖`.  -/
theorem ContinuousMultilinearMap.le_opNorm :
    ∀ {𝕜 : Type u} {ι : Type v} {E : ι → Type wE} {G : Type wG} [inst : Fintype ι] [inst_1 : NontriviallyNormedField 𝕜]
      [inst_2 : (i : ι) → SeminormedAddCommGroup (E i)] [inst_3 : (i : ι) → NormedSpace 𝕜 (E i)]
      [inst_4 : SeminormedAddCommGroup G] [inst_5 : NormedSpace 𝕜 G] (f : ContinuousMultilinearMap 𝕜 E G)
      (m : (i : ι) → E i), ‖f m‖ ≤ ‖f‖ * Finset.prod Finset.univ fun i => ‖m i‖ :=
  by sorry

This theorem states the fundamental property of the operator norm of a continuous multilinear map. Specifically, for any continuous multilinear map `f` from a normed field `𝕜` to a space `E` indexed by a finite type `ι`, and for a given mapping `m` from `ι` to `E`, the norm of `f(m)` is bounded by the product of the norm of `f` and the product of the norms of `m i` for every `i` in the universal set of `ι`. In mathematical notation, this is expressed as `‖f m‖ ≤ ‖f‖ * ∏ i ∈ ι, ‖m i‖`.

The norm of a continuous multilinear map applied to a vector valued function is bounded by the product of the map's norm and the product of the norms of the function values.


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

The theorem `isCompact_singleton` states that for any type `X` equipped with a topological space structure, every singleton set `{x}` is compact. In other words, for any given filter `f` that is not trivial and contains `{x}`, there exists a point in `{x}` (which is `x` itself) such that every set of `f` meets every neighborhood of `x`.

For any topological space `(X, τ)` and point `x ∈ X`, the singleton set `{x} ⊆ X` is compact.


theorem Finset.prod_union :
    ∀ {α : Type u_3} {β : Type u_4} {s₁ s₂ : Finset α} {f : α → β} [inst : CommMonoid β] [inst_1 : DecidableEq α],
      Disjoint s₁ s₂ →
        (Finset.prod (s₁ ∪ s₂) fun x => f x) = (Finset.prod s₁ fun x => f x) * Finset.prod s₂ fun x => f x :=
  by sorry

The theorem `Finset.prod_union` states that for any types `α` and `β`, two finite sets of type `α` namely `s₁` and `s₂`, and a function `f` from `α` to `β`, given a commutative monoid structure on `β` and a way to decide equality in `α`, if `s₁` and `s₂` are disjoint (meaning that their intersection is the bottom element), then the product of `f` over the union of `s₁` and `s₂` is equal to the product of `f` over `s₁` multiplied by the product of `f` over `s₂`. In mathematical notation, this is saying $\prod_{x \in s_1 \cup s_2} f(x) = \prod_{x \in s_1} f(x) \times \prod_{x \in s_2} f(x)$, provided $s_1$ and $s_2$ are disjoint.

Given finite sets `s₁` and `s₂` of type `α` that are disjoint and have a commutative monoid structure on type `β` with equality decidable in `α`, the product of a function `f` from `α` to `β` over the union of `s₁` and `s₂` equals the product of `f` over `s₁` multiplied by the product of `f` over `s₂`. That is, $\prod\_{x \in s\_1 \cup s\_2} f(x) = \prod\_{x \in s\_1} f(x) \times \prod\_{x \in s\_2} f(x)$.


theorem Quotient.exists_rep : ∀ {α : Sort u} {s : Setoid α} (q : Quotient s), ∃ a, ⟦a⟧ = q := by sorry

This theorem, `Quotient.exists_rep`, states that for any Sort `α` and any Setoid `s` on `α`, and for any Quotient `q` of `s`, there exists some element `a` from `α` such that the equivalence class of `a` under the Setoid `s` is equal to `q`. In other words, every quotient has a representative from the original set `α`.

For any Setoid `s` on Sort `α` and its Quotient `q`, there exists an element `a` in `α` such that `q = [a]_s` (the equivalence class of `a` under `s`).


theorem StrictMonoOn.le_iff_le :
    ∀ {α : Type u} {β : Type v} [inst : LinearOrder α] [inst_1 : Preorder β] {f : α → β} {s : Set α},
      StrictMonoOn f s → ∀ {a b : α}, a ∈ s → b ∈ s → (f a ≤ f b ↔ a ≤ b) :=
  by sorry

The theorem `StrictMonoOn.le_iff_le` states that for any set `s` of elements of a certain type `α`, and for any function `f` from `α` to another type `β`, given that the types `α` and `β` have a linear and a preorder relationship respectively, if the function `f` is strictly monotone on the set `s`, then for any two elements `a` and `b` in the set `s`, `f(a)` is less than or equal to `f(b)` if and only if `a` is less than or equal to `b`. In other words, the ordering of `a` and `b` in `α` is preserved under `f` in `β`.

If `f` is a strictly monotone function from a set `s` of type `α` to a preordered type `β`, then for all `a, b ∈ s`, `a ≤ b` implies `f(a) ≤ f(b)`.


theorem Subsemigroup.gc_map_comap :
    ∀ {M : Type u_1} {N : Type u_2} [inst : Mul M] [inst_1 : Mul N] (f : M →ₙ* N),
      GaloisConnection (Subsemigroup.map f) (Subsemigroup.comap f) :=
  by sorry

The theorem `Subsemigroup.gc_map_comap` states that for all semigroups `M` and `N` (with respective multiplication operations), and for any semigroup homomorphism `f` from `M` to `N`, there exists a Galois connection between the function that maps subsemigroups of `M` to subsemigroups of `N` via `f`, and the function that returns the preimage of a subsemigroup in `N` along `f` as a subsemigroup of `M`. In other words, a subsemigroup in `M` is mapped to a subsemigroup in `N` under `f` if and only if the preimage of a subsemigroup in `N` under `f` is a subsemigroup in `M`.

For every semigroup homomorphism f between semigroups M and N, the functions mapping subsemigroups of M to subsemigroups of N via f and mapping subsemigroups of N back to their preimages in M form a Galois connection.


theorem Set.mem_inter : ∀ {α : Type u} {x : α} {a b : Set α}, x ∈ a → x ∈ b → x ∈ a ∩ b := by sorry

The theorem `Set.mem_inter` states that for any type `α`, any element `x` of type `α`, and any two sets `a` and `b` of type `Set α`, if `x` is a member of both `a` and `b`, then `x` is also a member of the intersection of `a` and `b`. This theorem essentially formalizes one of the fundamental properties of set theory: the definition of set intersection.

If `x` is an element of both sets `a` and `b`, then `x` is an element of their intersection `a INTER b`.


theorem Set.Ici_inter_Iio : ∀ {α : Type u_1} [inst : Preorder α] {a b : α}, Set.Ici a ∩ Set.Iio b = Set.Ico a b := by
  sorry

This theorem states that for any type `α` with a preorder structure, and any two elements `a` and `b` of `α`, the intersection of the left-closed right-infinite interval starting at `a` (`Set.Ici a`) and the left-infinite right-open interval ending at `b` (`Set.Iio b`) is equal to the left-closed right-open interval from `a` to `b` (`Set.Ico a b`). In other words, the set of all elements `x` such that `x` is greater than or equal to `a` and less than `b` can be obtained by taking the intersection of the set of all elements greater than or equal to `a` and the set of all elements less than `b`.

For any preordered type `α` and elements `a` and `b` in `α`, the interval from `a` to `b` (left-closed and right-open) is equal to the intersection of the left-closed right-infinite interval starting at `a` and the left-infinite right-open interval ending at `b`.


theorem Filter.EventuallyEq.eq_of_nhds :
    ∀ {X : Type u} {α : Type u_1} {x : X} [inst : TopologicalSpace X] {f g : X → α}, f =ᶠ[nhds x] g → f x = g x := by
  sorry

This theorem states that for any type `X` with a topological space structure, any type `α`, and any two functions `f` and `g` from `X` to `α`, if `f` is eventually equal to `g` at the neighborhood filter of a point `x` in `X` (i.e., `f` and `g` are equal at all points sufficiently close to `x`), then the values of `f` and `g` are also equal at `x`. In other words, if two functions coincide in a neighborhood of a point, they must also coincide at that point.

If two functions from a topological space to a type have equal values in a neighborhood of a point, then they are equal at that point.


theorem Int.modEq_iff_dvd : ∀ {n a b : ℤ}, a ≡ b [ZMOD n] ↔ n ∣ b - a := by sorry

This theorem states that for any three integers `n`, `a`, and `b`, `a` is congruent to `b` modulo `n` if and only if `n` divides the difference of `b` and `a`. The left-hand side represents a congruence relationship in modulo arithmetic, where `a` and `b` leave the same remainder when divided by `n`. The right-hand side signifies a divisibility relationship, where `n` divides evenly into the difference between `b` and `a`. Thus, the theorem connects these two mathematical concepts, showing that they are equivalent under these conditions.

For integers `n`, `a`, and `b`, `a` is congruent to `b` modulo `n` if and only if `n` divides `b - a`.


theorem MeasureTheory.withDensity_absolutelyContinuous :
    ∀ {α : Type u_1} {m : MeasurableSpace α} (μ : MeasureTheory.Measure α) (f : α → ENNReal),
      MeasureTheory.Measure.AbsolutelyContinuous (μ.withDensity f) μ :=
  by sorry

The theorem `MeasureTheory.withDensity_absolutelyContinuous` states that for any measure μ and any function f from a type α to the extended nonnegative real numbers (ENNReal), the measure with density f with respect to the measure μ is absolutely continuous with respect to μ. In mathematical terms, this means that if for any set A, if the measure μ assigns it a measure of 0, then the measure with density f also assigns it a measure of 0. This property is important in measure theory and probability theory because it relates the behavior of the original measure μ and the derived measure with density f.

If `μ` is a measure and `f : α → ↑ℝ` is a function, then the measure with density `f` with respect to `μ` is absolutely continuous with respect to `μ`.


Set.mapsTo'

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

The theorem `Set.mapsTo'` asserts that for any types `α` and `β`, any sets `s` of `α` and `t` of `β`, and any function `f` from `α` to `β`, the statement that `f` maps `s` into `t` is equivalent to the statement that the image of `s` under `f` is a subset of `t`. In other words, it says that every element of `s` gets mapped by `f` into an element in `t` if and only if all elements in the image of `s` under `f` are also elements of `t`.

For any types α and β, sets s of α and t of β, and function f : α → β, the sets {x ∈ s | f x ∈ t} and f["s"] are equal.


theorem RelIso.map_rel_iff :
    ∀ {α : Type u_1} {β : Type u_2} {r : α → α → Prop} {s : β → β → Prop} (f : r ≃r s) {a b : α},
      s (f a) (f b) ↔ r a b :=
  by sorry

This theorem states that for all types `α` and `β`, and for all relations `r` on `α` and `s` on `β`, if there is a relative isomorphism `f` from `r` to `s`, then for any two elements `a` and `b` of `α`, `s` holds between `f(a)` and `f(b)` if and only if `r` holds between `a` and `b`. In other words, the relative isomorphism `f` preserves the relational structure between `α` and `β`.

Given types `α` and `β`, relations `r` on `α` and `s` on `β`, and a relative isomorphism `f` from `r` to `s`, for all `a, b ∈ α`, `r(a, b)` if and only if `s(f(a), f(b))`.


theorem CategoryTheory.Projective.factorThru_comp :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {P X E : C} [inst_1 : CategoryTheory.Projective P]
      (f : P ⟶ X) (e : E ⟶ X) [inst_2 : CategoryTheory.Epi e],
      CategoryTheory.CategoryStruct.comp (CategoryTheory.Projective.factorThru f e) e = f :=
  by sorry

The theorem `CategoryTheory.Projective.factorThru_comp` states that for every category `C` with a projective object `P` and objects `X` and `E`, given a morphism `f` from `P` to `X` and an epimorphism `e` from `E` to `X`, the composition of the morphism `f` factored through `e` (using the `CategoryTheory.Projective.factorThru` function) and `e` itself is equal to `f`. This shows that the factoring of `f` through `e` preserves the original transformation `f` when followed by `e`.

Given a category with a projective object, for any morphism from the projective object to an object and an epimorphism to that object, the factorization of the morphism through the epimorphism equals the original morphism.


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

The theorem `Finset.card_image_of_injOn` states that for any types `α` and `β`, any finite set `s` of type `α`, and any function `f` from `α` to `β` (where `β` has decidable equality), if the function `f` is injective on the set `s` (i.e., no two different elements of `s` map to the same element of `β`), then the cardinality (or size) of the image of `s` under `f` is equal to the cardinality of the set `s`. In other words, when mapping a finite set using an injective function, the number of elements in the output set is the same as the number of elements in the input set.

If `f: α → β` is a function from a finite set `s ⊆ α` to `β` with decidable equality such that `f` is injective on `s`, then `#s = #(image s f)`.


theorem Multiset.map_const' :
    ∀ {α : Type u_1} {β : Type v} (s : Multiset α) (b : β),
      Multiset.map (fun x => b) s = Multiset.replicate (Multiset.card s) b :=
  by sorry

This theorem states that for any multiset `s` of type `α` and any value `b` of type `β`, the result of mapping the function `(fun x => b)` over `s` is equivalent to a multiset that only contains the value `b` with the multiplicity equal to the cardinality (number of elements) of `s`. In mathematical terms, the theorem states that applying a constant function to each element of a multiset yields a new multiset where all elements are that constant and the number of times the constant appears is equal to the size of the initial multiset.

For any multiset `s` of type `α` and any value `b` of type `β`, the function `(map s fun x => b)` is a multiset of size equal to the cardinality of `s` consisting only of the value `b`.


theorem Decidable.of_not_not : ∀ {p : Prop} [inst : Decidable p], ¬¬p → p := by sorry

This theorem is stating that for any proposition `p`, if `p` is decidable (meaning it is either true or false), then if it's not the case that `p` is not true (expressed as ¬¬p), it follows that `p` is true. In other words, if we can't deny that `p` is false, then `p` is true. This is a formulation of the law of double negation in classical logic.

In classical logic, if a proposition `p` is decidable, then `p` and ¬¬`p` are logically equivalent.


theorem normalize_associated :
    ∀ {α : Type u_1} [inst : CancelCommMonoidWithZero α] [inst_1 : NormalizationMonoid α] (x : α),
      Associated (normalize x) x :=
  by sorry

The theorem `normalize_associated` states that for any type `α` that has both a `CancelCommMonoidWithZero` and a `NormalizationMonoid` structure, and for any element `x` of type `α`, the `normalize` of `x` is associated with `x`. In the context of monoids, two elements are associated if one can be obtained by multiplying the other by a unit on the right. Here, 'normalize' chooses an element of each associate class by multiplying by `normUnit`. Therefore, this theorem is saying that the normalization of an element is in the same associate class as the original element.

For any type `α` with both a `CancelCommMonoidWithZero` and a `NormalizationMonoid` structure, the normalization of an element `x` is in the same associate class.


theorem ENNReal.coe_ne_zero : ∀ {r : NNReal}, ↑r ≠ 0 ↔ r ≠ 0 := by sorry

This theorem is stating that for any nonnegative real number `r`, the coercion of `r` to an extended nonnegative real number (indicated by `↑r`) is not equal to zero if and only if `r` is not equal to zero. This means that zero in the context of nonnegative real numbers and extended nonnegative real numbers is consistent; a nonnegative real number is zero if and only if its corresponding extended nonnegative real number is zero.

For any nonnegative real number `r`, `↑r = 0` if and only if `r = 0`.


theorem BilinForm.smul_right :
    ∀ {R : Type u_1} {M : Type u_2} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
      {B : BilinForm R M} (a : R) (x y : M), B.bilin x (a • y) = a * B.bilin x y :=
  by sorry

This theorem states for any commutative semiring `R`, an add-commutative monoid `M`, and a module `M` over `R`, for any bilinear form `B` on `R` and `M`, and for any elements `a` of `R`, `x, y` of `M`, the bilinear form evaluated at `x` and `a` scaled by `y`, is equal to `a` times the bilinear form evaluated at `x` and `y`. This essentially expresses the property that a bilinear form is linear in each argument.

For any commutative semiring `R`, add-commutative monoid `M`, module `M` over `R`, bilinear form `B` on `R` and `M`, and elements `a` in `R` and `x`, `y` in `M`, we have `B(x, a) = a * B(x, y)`.


theorem le_add_tsub :
    ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : AddCommSemigroup α] [inst_2 : Sub α] [inst_3 : OrderedSub α]
      {a b : α}, a ≤ b + (a - b) :=
  by sorry

This theorem, `le_add_tsub`, states that for any type `α` that satisfies the conditions of being a preorder, an additive commutative semigroup, and an ordered subtraction operation, for any two elements `a` and `b` of `α`, `a` is less than or equal to the result of adding `b` to the difference of `a` and `b`. In mathematical terms, for all `a` and `b` in `α`, we have `a ≤ b + (a - b)`.

For all `α` with preorder, additive commutative semigroup structure, and ordered subtraction, and all `a` and `b` in `α`, we have `a ≤ b + (a - b)`.


theorem inner_zero_right :
    ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
      (x : E), ⟪x, 0⟫_𝕜 = 0 :=
  by sorry

This theorem, `inner_zero_right`, states that for any type `𝕜` behaving like a ring (indicated by `RCLike 𝕜`) and any normed additive commutative group `E` which also constitutes an inner product space over `𝕜` (denoted as `InnerProductSpace 𝕜 E`), the inner product of any element `x` of `E` with the zero element is always zero. This is a fundamental property that holds in any inner product space.

For any ring-like type `𝕜` and inner product space `E` over `𝕜`, the inner product of any element in `E` with the zero element is zero.


/-- By definition, if `x` is invertible then `inverse x = x⁻¹`.  -/
theorem Ring.inverse_unit : ∀ {M₀ : Type u_2} [inst : MonoidWithZero M₀] (u : M₀ˣ), Ring.inverse ↑u = ↑u⁻¹ := by sorry

This theorem states that within the context of a monoid with zero `M₀`, for any unit `u` in `M₀` (i.e., any invertible element), the `inverse` function gives the same result as the direct inversion of `u`. In other words, if `x` is an invertible element in `M₀`, then `inverse x` equals to the inverse of `x`, denoted as `x⁻¹`.

For any unit `u` in a monoid `M₀` with zero, the function `inverse` and the direct inversion `u⁻¹` are equal: `inverse u = u⁻¹`.


theorem PartialEquiv.trans_refl :
    ∀ {α : Type u_1} {β : Type u_2} (e : PartialEquiv α β), PartialEquiv.trans e (PartialEquiv.refl β) = e := by sorry

The theorem `PartialEquiv.trans_refl` asserts that for all types `α` and `β`, and for any partial equivalence `e` from `α` to `β`, the composition of `e` with the identity partial equivalence on `β` (denoted as `PartialEquiv.refl β`) is equal to `e` itself. In other words, this theorem states that the identity partial equivalence acts as a right identity with respect to the composition of partial equivalences.

For any partial equivalences `e: α ≃_* β` and `r: β ≃_* β` in Lean 4, `e �circ r = e`, where `�circ` denotes composition.


theorem CategoryTheory.Limits.IsColimit.comp_coconePointUniqueUpToIso_hom :
    ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃}
      [inst_1 : CategoryTheory.Category.{v₃, u₃} C] {F : CategoryTheory.Functor J C}
      {s t : CategoryTheory.Limits.Cocone F} (P : CategoryTheory.Limits.IsColimit s)
      (Q : CategoryTheory.Limits.IsColimit t) (j : J),
      CategoryTheory.CategoryStruct.comp (s.ι.app j)
          (CategoryTheory.Limits.IsColimit.coconePointUniqueUpToIso P Q).hom =
        t.ι.app j :=
  by sorry

The theorem `CategoryTheory.Limits.IsColimit.comp_coconePointUniqueUpToIso_hom` states that for any category `J` and any category `C`, given a functor `F` from `J` to `C`, two cocones `s` and `t` over `F`, and assuming `P` is a colimit of `s` and `Q` is a colimit of `t`, then for any object `j` in `J`, the composition of the morphism from `j` to the vertex of `s` with the unique isomorphism from the vertex of `s` to the vertex of `t` is equal to the morphism from `j` to the vertex of `t`. In other words, it asserts the uniqueness of the morphism up to a specific isomorphism in the context of category theory, specifically dealing with colimits and cocones.

Given any functor F from category J to C, if two cocones over F have equal colimits, then the unique isomorphism between their vertices maps each morphism from an object in J to the first vertex to the corresponding morphism to the second vertex.


theorem Filter.tendsto_principal_principal :
    ∀ {α : Type u} {β : Type v} {f : α → β} {s : Set α} {t : Set β},
      Filter.Tendsto f (Filter.principal s) (Filter.principal t) ↔ ∀ a ∈ s, f a ∈ t :=
  by sorry

This theorem, `Filter.tendsto_principal_principal`, asserts that for any types `α` and `β`, any function `f` from `α` to `β`, and any sets `s` of `α` and `t` of `β`, the function `f` tends to the principal filter of `t` from the principal filter of `s` if and only if for all elements `a` in `s`, the image of `a` under `f` is in `t`. In other words, the theorem states that a function `f` tends towards the filter generated by `t` when it is restricted to the filter generated by `s`, if and only if every element of `s` gets mapped to an element in `t` by the function `f`. Here, a filter generated by a set is the collection of all supersets of the set, and a function tends towards a filter if the preimage of every neighborhood in the target filter is a neighborhood in the source filter.

A function from one set to another tends to the principal filter of its image set if and only if every element in the domain set is mapped to an element in the image set.


ProbabilityTheory.IdentDistrib.comp

theorem ProbabilityTheory.IdentDistrib.comp :
    ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {δ : Type u_4} [inst : MeasurableSpace α]
      [inst_1 : MeasurableSpace β] [inst_2 : MeasurableSpace γ] [inst_3 : MeasurableSpace δ]
      {μ : MeasureTheory.Measure α} {ν : MeasureTheory.Measure β} {f : α → γ} {g : β → γ} {u : γ → δ},
      ProbabilityTheory.IdentDistrib f g μ ν → Measurable u → ProbabilityTheory.IdentDistrib (u ∘ f) (u ∘ g) μ ν :=
  by sorry

The theorem `ProbabilityTheory.IdentDistrib.comp` states that for all types `α`, `β`, `γ`, `δ`, given measurable spaces over these types, measures `μ` and `ν` over `α` and `β` respectively, and functions `f : α → γ`, `g : β → γ` and `u : γ → δ`, if `f` and `g` are distributions that are identically distributed under measures `μ` and `ν` respectively, and `u` is a measurable function, then the composed functions `u ∘ f` and `u ∘ g` are also identically distributed under measures `μ` and `ν`. This theorem essentially expresses the property that the identical distribution of two random variables is preserved under the action of a measurable function.

If measurable functions $f : \alpha \rightarrow \gamma$ and $g : \beta \rightarrow \gamma$ are identically distributed under measures $\mu$ and $\nu$ over types $\alpha$ and $\beta$ respectively, and $u : \gamma \rightarrow \delta$ is a measurable function, then $u \circ f$ and $u \circ g$ are identically distributed under measures $\mu$ and $\nu$.


theorem CategoryTheory.MonoidalCategory.tensor_whiskerLeft :
    ∀ {C : Type u} [𝒞 : CategoryTheory.Category.{v, u} C] [inst : CategoryTheory.MonoidalCategory C] (X Y : C)
      {Z Z' : C} (f : Z ⟶ Z'),
      CategoryTheory.MonoidalCategory.whiskerLeft (CategoryTheory.MonoidalCategory.tensorObj X Y) f =
        CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategory.associator X Y Z).hom
          (CategoryTheory.CategoryStruct.comp
            (CategoryTheory.MonoidalCategory.whiskerLeft X (CategoryTheory.MonoidalCategory.whiskerLeft Y f))
            (CategoryTheory.MonoidalCategory.associator X Y Z').inv) :=
  by sorry

This theorem, `CategoryTheory.MonoidalCategory.tensor_whiskerLeft`, in the field of category theory, states the following: for any category `C` that is also a monoidal category, and for any objects `X`, `Y`, `Z`, and `Z'` of `C`, and a morphism `f` from `Z` to `Z'`, the operation of whiskering on the left by the tensor product of `X` and `Y` and then applying the morphism `f` is equivalent to first applying the associator to `X`, `Y`, and `Z`, then whiskering on the left by `X` and then `Y` and applying `f`, and finally applying the inverse of the associator to `X`, `Y`, and `Z'`. This theorem essentially shows the coherence of the whiskering operation with the tensor product and the associator in a monoidal category.

For any monoidal category C and objects X, Y, Z, Z' along with a morphism f from Z to Z', the left whiskering of f with the tensor product X ⊗ Y is equivalent to applying the associator (left identity natural transformation) with X, Y, and Z, whiskering on the left with X and then Y, and finally the inverse associator with X, Y, and Z'.


theorem Basis.repr_self :
    ∀ {ι : Type u_1} {R : Type u_3} {M : Type u_6} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
      (b : Basis ι R M) (i : ι), b.repr (b i) = fun₀ | i => 1 :=
  by sorry

The theorem `Basis.repr_self` states that for any index set `ι`, ring `R`, module `M` over `R`, and basis `b` of the module `M` indexed by `ι`, the representation of the basis element `b i` with respect to the basis `b` is the function that maps `i` to `1` and all other indices to `0`. In other words, each basis element is represented as having a coefficient of `1` at its own index and `0` at every other index. This is a formal encoding of one of the fundamental properties of a basis in linear algebra.

Given a module `M` over a ring `R` with basis `b` indexed by `ι`, the representation function of `b i` with respect to `b` is the function that maps `i` to `1` and all other indices to `0`.


theorem ENNReal.one_lt_top : 1 < ⊤ := by sorry

This theorem, `ENNReal.one_lt_top`, states that one is less than infinity in the context of extended non-negative real numbers. In mathematical notation, this theorem is asserting that 1 < ∞. This is commonly accepted in mathematics as infinity is considered greater than any real number.

One is strictly less than infinity in the extended non-negative real numbers.


theorem Order.pred_le : ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : PredOrder α] (a : α), Order.pred a ≤ a := by
  sorry

The theorem `Order.pred_le` states that for any type `α`, given that `α` is equipped with a Preorder and a PredOrder structure, the predecessor of any element `a` from `α` is less than or equal to `a` itself. In other words, for any element `a` in a preordered set, the element `Order.pred a`, which is defined as the greatest element less than `a` if `a` is not minimal and as `a` itself if `a` is minimal, is always less than or equal to `a`.

For any preordered type `α` and element `a` in `α`, the predecessor `Order.pred a` satisfies `Order.pred a ≤ a`.


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

The theorem `Equiv.Perm.inv_apply_self` states that for all types `α` and for all bijections `f` from `α` to itself (`f` is an element of `Equiv.Perm α`), applying `f⁻¹` (the inverse of `f`) to `f(x)` (the image of `x` under `f`) gives back `x`. In mathematical terms, this theorem is stating that for every bijection `f : α → α` and for all `x` in `α`, we have `f⁻¹(f(x)) = x`. This essentially captures the property that a bijection has an inverse such that applying the bijection followed by its inverse returns to the original element.

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


theorem zero_le' : ∀ {α : Type u_1} [inst : LinearOrderedCommMonoidWithZero α] {a : α}, 0 ≤ a := by sorry

This theorem states that for all types `α` that are instances of the `LinearOrderedCommMonoidWithZero` class, zero is less than or equal to any element `a` of type `α`. In other words, in any ordered commutative monoid with zero, zero is the smallest or equal to every element.

For all types `α` instancing `LinearOrderedCommMonoidWithZero`, `0 ≤ a` holds for all `a` in `α`.


theorem Multiset.map_add :
    ∀ {α : Type u_1} {β : Type v} (f : α → β) (s t : Multiset α),
      Multiset.map f (s + t) = Multiset.map f s + Multiset.map f t :=
  by sorry

The theorem `Multiset.map_add` states that for any type `α` and `β`, any function `f` from `α` to `β`, and any multiset `s` and `t` of `α`, the map of the function `f` onto the union of the multisets `s` and `t` is equal to the union of the map of `f` onto `s` and the map of `f` onto `t`. In other words, mapping a function over the addition (union) of two multisets is the same as adding (union) the maps of the function over the individual multisets. This property reflects the distributive nature of the map operation over multiset addition.

For any type α, function f from α to β, and multisets s and t of α, the map of f onto the union of s and t equals the union of the maps of f onto s and t. (Multiset.map\_add)


theorem CategoryTheory.Limits.op_zero :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
      (X Y : C), 0.op = 0 :=
  by sorry

This theorem, `CategoryTheory.Limits.op_zero`, states that in any category `C` that possesses zero morphisms, the opposite of a zero morphism is still a zero morphism. More specifically, for any two objects `X` and `Y` in the category, the opposite of the zero morphism from `X` to `Y` is equal to the zero morphism.

In a category with zero morphisms, the opposite of a zero morphism is equal to the zero morphism.


theorem Fintype.card_eq :
    ∀ {α : Type u_4} {β : Type u_5} [_F : Fintype α] [_G : Fintype β],
      Fintype.card α = Fintype.card β ↔ Nonempty (α ≃ β) :=
  by sorry

The theorem `Fintype.card_eq` states that for any two types `α` and `β`, assuming both are finite (`Fintype α` and `Fintype β` respectively), the cardinality of `α` (number of elements in `α`) is equal to the cardinality of `β` if and only if there exists a bijection between `α` and `β` (represented as `α ≃ β` in Lean). In other words, two finite types have the same number of elements if and only if there's a one-to-one correspondence between their elements.

For finite types `α` and `β`, their cardinalities are equal if and only if there exists a bijection between them.


theorem Set.iUnion₂_mono :
    ∀ {α : Type u_1} {ι : Sort u_4} {κ : ι → Sort u_7} {s t : (i : ι) → κ i → Set α},
      (∀ (i : ι) (j : κ i), s i j ⊆ t i j) → ⋃ i, ⋃ j, s i j ⊆ ⋃ i, ⋃ j, t i j :=
  by sorry

This theorem, `Set.iUnion₂_mono`, states that for any type `α` and any indexed types `ι` and `κ`, if we have two families of sets `s` and `t` indexed by `ι` and `κ`, and every set in `s` is a subset of the corresponding set in `t`, then the union over `ι` and `κ` of the sets in `s` is a subset of the union over `ι` and `κ` of the sets in `t`. In other words, if each set from one indexed collection of sets is included in the corresponding set from another collection, then the union of the first collection of sets is included in the union of the second collection.

If for all i in ι and j in κ, s(i, j) ⊆ t(i, j), then ⋃i∈ι⋃j∈κ s(i, j) ⊆ ⋃i∈ι⋃j∈κ t(i, j).


theorem Zsqrtd.coe_int_im : ∀ {d : ℤ} (n : ℤ), (↑n).im = 0 := by sorry

This theorem states that for any integer `n` and any integer `d`, the imaginary part of `n` when it is cast to a complex number (`↑n`) is equal to `0`. This result is expected because integers are real numbers, and real numbers have no imaginary part: their imaginary part is always `0`.

For any integer `n`, the imaginary part of the complex number `↑n` is equal to 0.


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

This theorem, `Subtype.ext_val`, states that for any type `α` and any predicate `p` over `α`, if you have two elements `a1` and `a2` of the subtype `{x // p x}` (that is, the set of elements of `α` for which `p` holds true), if the underlying elements of `a1` and `a2` (obtained by the coercion function `↑`) are equal, then `a1` and `a2` are also equal. Essentially, it's saying that two elements of a subtype are equal if and only if the elements they represent in the parent type are equal.

For any type `α` and predicate `p` over `α`, elements `a1` and `a2` of the subtype `{x // p x}` are equal if and only if their underlying elements `↑a1` and `↑a2` are equal.


theorem Polynomial.modByMonic_add_div :
    ∀ {R : Type u} [inst : Ring R] (p : Polynomial R) {q : Polynomial R},
      Polynomial.Monic q → p %ₘ q + q * (p /ₘ q) = p :=
  by sorry

The theorem `Polynomial.modByMonic_add_div` states that for any type `R` that is a ring, for any polynomial `p` and any monic polynomial `q` (a polynomial is considered monic if its leading coefficient is 1), the sum of the remainder of `p` divided by `q` and the result of `q` multiplied by the quotient of `p` divided by `q` is equal to `p`. In other words, this is the polynomial version of the division algorithm, where the quotient and remainder satisfy the equation `p = q * quotient + remainder`.

For any ring type `R`, monic polynomial `q(X)` and polynomial `p(X)` over `R`, we have `p = q * (p divide q) + remainder(p divide q)`, where `p divide q` is the quotient and `remainder(p divide q)` is the remainder of `p` divided by `q`.


theorem sSup_le_sSup : ∀ {α : Type u_1} [inst : CompleteSemilatticeSup α] {s t : Set α}, s ⊆ t → sSup s ≤ sSup t := by
  sorry

The theorem `sSup_le_sSup` states that for all types `α` that are complete semilattices with respect to the supremum operation, and for all sets `s` and `t` of elements of type `α`, if set `s` is a subset of set `t`, then the supremum of set `s` is less than or equal to the supremum of set `t`. In other words, if all elements of a set `s` are also in a set `t`, then the least upper bound (or supremum) of `s` will not exceed the least upper bound of `t`.

For all complete semilattices with supremum operation α and sets s ⊆ t of elements in α, the supremum of s is less than or equal to the supremum of t.


theorem Finset.card_lt_card : ∀ {α : Type u_1} {s t : Finset α}, s ⊂ t → s.card < t.card := by sorry

This theorem states that for any two finite sets `s` and `t` of any type `α`, if `s` is a proper subset of `t` (i.e., `s` is contained within `t` but `s` is not equal to `t`), then the cardinality (or size) of `s` is less than the cardinality of `t`. In other words, a proper subset of a finite set has fewer elements than the set itself.

For any finite sets `s` and `t` of type `α`, if `s` is a proper subset of `t`, then `#s` (the cardinality of `s`) is strictly less than `#t` (the cardinality of `t`).


theorem Mathlib.Algebra.Module.Basic._auxLemma.4 :
    ∀ {R : Type u_2} {M : Type u_5} [inst : Zero R] [inst_1 : Zero M] [inst_2 : SMulWithZero R M]
      [inst_3 : NoZeroSMulDivisors R M] {c : R} {x : M}, (c • x = 0) = (c = 0 ∨ x = 0) :=
  by sorry

This theorem, `Mathlib.Algebra.Module.Basic._auxLemma.4`, states that for any types `R` and `M`, given that `R` has a zero and `M` also has a zero, and given that scalar multiplication with zero in `R` on `M` is defined and there exists no zero scalar multiplication divisors in `R` and `M`, then for any elements `c` from `R` and `x` from `M`, the equality `c` times `x` equals zero holds if and only if either `c` equals zero or `x` equals zero. This is a fundamental property in algebra where the product of two elements is zero if and only if one or both of the elements are zero.

For any commutative ring `R` with identity and any additive abelian group `M`, if scalar multiplication by zero in `R` on `M` is zero and there are no zero divisors for scalars or vectors, then the product of an element from `R` and an element from `M` is zero if and only if one of them is zero.


SimpleGraph.Adj.symm

theorem SimpleGraph.Adj.symm : ∀ {V : Type u} {G : SimpleGraph V} {u v : V}, G.Adj u v → G.Adj v u := by sorry

This theorem, `SimpleGraph.Adj.symm`, states that for any given graph `G` of type `SimpleGraph V`, with `V` being any type, and any two vertices `u` and `v` of `V`, if `u` is adjacent to `v` in `G`, then `v` is also adjacent to `u`. In other words, adjacency in a simple graph is symmetric.

If `G` is a simple graph and `u` is adjacent to `v` in `G`, then `v` is adjacent to `u` in `G`.


theorem UniformSpace.Completion.norm_coe : ∀ {E : Type u_2} [inst : SeminormedAddCommGroup E] (x : E), ‖↑E x‖ = ‖x‖ :=
  by sorry

This theorem states that for any type `E` which is a seminormed additive commutative group, the norm of an element `x` of `E` when it is embedded into the uniform space completion of `E` is equal to the norm of `x` in `E`. In other words, embedding a seminormed additive commutative group into its uniform space completion preserves the norm of its elements.

The norm of an element in a seminormed additive commutative group is equal to its norm in the completion of that group under the embedding homomorphism.


theorem zsmul_zero : ∀ {α : Type u_1} [inst : SubtractionMonoid α] (n : ℤ), n • 0 = 0 := by sorry

This theorem states that for any integer `n` and any type `α` that is a subtraction monoid, the `n`-fold scalar multiplication (denoted `n • 0`) of the zero element of `α` is also the zero element of `α`. In other words, repeating the zero element of `α` `n` times results in the zero element, in any subtraction monoid `α`. This is a basic property in abstract algebra that expresses how scalar multiplication interacts with the zero element.

For any integer `n` and subtraction monoid `α`, the `n`-fold scalar multiplication of its zero element is the zero element.


theorem Fin.castSucc_castPred : ∀ {n : ℕ} (i : Fin (n + 1)) (h : i ≠ Fin.last n), Fin.castSucc (Fin.castPred i h) = i :=
  by sorry

The theorem `Fin.castSucc_castPred` states that for any natural number `n` and an element `i` of `Fin (n + 1)` which is not the last element of `Fin (n + 1)`, embedding `i` back into `Fin (n + 1)` after casting it to `Fin n` returns the original element `i`. This means that the casting operations `castPred` and `castSucc` are inverses to each other when excluding the last element of `Fin (n + 1)`.

For all natural numbers `n` and elements `i` of `Fin (n + 1)` that are not the last element, `castPred (castSucc i) = i` holds in `Fin (n + 1)`.


theorem Fin.insertNth_apply_succAbove :
    ∀ {n : ℕ} {α : Fin (n + 1) → Type u} (i : Fin (n + 1)) (x : α i) (p : (j : Fin n) → α (Fin.succAbove i j))
      (j : Fin n), Fin.insertNth i x p (Fin.succAbove i j) = p j :=
  by sorry

The theorem `Fin.insertNth_apply_succAbove` states that for any natural number `n`, any type function `α` indexed by `Fin (n + 1)`, any index `i` in `Fin (n + 1)`, any element `x` of the type `α i`, any function `p` from `Fin n` to `α (Fin.succAbove i j)`, and any index `j` in `Fin n`, applying the function `Fin.insertNth` to the index `Fin.succAbove i j` is equivalent to applying the function `p` to the index `j`. In other words, inserting an element at a position determined by `Fin.succAbove i j` in a sequence using `Fin.insertNth` and then accessing the element at that position yields the same result as directly applying the function `p` to `j`.

For any natural number `n`, any type function `α` indexed by `Fin (n + 1)`, any `i` in `Fin (n + 1)`, any `x` of type `α i`, any function `p` from `Fin n` to `α (Fin.succAbove i)`, and any `j` in `Fin n`, `Fin.insertNth (Fin.succAbove i j) x (p j) = p j`.


Int.le.intro

theorem Int.le.intro : ∀ {a b : ℤ} (n : ℕ), a + ↑n = b → a ≤ b := by sorry

This theorem, `Int.le.intro`, establishes that for any two integers `a` and `b`, and a natural number `n`, if `a` plus the conversion of `n` to an integer equals `b`, then `a` is less than or equal to `b`. Basically, it states that if you can add a natural number to `a` to get `b`, then `a` must be less than or equal to `b`.

For all integers `a` and `b` and natural number `n`, if `a + (nat.to_int n) = b`, then `a ≤ b`.


theorem And.imp_left : ∀ {a b c : Prop}, (a → b) → a ∧ c → b ∧ c := by sorry

This theorem, "And.imp_left", states that for any three propositional variables 'a', 'b', and 'c', if there exists a logical implication from 'a' to 'b', then it also implies that if 'a' and 'c' are true, then 'b' and 'c' will also be true. In other words, you can import the implication from 'a' to 'b' into an "and" statement with 'c', preserving the truth of 'c'.

If `a` implies `b` in propositional logic, then `(a ∧ c)` is logically equivalent to `(b ∧ c)`.


theorem Set.image_nonempty :
    ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {s : Set α}, Set.Nonempty (f '' s) ↔ Set.Nonempty s := by sorry

The theorem `Set.image_nonempty` states that for all types `α` and `β`, for any function `f` from `α` to `β`, and any set `s` of type `α`, the image of `s` under `f` is nonempty if and only if `s` itself is nonempty. This means that a function will map a nonempty set to a nonempty set under its operation, and inversely, if the image of a function is nonempty, then the original set must also have been nonempty.

For all types α and β, and for any function f from α to β, if s is a nonempty set of type α, then the image of s under f is also a nonempty set. Conversely, if the image of s under f is nonempty, then s itself must be nonempty.


theorem mul_le_of_le_one_left :
    ∀ {α : Type u_1} {a b : α} [inst : MulOneClass α] [inst_1 : Zero α] [inst_2 : Preorder α] [inst_3 : MulPosMono α],
      0 ≤ b → a ≤ 1 → a * b ≤ b :=
  by sorry

This theorem states that for any type 'α' equipped with multiplication, one, zero, and a preorder relation, which also satisfies the property of positive monotonicity of multiplication, if 'b' is a nonnegative element ('b' is greater than or equal to zero), and 'a' is less than or equal to one, then the product of 'a' and 'b' is less than or equal to 'b'. In mathematical terms, if 0 ≤ b and a ≤ 1, then a*b ≤ b. This theorem thus captures a property of multiplication specific to partially ordered algebraic structures, where multiplication by an element less than or equal to one does not increase the magnitude of another nonnegative element.

For any type 'α' with multiplication, one, zero, and a preorder relation satisfying positive monotonicity, if 0 ≤ b and 0 ≤ a, then a * b ≤ b.


theorem UniformSpace.Completion.denseInducing_coe : ∀ {α : Type u_1} [inst : UniformSpace α], DenseInducing ↑α := by
  sorry

This theorem states that for any type `α` that carries a `UniformSpace` structure, the coercive function from that type into its completion induces a dense subset. In simpler terms, any point in the completion of the uniform space can be approximated as closely as desired by a point from the original space, making the original space "dense" within its completion.

For any uniform space `(α, δ)`, the coercion map from `α` to its completion `(COMP α, δ')` is a continuous surjection with dense source, i.e., every point in `COMP α` can be approximated by a sequence of points in `α`.


theorem Nat.add_left_comm : ∀ (n m k : ℕ), n + (m + k) = m + (n + k) := by sorry

This theorem is called `Nat.add_left_comm`, and it states that for any three natural numbers `n`, `m`, and `k`, the sum of `n` and the sum of `m` and `k` is equal to the sum of `m` and the sum of `n` and `k`. In other words, it's saying that addition of natural numbers is left-commutative. This could be written in mathematical notation as ∀ n, m, k ∈ ℕ, n + (m + k) = m + (n + k).

For all natural numbers `n`, `m`, and `k`, the left-commutative property holds for addition, that is, `n + (m + k) = m + (n + k)`.


HasDerivWithinAt.differentiableWithinAt

theorem HasDerivWithinAt.differentiableWithinAt :
    ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {F : Type v} [inst_1 : NormedAddCommGroup F]
      [inst_2 : NormedSpace 𝕜 F] {f : 𝕜 → F} {f' : F} {x : 𝕜} {s : Set 𝕜},
      HasDerivWithinAt f f' s x → DifferentiableWithinAt 𝕜 f s x :=
  by sorry

The theorem `HasDerivWithinAt.differentiableWithinAt` states that for any type `𝕜` that has a non-trivial normed field, type `F` that has a normed add commutative group and a normed space over `𝕜`, a function `f` from `𝕜` to `F`, a derivative `f'` of type `F`, a point `x` of type `𝕜`, and a set `s` of type `Set 𝕜`; if the function `f` has the derivative `f'` at the point `x` within the subset `s`, then the function `f` is differentiable at the point `x` within the set `s`. In other words, if a function has a derivative within a certain set at a certain point, then it is differentiable within that set at that point.

If a function has a derivative within a set at a point, then it is differentiable within that set at that point.


MeasureTheory.OuterMeasure.mono'

theorem MeasureTheory.OuterMeasure.mono' :
    ∀ {α : Type u_1} (m : MeasureTheory.OuterMeasure α) {s₁ s₂ : Set α}, s₁ ⊆ s₂ → ↑m s₁ ≤ ↑m s₂ := by sorry

The theorem `MeasureTheory.OuterMeasure.mono'` states that for any type `α`, given an outer measure `m` on `α` and two sets `s₁` and `s₂` of `α`, if `s₁` is a subset of `s₂` (`s₁ ⊆ s₂`), then the outer measure of `s₁` is less than or equal to the outer measure of `s₂`. In other words, the outer measure of a set does not increase if the set is enlarged.

For any outer measure `m` and sets `s₁ ⊆ s₂`, we have `m(s₁) ≤ m(s₂)`.


theorem CategoryTheory.Subobject.ofLE_arrow :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {B : C} {X Y : CategoryTheory.Subobject B} (h : X ≤ Y),
      CategoryTheory.CategoryStruct.comp (CategoryTheory.Subobject.ofLE X Y h) (CategoryTheory.Subobject.arrow Y) =
        CategoryTheory.Subobject.arrow X :=
  by sorry

This theorem states that in any category `C`, for any object `B` in `C` and for any two subobjects `X` and `Y` of `B`, if `X` is less than or equal to `Y` (denoted by `h : X ≤ Y`), then the composition of the morphism from `X` to `Y` (obtained by `CategoryTheory.Subobject.ofLE X Y h`) and the arrow from `Y` to `B` (`CategoryTheory.Subobject.arrow Y`) is equal to the arrow from `X` to `B` (`CategoryTheory.Subobject.arrow X`).

In other words, if you have two subobjects and there exists a morphism witnessing that one is less than or equal to the other, the composed morphism from the first subobject to the ambient object (through the second subobject) is the same as the direct morphism from the first subobject to the ambient object. This is a property that maintains the structure of the category when dealing with subobjects.

In any category C, for any object B and subobjects X and Y of B with X ≤ Y, the composition of the morphisms from X to Y and from Y to B equals the morphism from X to B.


theorem Part.mem_unique : ∀ {α : Type u_1} {a b : α} {o : Part α}, a ∈ o → b ∈ o → a = b := by sorry

This theorem, `Part.mem_unique`, states that for any type `α`, and any two elements `a` and `b` of that type, if both `a` and `b` are elements of the same partial function `o` (of type `Part α`), then `a` and `b` must be equal. In other words, it asserts that a partial function can have at most one value for any given input.

For any type `α` and partial function `o` of type `Part α`, if `a` and `b` are in the domain of `o` and `o a = o b`, then `a = b`.


theorem Mathlib.Data.Complex.Exponential._auxLemma.8 : ∀ (x : ℝ), Complex.cos ↑x = ↑(Real.cos x) := by sorry

This theorem states that for any real number `x`, the complex cosine of `x` (when `x` is treated as a complex number with imaginary part 0) is equal to the real cosine of `x` treated as a real number. Here, the complex cosine is defined via the exponential function, and the real cosine is defined as the real part of the complex cosine. In mathematical terms, for any real number `x`, `Complex.cos (x)` is equal to `Real.cos (x)`.

For any real number x, the complex cosine of x treated as a complex number with imaginary part 0 equals the real part of the complex cosine of x, which is equivalent to the real cosine of x. In other words, `Real.cos x = Re part (Complex.cos x)`.


theorem Polynomial.degree_neg :
    ∀ {R : Type u} [inst : Ring R] (p : Polynomial R), Polynomial.degree (-p) = Polynomial.degree p := by sorry

This theorem states that for every polynomial `p` defined over a ring `R`, the degree of the negation of `p` (denoted as `-p`) is the same as the degree of `p` itself. In mathematical terms, if `p` is a polynomial over a ring `R`, then the largest exponent of `x` that appears in `-p` is the same as the largest exponent of `x` that appears in `p`. This is true regardless of whether `p` is a non-zero polynomial or the zero polynomial.

The degree of the negation of a polynomial over a ring is equal to the degree of the polynomial itself.


theorem Nat.zero_eq : Nat.zero = 0 := by sorry

This theorem states that the natural number zero, denoted as `Nat.zero` in Lean, is equal to the numeral `0`. Although they may appear to be defined differently in the context of the Lean programming language, this theorem assures us that they are indeed the same value.

The theorem asserts the equality of the natural number zero in Lean and the numeral 0.


theorem Mathlib.Algebra.Order.Field.Basic._auxLemma.5 :
    ∀ {α : Type u_2} [inst : LinearOrderedSemifield α] {a : α}, (a⁻¹ < 1) = (a ≤ 0 ∨ 1 < a) := by sorry

This theorem states that for any type `α` that is a Linear Ordered Semifield and any element `a` of type `α`, `a` inverse is less than 1 if and only if `a` is less than or equal to zero or `a` is greater than 1. Essentially, this theorem provides conditions under which the inverse of a number is less than one within the context of a Linear Ordered Semifield.

In a Linear Ordered Semifield `α`, for any element `a` of type `α`, `a` has an inverse `b` such that `0 ≤ a ≤ 1` or `a > 1` implies `b < 1`.


theorem Polynomial.finset_sum_coeff :
    ∀ {R : Type u} [inst : Semiring R] {ι : Type u_1} (s : Finset ι) (f : ι → Polynomial R) (n : ℕ),
      Polynomial.coeff (Finset.sum s fun b => f b) n = Finset.sum s fun b => Polynomial.coeff (f b) n :=
  by sorry

The theorem `Polynomial.finset_sum_coeff` states that for any semiring `R`, any type `ι`, any finite set `s` of type `ι`, any function `f` from `ι` to `Polynomial R`, and any natural number `n`, the coefficient of `X^n` in the polynomial resulting from the sum of applying `f` to each element in `s` is equal to the sum of the coefficients of `X^n` in each polynomial obtained by applying `f` to the elements of `s`. In other words, the distribution of `f` and `Polynomial.coeff` over the sum is commutative.

For any semiring R, type ι, finite set s of ι, function f from ι to Polynomial R, and natural number n, the coefficient of X^n in the polynomial sum of f applied to each element in s is equal to the sum of the coefficients of X^n in each polynomial obtained by applying f to the elements of s.


theorem Computable.to₂ :
    ∀ {α : Type u_1} {β : Type u_2} {σ : Type u_4} [inst : Primcodable α] [inst_1 : Primcodable β]
      [inst_2 : Primcodable σ] {f : α × β → σ}, Computable f → Computable₂ fun a b => f (a, b) :=
  by sorry

The theorem `Computable.to₂` states that for any three types `α`, `β`, and `σ` which have instances of `Primcodable`, and a function `f` from the product of `α` and `β` to `σ`, if this function `f` is computable (as defined by the `Computable` property), then the function `f` is also computable when viewed as a two-argument function (as defined by the `Computable₂` property). This essentially means that computable functions remain computable even when their arguments are rearranged.

If `f` is a computable function from the product of types `α` and `β` to `σ`, where `α`, `β`, and `σ` have `Primcodable` instances, then `f` is also computable as a two-argument function.


theorem Finset.Nonempty.ne_empty : ∀ {α : Type u_1} {s : Finset α}, s.Nonempty → s ≠ ∅ := by sorry

This theorem states that for any type `α` and any finite set `s` of type `α`, if `s` is nonempty (i.e., it contains at least one element), then `s` is not equal to the empty set. In mathematical terms, given a finite set `s` in an arbitrary universe `α`, if `s` contains at least one element, we can conclusively say that `s` is not the empty set.

If a finite set `s` is nonempty, then `s` is not the empty set.


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

This theorem states that for any entity `a` of a certain type `E`, where `E` is a normed group, the norm of `a` is less than or equal to zero if and only if `a` is zero. A normed group is a group in which distance and subtraction operations are defined in a way that satisfies certain conditions. Essentially, this theorem is saying that in these mathematical structures, the only entity with a norm (or length) of zero or less is the zero entity itself.

In a normed group, an entity has zero norm if and only if it is the additive identity.