theorem Pi.single_eq_of_ne :
    ∀ {I : Type u} {f : I → Type v₁} [inst : DecidableEq I] [inst_1 : (i : I) → Zero (f i)] {i i' : I},
      i' ≠ i → ∀ (x : f i), Pi.single i x i' = 0 :=
  by sorry

The theorem `Pi.single_eq_of_ne` states that for any type `I`, a function `f : I → Type v₁`, an instance of decidable equality on `I`, and an instance of zero for `f i`, if `i'` and `i` are distinct (i.e., `i' ≠ i`), then for any `x` in the codomain of `f` at `i`, the value of the function `Pi.single i x` at `i'` is zero. In other words, it asserts that the "single" function, which assigns the value `x` to `i` and zero to all other elements of `I`, indeed returns zero for inputs not equal to `i`.

For any function `f : I -> Type v₁`, decidable equality on `I`, and `i ≠ i'` in `I`, the "single" function `Pi.single i x` assigns zero to `i'` for any `x` in the codomain of `f`.


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

This theorem, `inner_conj_symm`, states that for any two elements `x` and `y` in an inner product space `E` over a field `𝕜` that has a star ring endomorphism, the inner product of `y` and `x` conjugated by the star ring endomorphism is equal to the inner product of `x` and `y`. In mathematical terms, it states that ⟨y, x⟩ₖ⁎ = ⟨x, y⟩ₖ for all `x` and `y` in `E`, where ⟨., .⟩ₖ is the inner product in the space `E`.

For any inner product space E over a field with a star ring endomorphism, the conjugated inner product of y and x equals the inner product of x and y, i.e., ⟨y, x⟩ₖ⁎ = ⟨x, y⟩ₖ for all x and y in E.


/-- `zeta n A B` is a primitive `n`-th root of unity.  -/
theorem IsCyclotomicExtension.zeta_spec :
    ∀ (n : ℕ+) (A : Type w) (B : Type z) [inst : CommRing A] [inst_1 : CommRing B] [inst_2 : Algebra A B]
      [inst_3 : IsCyclotomicExtension {n} A B], IsPrimitiveRoot (IsCyclotomicExtension.zeta n A B) ↑n :=
  by sorry

The theorem `IsCyclotomicExtension.zeta_spec` states that for any positive integer `n`, and types `A` and `B` where `A` and `B` are both commutative rings and `B` is an `A`-algebra, given that `B` is an `n`-th cyclotomic extension of `A`, the function `zeta n A B`, as defined in the context of `IsCyclotomicExtension`, is a primitive `n`-th root of unity. This means that the output of the `zeta` function is an element in `B` that generates the cyclic group of `n`-th roots of unity.

For any positive integer `n`, if `B` is an `n`-th cyclotomic extension of the commutative ring `A`, then the `zeta_n` function output of `IsCyclotomicExtension` for `A` and `B` is a primitive `n`-th root of unity in `B`.


/-- The oriented angle between two vectors equals the unoriented angle if the sign is positive.  -/
theorem Orientation.oangle_eq_angle_of_sign_eq_one :
    ∀ {V : Type u_1} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V]
      [inst_2 : Fact (FiniteDimensional.finrank ℝ V = 2)] (o : Orientation ℝ V (Fin 2)) {x y : V},
      Real.Angle.sign (Orientation.oangle o x y) = 1 → Orientation.oangle o x y = ↑(InnerProductGeometry.angle x y) :=
  by sorry

The theorem `Orientation.oangle_eq_angle_of_sign_eq_one` states that, given a normed additive commutative group `V` equipped with an inner product space over real numbers (ℝ) which is two-dimensional, an orientation `o` of `V`, and any two vectors `x` and `y` in `V`, if the sign of the oriented angle between `x` and `y` is positive (i.e., `1`), then the oriented angle between `x` and `y` is equal to the unoriented angle between `x` and `y`. This theorem formalizes the intuitive notion that a positive oriented angle in a two-dimensional space corresponds to the standard "counterclockwise" angle measurement.

If the oriented angle between two vectors in a 2-dimensional inner product space is positive, then it equals the unoriented angle between them.


Zsqrtd.ext

theorem Zsqrtd.ext : ∀ {d : ℤ} (x y : ℤ√d), x.re = y.re → x.im = y.im → x = y := by sorry

This theorem states that for any integer `d` and any two numbers `x` and `y` in the space of integer square roots of `d` (notated as `ℤ√d`), if the real part of `x` is equal to the real part of `y` and the imaginary part of `x` is equal to the imaginary part of `y`, then `x` is equal to `y`. Essentially, it's expressing the concept that two complex numbers are equal if and only if both their real parts and their imaginary parts are equal.

If two complex numbers with integer square root coefficients have equal real and imaginary parts, then they are equal.


theorem CategoryTheory.Subobject.factorThru_arrow :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X Y : C} (P : CategoryTheory.Subobject Y) (f : X ⟶ Y)
      (h : CategoryTheory.Subobject.Factors P f),
      CategoryTheory.CategoryStruct.comp (CategoryTheory.Subobject.factorThru P f h)
          (CategoryTheory.Subobject.arrow P) =
        f :=
  by sorry

The theorem `CategoryTheory.Subobject.factorThru_arrow` states that for any category `C`, any objects `X` and `Y` in `C`, a subobject `P` of `Y`, and a morphism `f` from `X` to `Y` which factors through `P`, the composition of the factorization of `f` through `P` (denoted as `CategoryTheory.Subobject.factorThru P f h`) with the morphism from the underlying object of `P` to `Y` (denoted as `CategoryTheory.Subobject.arrow P`) is equal to `f`. In simpler terms, it states that if we first factor `f` through `P`, and then follow the arrow from `P` to `Y`, we end up with the original morphism `f`. This theorem is a formalization of the property of factorization in category theory.

Given any category C, object X, object Y, subobject P of Y, and morphism f from X to Y factors through P, the composite of the factorization of f through P and the morphism from the subobject P to Y equals f.


theorem ne_comm : ∀ {α : Sort u_1} {a b : α}, a ≠ b ↔ b ≠ a := by sorry

This theorem, `ne_comm`, states that for any type or sort `α`, and any two elements `a` and `b` of type `α`, the proposition `a ≠ b` is equivalent to `b ≠ a`. In other words, if `a` is not equal to `b`, then `b` is not equal to `a`, and vice versa. This theorem applies to any type, not just numbers.

For any type or sort `α` and elements `a`, `b` of type `α`, the proposition `a ≠ b` is equivalent to `b ≠ a`.


theorem lt_add_of_pos_right :
    ∀ {α : Type u_1} [inst : AddZeroClass α] [inst_1 : LT α]
      [inst_2 : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x < x_1] (a : α) {b : α}, 0 < b → a < a + b :=
  by sorry

This theorem, named `lt_add_of_pos_right`, states that for any type `α` equipped with an addition operation, a zero element, and a less-than relation such that addition is covariant with respect to the less-than relation, and for any elements `a` and `b` of this type, if `b` is greater than zero, then `a` is less than `a + b`. Simply put, adding a positive number to any number `a` results in a number greater than `a`.

For any type equipped with a covariant addition, zero, and less-than relation, if `a` is an element and `b` is positive, then `a < a + b`.


theorem MvPolynomial.eval₂_X :
    ∀ {R : Type u} {S₁ : Type v} {σ : Type u_1} [inst : CommSemiring R] [inst_1 : CommSemiring S₁] (f : R →+* S₁)
      (g : σ → S₁) (n : σ), MvPolynomial.eval₂ f g (MvPolynomial.X n) = g n :=
  by sorry

The theorem `MvPolynomial.eval₂_X` states that for all types `R`, `S₁` and `σ` where `R` and `S₁` are commutative semirings, given a ring homomorphism `f` from `R` to `S₁`, a function `g` from `σ` to `S₁`, and an element `n` of type `σ`, evaluating the degree `1` monomial `MvPolynomial.X n` using the evaluation function `MvPolynomial.eval₂` with `f` and `g` yields the value `g n`. In mathematical terms, this means that applying the function `g` to the variable `n` gives the same result as evaluating the monomial $X_n$ where the coefficients are mapped according to `f` and the variables are mapped according to `g`.

For all commutative semirings R and S₁, ring homomorphism f : R → S₁, function g : σ → S₁, and element n : σ, we have MvPolynomial.eval₂ f g (MvPolynomial.X n) = g n.


theorem monotone_id : ∀ {α : Type u} [inst : Preorder α], Monotone id := by sorry

The theorem `monotone_id` states that for any type `α` that has a preorder (a binary relation reflecting a linearity/ordering of some kind), the identity function on this type is monotone. In other words, for all `a` and `b` in `α`, if `a` is less than or equal to `b`, then `id a` (which is just `a`) is less than or equal to `id b` (which is just `b`). This is essentially a formalization of the obvious fact that the identity function preserves the order of elements in any ordered set.

For any type equipped with a preorder, the identity function is a monotone function with respect to the preorder relation.


theorem ENNReal.ofReal_one : ENNReal.ofReal 1 = 1 := by sorry

The theorem `ENNReal.ofReal_one` states that if we apply the function `ENNReal.ofReal` to the real number `1`, the result is `1`. This makes sense since `1` is nonnegative, so `ENNReal.ofReal` just returns the same value `1`.

The theorem `ENNReal.ofReal_one` asserts that `ENNReal.ofReal 1 = 1`.


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

This theorem is named `Nat.le_antisymm` and it states that for any two natural numbers `n` and `m`, if `n` is less than or equal to `m` and `m` is less than or equal to `n`, then `n` must be equal to `m`. In other words, this is the antisymmetry property of the less than or equal to relation on natural numbers: it cannot be the case that both `n ≤ m` and `m < n` for natural numbers `n` and `m`.

If `n` is less than or equal to `m` and `m` is less than or equal to `n` then `n` equals `m`. (Antisymmetry property of the less-than-or-equal relation on natural numbers)


Substring.Valid.validFor

theorem Substring.Valid.validFor : ∀ {s : Substring}, Substring.Valid s → ∃ l m r, Substring.ValidFor l m r s := by
  sorry

This theorem states that for every substring 's', if 's' is valid, then there exist strings 'l', 'm', and 'r' such that 's' is valid for the concatenation of 'l', 'm', and 'r'. In other words, any valid substring must be part of some valid concatenation of three other strings.

For every valid string `s`, there exist strings `l`, `m`, and `r` such that `l & m & r = s` holds, where `&` denotes string concatenation.


theorem CategoryTheory.Limits.biprod.hom_ext' :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
      {X Y Z : C} [inst_2 : CategoryTheory.Limits.HasBinaryBiproduct X Y] (f g : X ⊞ Y ⟶ Z),
      CategoryTheory.CategoryStruct.comp CategoryTheory.Limits.biprod.inl f =
          CategoryTheory.CategoryStruct.comp CategoryTheory.Limits.biprod.inl g →
        CategoryTheory.CategoryStruct.comp CategoryTheory.Limits.biprod.inr f =
            CategoryTheory.CategoryStruct.comp CategoryTheory.Limits.biprod.inr g →
          f = g :=
  by sorry

The theorem `CategoryTheory.Limits.biprod.hom_ext'` states that in a category `C` equipped with a binary biproduct structure and zero morphisms, for any three objects `X`, `Y`, and `Z` and any two morphisms `f, g : X ⊞ Y ⟶ Z`, if we have that the composition of `f` (or `g`) with the inclusion from `X` into the first summand (denoted `CategoryTheory.Limits.biprod.inl`) is equal, and similarly for `Y` into the second summand (denoted `CategoryTheory.Limits.biprod.inr`), then `f` must be equal to `g`. In mathematical terms, it states that if `(inl ≫ f) = (inl ≫ g)` and `(inr ≫ f) = (inr ≫ g)` then `f = g`. This is a statement about the uniqueness of morphisms in the context of biproducts in a category.

In a category with binary biproducts and zero morphisms, if the inclusions of the summands make the same compositions with two morphisms from the biproduct to another object, then those morphisms are equal.


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

This theorem states that for any integer `a`, the product of `a` and zero equals zero. In mathematical notation, it's expressed as ∀a ∈ ℤ, a * 0 = 0. This is a fundamental property of multiplication in the set of integers (ℤ), and it's an instance of the more general arithmetic property that any number multiplied by zero gives zero.

For all integers `a`, `a` multiplied by zero equals zero. (Or more succinctly: For all `a` in ℤ, `a` * 0 = 0.)


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

This theorem states that for any set `s` of a certain type `α`, the set `s` is equivalent to the empty set if and only if for every element `x` of type `α`, `x` is not a member of the set `s`. In other words, a set is empty if and only if no element of the type of the set belongs to the set.

A set of type `α` is empty if and only if it contains no elements of type `α`.


theorem AEMeasurable.prod_mk :
    ∀ {α : Type u_2} {β : Type u_3} {γ : Type u_4} {m0 : MeasurableSpace α} [inst : MeasurableSpace β]
      [inst_1 : MeasurableSpace γ] {μ : MeasureTheory.Measure α} {f : α → β} {g : α → γ},
      AEMeasurable f μ → AEMeasurable g μ → AEMeasurable (fun x => (f x, g x)) μ :=
  by sorry

The theorem `AEMeasurable.prod_mk` states that for any types `α`, `β`, and `γ`; given a measurable space over `α`, a measurable space over `β`, a measurable space over `γ`, a measure `μ` over the type `α`, and functions `f` and `g` that map from `α` to `β` and `γ` respectively; if `f` and `g` are both almost everywhere measurable (AEMeasurable), then the function that maps `x` in `α` to the pair `(f x, g x)` is also almost everywhere measurable. In other words, we can create an almost everywhere measurable function over pairs of the range values, if the original functions are almost everywhere measurable.

If `f` and `g` are almost everywhere measurable functions from a measurable space `(α, Σα, μ)` to measurable spaces `(β, Σβ)` and `(γ, Σγ)` respectively, then the function `x ↦ (f x, g x)` is almost everywhere measurable from `(α, Σα)` to the product measurable space `(β × γ, Σβ × Σγ)`.


theorem Nat.exists_eq_succ_of_ne_zero : ∀ {n : ℕ}, n ≠ 0 → ∃ k, n = Nat.succ k := by sorry

This theorem states that for any natural number `n` that is not zero, there exists another natural number `k` such that `n` is the successor of `k`. In other words, if you have a nonzero natural number, it must be one greater than another natural number.

For any non-zero natural number `n`, there exists a natural number `k` such that `n = Succ(k)`.


theorem mul_right_cancel :
    ∀ {G : Type u_1} [inst : Mul G] [inst_1 : IsRightCancelMul G] {a b c : G}, a * b = c * b → a = c := by sorry

This theorem, `mul_right_cancel`, states that for any type `G` equipped with a multiplication operation and the property of right cancellation, and for any elements `a`, `b`, and `c` of type `G`, if the multiplication of `a` and `b` equals the multiplication of `c` and `b`, then `a` must be equal to `c`. In other words, it states that multiplication in such a setting is 'right cancellable': if `a * b = c * b`, we can 'cancel out' the `b` on the right side of both equations to get `a = c`. This property is crucial in structures like groups or fields where operations have certain cancellation properties.

If `a * b = c * b` in a type `G` with right cancellation, then `a = c`.


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

This theorem states that for any type `α` and any sets `s` and `t` of this type, if `s` is a subset of `t`, then the intersection of `s` and `t` is equal to `s`. In other words, all elements in `s` are also in `t`, so the common elements between `s` and `t` are just the elements of `s`. This can be expressed in mathematical notation as: if $s \subseteq t$, then $s \cap t = s$.

For any sets `s` and `t` of type `α`, if `s` is a subset of `t`, then `s` is equal to their intersection, i.e., `s = s ∩ t`.


Sum.inr.injEq

theorem Sum.inr.injEq : ∀ {α : Type u} {β : Type v} (val val_1 : β), (Sum.inr val = Sum.inr val_1) = (val = val_1) := by
  sorry

This theorem, `Sum.inr.injEq`, states that for any two values (`val` and `val_1`) of type `β`, the assertion that `Sum.inr val` is equal to `Sum.inr val_1` is equivalent to the assertion that `val` is equal to `val_1`. The `Sum.inr` function wraps a value into the right side of a sum type, and this theorem assures that the equality of two such wrapped values depends solely on the equality of the values themselves, not on the wrapping function.

For any type `β`, the equality of `Sum.inr (val : β)` and `Sum.inr (val_1 : β)` holds if and only if `val` is equal to `val_1`.


asymm

theorem asymm : ∀ {α : Sort u} {r : α → α → Prop} [inst : IsAsymm α r] {a b : α}, r a b → ¬r b a := by sorry

This theorem states that, in any sort or type `α`, given a binary relation `r` and assuming that `r` is an asymmetric relation, for all elements `a` and `b` of `α`, if `r a b` holds, then `r b a` cannot hold. In other words, if `r` relates `a` to `b`, it cannot relate `b` back to `a`. This corresponds to the mathematical concept of asymmetric relation, where if a relation holds from `a` to `b`, it cannot hold from `b` to `a`.

In any asymmetric relation r on type α, for all a and b, if r a b holds then r b a does not hold.


theorem Polynomial.mem_support_iff :
    ∀ {R : Type u} {n : ℕ} [inst : Semiring R] {p : Polynomial R},
      n ∈ Polynomial.support p ↔ Polynomial.coeff p n ≠ 0 :=
  by sorry

The theorem `Polynomial.mem_support_iff` states that for any given type `R` (which is a semiring), a natural number `n`, and a polynomial `p` of type `R`, the number `n` is in the support of the polynomial `p` if and only if the coefficient of `X^n` in `p` is non-zero. This support of a polynomial is defined as the set of all `n` such that `X^n` has a non-zero coefficient. Hence, this theorem is connecting the concept of the support of a polynomial to the non-zero coefficients of the polynomial.

For any semiring R, natural number n, and polynomial p over R, n is in the support of p if and only if the coefficient of X^n in p is non-zero.


theorem Finset.mem_union :
    ∀ {α : Type u_1} [inst : DecidableEq α] {s t : Finset α} {a : α}, a ∈ s ∪ t ↔ a ∈ s ∨ a ∈ t := by sorry

This theorem states that for any type `α` with decidable equality, given two sets (`s` and `t`) of this type and an element `a` of type `α`, `a` is a member of the union of the two sets if and only if `a` is a member of at least one of the two sets. In other words, it formalizes the standard property of set union in the context of finite sets (Finsets) in the Lean 4 theorem prover.

For any decidably equal type `α` and sets `s` and `t` of type `α`, `a` is in the union of `s` and `t` if and only if `a` is in `s` or `a` is in `t`.


theorem Polynomial.coeff_eq_zero_of_natDegree_lt :
    ∀ {R : Type u} [inst : Semiring R] {p : Polynomial R} {n : ℕ},
      Polynomial.natDegree p < n → Polynomial.coeff p n = 0 :=
  by sorry

The theorem `Polynomial.coeff_eq_zero_of_natDegree_lt` states that for any type `R` equipped with a semiring structure, any polynomial `p` over `R`, and any natural number `n`, if `n` is greater than the natural degree of `p` (`Polynomial.natDegree p < n`), then the coefficient of `X^n` in `p` (`Polynomial.coeff p n`) is equal to zero. In other words, if the degree of a polynomial is less than a given natural number, the polynomial's coefficient for the term with that exponent is zero.

For any polynomial `p` over a semiring `R` and natural number `n` greater than its degree `Polynomial.natDegree p`, the coefficient `Polynomial.coeff p n` is equal to zero.


theorem Mathlib.Data.Set.Finite._auxLemma.3 :
    ∀ {α : Type u} {s : Set α} {a : α} (hs : Set.Finite s), (a ∈ Set.Finite.toFinset hs) = (a ∈ s) := by sorry

This theorem states that for any type `α`, any finite set `s` of type `α`, and any element `a` of type `α`, the membership of `a` in the finite set `s` is equivalent to the membership of `a` in the finset obtained from the set `s`. In other words, an element `a` belongs to the finset representation of a finite set `s` if and only if `a` belongs to the set `s`.

For any type `α`, any finite set `s` of type `α`, and any element `a` of type `α`, `a` is in the finite set `s` if and only if `a` is in the finset obtained from `s`.


theorem AddSubmonoid.LocalizationMap.map_addUnits :
    ∀ {M : Type u_1} [inst : AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [inst_1 : AddCommMonoid N]
      (f : AddSubmonoid.LocalizationMap S N) (y : ↥S), IsAddUnit ((AddSubmonoid.LocalizationMap.toMap f) ↑y) :=
  by sorry

This theorem states that for any additive commutative monoid `M` and its additive submonoid `S`, along with a localization map `f` to another additive commutative monoid `N`, every element `y` from the submonoid `S` is an additive unit when mapped to `N` using the localization map. In other words, every mapped element from the submonoid has a two-sided additive inverse in the monoid `N`. In mathematical terms, for any `y` in `S`, there exists an element in `N` such that their sum under the localization map `f` is the additive identity of the monoid `N`.

For any additive commutative monoid `M` with submonoid `S`, and localization map from `S` to an additive commutative monoid `N`, every element in `S` is a local additive unit in `N`, meaning it has a two-sided additive inverse in `N`.


theorem continuousOn_iff_continuous_restrict :
    ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] {f : α → β} {s : Set α},
      ContinuousOn f s ↔ Continuous (Set.restrict s f) :=
  by sorry

The theorem `continuousOn_iff_continuous_restrict` asserts that for any type `α` and `β` which have a topology, any function `f` from `α` to `β`, and any set `s` of type `α`, the function `f` is continuous on the set `s` if and only if when the function `f` is restricted to the set `s`, it is continuous. In other words, it establishes an equivalence between the continuity of a function on a subset of its domain and the continuity of its restriction to that subset.

A function between topological spaces is continuous on a subset if and only if its restriction to that subset is continuous.


theorem ENNReal.ofReal_zero : ENNReal.ofReal 0 = 0 := by sorry

This theorem states that when the function `ENNReal.ofReal` is applied to the real number `0`, it returns `0`. This function is defined to return the input if it is nonnegative, and `0` otherwise, so in this case, because `0` is nonnegative, it should return `0`.

The theorem asserts that `ENNReal.ofReal 0 = 0`.


theorem Real.log_one : Real.log 1 = 0 := by sorry

The theorem `Real.log_one` states that the logarithm of 1 in the real numbers is equal to 0. This is a standard result in mathematics, as any number raised to the power of 0 is 1, so the logarithm, being the inverse operation to exponentiation, must give 0 when applied to 1. This result holds true under the definition of the real logarithm function in Lean 4 whether 1 is considered a positive real number, or when it's equal to 0.

The logarithm of 1 in the real numbers equals 0.


Filter.Germ.inductionOn

theorem Filter.Germ.inductionOn :
    ∀ {α : Type u_1} {β : Type u_2} {l : Filter α} (f : Filter.Germ l β) {p : Filter.Germ l β → Prop},
      (∀ (f : α → β), p ↑f) → p f :=
  by sorry

This theorem is about the induction principle on the space of germs of functions from `α` to `β` at a filter `l`. It states that for all types `α` and `β`, for all filters `l` on `α`, and for any germ `f` of functions from `α` to `β` at filter `l`, if a proposition `p` holds for the equivalence class of every function from `α` to `β` (represented by `↑f`), then the proposition `p` also holds for the germ `f`.

If a proposition holds for the equivalence classes of functions from `α` to `β` at filter `l`, then it holds for the germ of any function `f` from `α` to `β` at filter `l`.


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

This theorem states that for any type `α` equipped with a pseudometric space structure, and any element `x` of `α`, the neighborhood filter at `x` has a basis given by the set of metric balls centered at `x` with a radius greater than zero. In other words, every neighborhood of `x` can be expressed as a union of such metric balls. In mathematical terms, the idea is that for each point in the pseudometric space, we can generate all its neighborhoods using "open balls" centered at the point with positive radii.

For any pseudometric space `(α, d)` and element `x` in `α`, the neighborhood filter of `x` is equal to the filter generated by the open metric balls centered at `x` with positive radii.


theorem Finset.card_pos : ∀ {α : Type u_1} {s : Finset α}, 0 < s.card ↔ s.Nonempty := by sorry

This theorem, `Finset.card_pos`, states that for any type `α` and any finite set `s` of that type, the cardinality (number of elements) of `s` is greater than 0 if and only if `s` is nonempty. In other words, a finite set `s` has a positive number of elements only when it has at least one element.

A finite set is nonempty if and only if it has a positive number of elements.


MeasureTheory.OuterMeasure.ext

theorem MeasureTheory.OuterMeasure.ext :
    ∀ {α : Type u_1} {μ₁ μ₂ : MeasureTheory.OuterMeasure α}, (∀ (s : Set α), ↑μ₁ s = ↑μ₂ s) → μ₁ = μ₂ := by sorry

The theorem `MeasureTheory.OuterMeasure.ext` states that for any given type `α`, if two outer measures `μ₁` and `μ₂` applied to any set `s` of type `α` produce the same result, then `μ₁` and `μ₂` are equal. In other words, two outer measures are considered equal if and only if they yield identical measures for every set of elements of the type `α`.

Two outer measures on a type `α` are equal if and only if they agree on the measure of every set.


theorem Function.Injective.mem_set_image :
    ∀ {α : Type u_1} {β : Type u_2} {f : α → β}, Function.Injective f → ∀ {s : Set α} {a : α}, f a ∈ f '' s ↔ a ∈ s :=
  by sorry

This theorem states that for any types `α` and `β`, and any function `f` from `α` to `β` that is injective, for any set `s` of type `α` and any element `a` of type `α`, the image of `a` under the function `f` is in the image set of `s` under `f` if and only if `a` is in `s`. In other words, an element's image belongs to the image set of given set if and only if the element belongs to the original set, when the function used to form the image set is injective.

For any injective function `f` and sets `s` of type `α`, an element `a` of type `α` belongs to the image set of `s` under `f` if and only if `f(a)` belongs to the image set of `s` under `f`.


theorem CategoryTheory.id_apply :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.ConcreteCategory C] {X : C}
      (x : (CategoryTheory.forget C).obj X), (CategoryTheory.CategoryStruct.id X) x = x :=
  by sorry

This theorem states that for any category `C` which is also a concrete category, and for any object `X` in `C`, the identity morphism applied to an object `x` (which is an object of the "forgotten" version of `X` in the category `C`) results in the same object `x`. In simpler terms, if we "forget" about the category structure of an object by using the forgetful functor and then apply the identity function, we get the original object back. This is an embodiment of the identity law in category theory, which states that the identity morphism for an object leaves the object unchanged.

In any concrete category, the identity morphism of an object, when applied using the forgetful functor, equals the identity of that object.


theorem continuous_norm : ∀ {E : Type u_6} [inst : SeminormedAddGroup E], Continuous fun a => ‖a‖ := by sorry

This theorem states that the norm function is continuous for any given type `E` that forms a seminormed add group. In other words, for any point `a` in `E`, small changes in `a` will result in small changes in its norm `‖a‖`. The continuity of the norm function is a fundamental property used in various branches of mathematics, particularly in analysis and linear algebra.

The norm function is continuous on any seminormed additive group.


theorem forall₂_swap :
    ∀ {ι₁ : Sort u_4} {ι₂ : Sort u_5} {κ₁ : ι₁ → Sort u_2} {κ₂ : ι₂ → Sort u_3}
      {p : (i₁ : ι₁) → κ₁ i₁ → (i₂ : ι₂) → κ₂ i₂ → Prop},
      (∀ (i₁ : ι₁) (j₁ : κ₁ i₁) (i₂ : ι₂) (j₂ : κ₂ i₂), p i₁ j₁ i₂ j₂) ↔
        ∀ (i₂ : ι₂) (j₂ : κ₂ i₂) (i₁ : ι₁) (j₁ : κ₁ i₁), p i₁ j₁ i₂ j₂ :=
  by sorry

This theorem, `forall₂_swap`, states that for any two sorts `ι₁` and `ι₂`, and any two functions `κ₁` and `κ₂` mapping from `ι₁` and `ι₂` respectively to other sorts, and a proposition `p` that relates elements from each sort, the proposition `p` holds for all combinations of elements of `ι₁` and `ι₂` irrespective of the order in which we choose the elements. That is, choosing an element from `ι₁` then `ι₂` is the same as choosing an element from `ι₂` then `ι₁`, as far as the proposition `p` is concerned.

For any sorts `ι₁` and `ι₂` and functions `κ₁ : ι₁ → Sort`, `κ₂ : ι₂ → Sort`, and proposition `p : ∀ i₁ i₂, p (κ₁ i₁) (κ₂ i₂) ↔ p (κ₂ i₂) (κ₁ i₁)`, `p` is a symmetric relation between the images of `κ₁` and `κ₂`.


theorem Set.countable_range :
    ∀ {β : Type v} {ι : Sort x} [inst : Countable ι] (f : ι → β), Set.Countable (Set.range f) := by sorry

The theorem `Set.countable_range` states that for any type `β` and for any sort `ι`, given a countable instance of `ι` and a function `f` from `ι` to `β`, the range of the function `f` is countable. In other words, if we have a countable set, and we apply a function to each element in this set, the set of all possible outputs (the range of the function) is also countable.

Given a countable index set `ι` and a function `f` from `ι` to a type `β`, the range of `f` is countable.


theorem mul_right_inj' :
    ∀ {M₀ : Type u_1} [inst : CancelMonoidWithZero M₀] {a b c : M₀}, a ≠ 0 → (a * b = a * c ↔ b = c) := by sorry

This theorem states that for any type `M₀` which forms a 'Cancel Monoid With Zero', and any elements `a`, `b`, and `c` of this type, if `a` is not zero, then `a` times `b` equals `a` times `c` if and only if `b` equals `c`. In other words, in this type of mathematical structure, multiplication is right-cancellable whenever the left factor is non-zero.

For any type `M₀` with a zero element `0` making it a cancel monoid, and for all `a ≠ 0` in `M₀`, `a * b = a * c` if and only if `b = c`.


/-- An `AddSubgroup` is closed under inverse. -/
theorem AddSubgroup.neg_mem : ∀ {G : Type u_1} [inst : AddGroup G] (H : AddSubgroup G) {x : G}, x ∈ H → -x ∈ H := by
  sorry

This theorem states that for any type `G` that has an `AddGroup` instance and any `AddSubgroup` `H` of `G`, if an element `x` belongs to `H`, then its additive inverse `-x` also belongs to `H`. In other words, an additive subgroup is closed under taking inverses.

If `H` is an additive subgroup of the additive group `G`, then for all `x` in `H`, `-x` is also in `H`.


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

This theorem states that for any given semiring `R`, semiring `S`, polynomial `p` in `R`, ring homomorphism `f` from `R` to `S`, and a variable `x` in `S`, evaluating the polynomial `p` that's been mapped across `f` at `x` is identical to evaluating `p` using the ring hom `f` and variable `x`. In other words, mapping a polynomial across a ring homomorphism and then evaluating it gives the same result as directly evaluating the polynomial with the ring homomorphism and the variable.

For any semiring homomorphism $f$ from semiring $R$ to semiring $S$, polynomial $p$ in $R$[x], and $x$ in $S$, $p^S(x) = p^R(x'\mapsto f(x))$, where $p^S$ and $p^R$ denote the polynomials $p$ evaluated in $S$ and $R$, respectively, and $x'\mapsto f(x)$ denotes the substitution of $x$ with $f(x)$ in $p$.


theorem Finset.map_map :
    ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} (f : α ↪ β) (g : β ↪ γ) (s : Finset α),
      Finset.map g (Finset.map f s) = Finset.map (Function.Embedding.trans f g) s :=
  by sorry

The theorem `Finset.map_map` states that for all types `α`, `β`, and `γ`, with `f` being an embedding from `α` to `β`, `g` being an embedding from `β` to `γ`, and `s` being a finite set in `α`, mapping `s` through `f` and then `g` is equivalent to directly mapping `s` through the composition of `f` and `g`. In other words, the operation of mapping a finite set through two embeddings is associative.

For all finite sets $s : \text{Finset} \ algebra_, \ f : \alpha \rightarrow \beta \ (\text{an embedding}), \ g : \beta \rightarrow \gamma \ (\text{an embedding}), \ \text{we have} \ \text{map} \ (f \circ g) \ s = \text{map} \ g \ (\text{map} \ f \ s)$.


theorem mem_nhdsWithin_of_mem_nhds :
    ∀ {α : Type u_1} [inst : TopologicalSpace α] {s t : Set α} {a : α}, s ∈ nhds a → s ∈ nhdsWithin a t := by sorry

The theorem states that for any type `α` with a topological space structure, and given two sets `s` and `t` of type `α`, and an element `a` of type `α`, if the set `s` is a neighborhood of `a` (i.e., `s` is in the neighborhood filter of `a`), then `s` is also a neighborhood within `t` of `a` (i.e., `s` is in the "neighborhood within" filter of `a` with respect to `t`). This implies that a neighborhood of `a` remains a neighborhood even when considering the intersection of the neighborhood with another set `t`.

Given a topological space `α` and sets `s` and `t` of `α`, if `s` is a neighborhood of an element `a` in `α` and `s` is contained in `t`, then `s` is a neighborhood of `a` within `t`.


theorem CategoryTheory.Functor.mono_of_mono_map :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂}
      [inst_1 : CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor C D)
      [inst_2 : CategoryTheory.Functor.ReflectsMonomorphisms F] {X Y : C} {f : X ⟶ Y},
      CategoryTheory.Mono (F.map f) → CategoryTheory.Mono f :=
  by sorry

This theorem states that in the context of category theory, given two categories `C` and `D`, and a functor `F` from `C` to `D` that reflects monomorphisms, if the map of a morphism `f` from `X` to `Y` in `C` under the functor `F` is a monomorphism in `D`, then `f` itself is a monomorphism in `C`. In other words, if the functor `F` "sees" a morphism as a monomorphism after mapping, then the original morphism is indeed a monomorphism.

Given functors F from category C to D and reflecting monomorphisms, if for any morphism f in C, F(f) is a monomorphism in D, then f is a monomorphism in C.


theorem Set.compl_univ : ∀ {α : Type u}, Set.univᶜ = ∅ := by sorry

This theorem states that the complement of the universal set in any type `α` is the empty set. In other words, there is no element in the type `α` that is not in the universal set, hence the set of all such elements, denoted as the complement of the universal set (`Set.univᶜ`), is indeed the empty set (`∅`). This is a fundamental concept in set theory.

 The complement of the universal set in any type `α` is the empty set.

Mathematically: `Set.univᶜ : ∀ {α : Type}, Set α = ∅`


theorem sdiff_le_iff : ∀ {α : Type u_2} [inst : GeneralizedCoheytingAlgebra α] {a b c : α}, a \ b ≤ c ↔ a ≤ b ⊔ c := by
  sorry

This theorem, `sdiff_le_iff`, states that for any type `α` that is a `GeneralizedCoheytingAlgebra`, and for any elements `a`, `b`, and `c` of type `α`, the statement "the set difference of `a` and `b` is less than or equal to `c`" is equivalent to the statement "`a` is less than or equal to the join of `b` and `c`". In the context of a Generalized Coheyting Algebra, the join operation (`⊔`) is similar to the union operation in set theory, and the set difference operation (`\`) removes elements of the second set from the first.

For any `α` being a `GeneralizedCoheytingAlgebra` and any elements `a`, `b`, and `c` of type `α`, `a \ b ≤ c` if and only if `a ≤ b ⊔ c`.


MeasureTheory.Integrable.neg

theorem MeasureTheory.Integrable.neg :
    ∀ {α : Type u_1} {β : Type u_2} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} [inst : NormedAddCommGroup β]
      {f : α → β}, MeasureTheory.Integrable f μ → MeasureTheory.Integrable (-f) μ :=
  by sorry

The theorem `MeasureTheory.Integrable.neg` states that for any measurable space `α`, any type `β` that forms a normed additive commutative group, any measure `μ` on the space `α`, and any function `f` from `α` to `β`, if `f` is integrable with respect to the measure `μ`, then the function `-f` (the function that maps each element of `α` to the negation of the corresponding element of `β` under `f`) is also integrable with respect to the measure `μ`.

If `μ` is a measure on measurable space `α` and `f` is a integrable function from `α` to a normed additive commutative group `β`, then the function `-f` is also integrable with respect to `μ`.


IsUnit.map

theorem IsUnit.map :
    ∀ {F : Type u_1} {M : Type u_4} {N : Type u_5} [inst : FunLike F M N] [inst_1 : Monoid M] [inst_2 : Monoid N]
      [inst_3 : MonoidHomClass F M N] (f : F) {x : M}, IsUnit x → IsUnit (f x) :=
  by sorry

This theorem states that for any two types `M` and `N` that have `Monoid` structures, and any type `F` that can be treated as a function from `M` to `N` and also satisfies the `MonoidHomClass` typeclass, if an element `x` of `M` is a unit (meaning it has a two-sided inverse in its monoid structure), then the image of `x` under any function `f` of type `F` is also a unit in `N`. Essentially, it states that the property of being a unit is preserved under homomorphisms between monoids.

If `M` and `N` are monoids, `F: M → N` is a monoid homomorphism, and `x` is a unit in `M`, then `F(x)` is a unit in `N`.


theorem CategoryTheory.Limits.biproduct.hom_ext :
    ∀ {J : Type w} {C : Type u} [inst : CategoryTheory.Category.{v, u} C]
      [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] {f : J → C} [inst_2 : CategoryTheory.Limits.HasBiproduct f]
      {Z : C} (g h : Z ⟶ ⨁ f),
      (∀ (j : J),
          CategoryTheory.CategoryStruct.comp g (CategoryTheory.Limits.biproduct.π f j) =
            CategoryTheory.CategoryStruct.comp h (CategoryTheory.Limits.biproduct.π f j)) →
        g = h :=
  by sorry

The theorem `CategoryTheory.Limits.biproduct.hom_ext` states that in the context of a category `C` with zero morphisms and a function `f : J → C` for which a biproduct exists, for any object `Z` in `C` and any two morphisms `g, h : Z ⟶ ⨁ f`, if the composition of `g` and `h` with the projection onto every summand of the biproduct of `f` is the same, then `g` and `h` themselves must be equal. This theorem essentially asserts the uniqueness of morphisms into a biproduct in the category, up to composition with the biproduct's projections.

In a category with zero morphisms, if two morphisms from an object to the biproduct of a function have the same composition with the projections of the biproduct, then they are equal.


theorem tendsto_pi_nhds :
    ∀ {Y : Type v} {ι : Type u_5} {π : ι → Type u_6} [T : (i : ι) → TopologicalSpace (π i)] {f : Y → (i : ι) → π i}
      {g : (i : ι) → π i} {u : Filter Y},
      Filter.Tendsto f u (nhds g) ↔ ∀ (x : ι), Filter.Tendsto (fun i => f i x) u (nhds (g x)) :=
  by sorry

The theorem `tendsto_pi_nhds` states that for any type `Y`, indexing type `ι`, function type `π : ι → Type u_6`, where every `π i` is a topological space, and for any functions `f : Y → (i : ι) → π i` and `g : (i : ι) → π i`, and a filter `u` on `Y`, the function `f` tends to the neighborhood filter of `g` under the filter `u` if and only if, for every index `x` in `ι`, the function `f` composed with the constant function at `x` tends to the neighborhood filter of `g x` under filter `u`.

In essence, this theorem is about continuity of functions into product spaces in topology. It provides a condition for a function to be continuous at a certain point in terms of the function's behavior in each individual coordinate.

For a function between topological spaces and a filter on the domain, the function tends to the neighborhood filter of a point in the codomain under the filter if and only if the composition of the function with the constant function at each index point tends to the neighborhood filter of the corresponding point in the codomain under the filter.


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

The theorem `Primrec.to₂` states that for any types `α`, `β`, and `σ` that are encodable (denoted by `Primcodable α`, `Primcodable β`, and `Primcodable σ`), if a function `f` mapping from a pair of type `α` and `β` to `σ` is primitive recursive (expressed as `Primrec f`), then the corresponding binary function that takes two separate arguments of type `α` and `β` and applies `f` to the pair of them is also primitive recursive (expressed as `Primrec₂ fun a b => f (a, b)`). In other words, this theorem proves that if a function is primitive recursive when applied to a pair, it remains primitive recursive when its arguments are separated.

If `f : α × β → σ` is a primitive recursive function between encodable types, then the corresponding function `g : α → β → σ` defined as `g a b := f (a, b)` is also primitive recursive.


theorem NoZeroSMulDivisors.algebraMap_injective :
    ∀ (R : Type u_1) (A : Type u_2) [inst : CommRing R] [inst_1 : Ring A] [inst_2 : Nontrivial A] [inst_3 : Algebra R A]
      [inst_4 : NoZeroSMulDivisors R A], Function.Injective ⇑(algebraMap R A) :=
  by sorry

This theorem, `NoZeroSMulDivisors.algebraMap_injective`, states that for any types `R` and `A`, where `R` is a commutative ring, `A` is a nontrivial ring and there exists an algebra structure from `R` to `A`, then the function given by the algebra structure (`algebraMap`) from `R` to `A` is injective, provided that there are no zero scalar multiplication divisors in the algebra from `R` to `A`. In other words, if you multiply by any non-zero scalar from `R` in `A`, you get a non-zero result and the mapping from `R` to `A` distinct elements in `R` are mapped to distinct elements in `A`.

Given a commutative ring `R`, a nontrivial ring `A`, and an algebra structure from `R` to `A` with no zero scalar multiplication divisors, the algebra map from `R` to `A` is injective.


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

The theorem `Mathlib.Algebra.Order.Monoid.Lemmas._auxLemma.23` states that for any type `α` that is an additive zero class, has a less-than relation, and satisfies both the covariant and contravariant properties with respect to addition and the less-than relation, for any elements `a` and `b` of type `α`, `a` is less than `a` plus `b` if and only if zero is less than `b`. In other words, the increment of `a` by `b` results in a value greater than `a` if `b` is greater than zero.

For any additive zero class type `α` with a total order relation satisfying covariance and contravariance properties with respect to addition, if `a` is less than `a + b`, then `0` is less than `b`.


theorem CategoryTheory.IsIso.hom_inv_id_assoc :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} (f : X ⟶ Y) [I : CategoryTheory.IsIso f] {Z : C}
      (g : X ⟶ Z),
      CategoryTheory.CategoryStruct.comp f (CategoryTheory.CategoryStruct.comp (CategoryTheory.inv f) g) = g :=
  by sorry

The theorem `CategoryTheory.IsIso.hom_inv_id_assoc` states that for any objects `X`, `Y`, and `Z` in a category `C`, and for any morphism `f` from `X` to `Y` that is an isomorphism, composing `f` with the composition of the inverse of `f` and another morphism `g` from `X` to `Z` is equal to `g`. In other words, (f ⋅ (f⁻¹ ⋅ g)) = g. This can be seen as a generalization of the cancellation property in group theory to the setting of categories.

For any objects X, Y, Z in a category C and isomorphism f from X to Y, f ⋅ (f⁻¹ ⋅ g) = g holds for any morphism g from X to Z.


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

The theorem `inner_neg_right` states that for any two elements `x` and `y` of an inner product space `E` over a scalar field `𝕜` (with `𝕜` being a field that behaves like real or complex numbers and `E` being a normed additive commutative group), the inner product of `x` and the negation of `y` is equal to the negation of the inner product of `x` and `y`. In mathematical notation, this is `⟪x, -y⟫_𝕜 = -⟪x, y⟫_𝕜`.

For any inner product space E over field 𝕜, the inner product of an element x with the negation of another element y is the negative of their inner product, i.e., ⟪x, -y⟫_𝕜 = -⟪x, y⟫_𝕜.


theorem CategoryTheory.MonoidalCategory.id_whiskerLeft :
    ∀ {C : Type u} [𝒞 : CategoryTheory.Category.{v, u} C] [inst : CategoryTheory.MonoidalCategory C] {X Y : C}
      (f : X ⟶ Y),
      CategoryTheory.MonoidalCategory.whiskerLeft (𝟙_ C) f =
        CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategory.leftUnitor X).hom
          (CategoryTheory.CategoryStruct.comp f (CategoryTheory.MonoidalCategory.leftUnitor Y).inv) :=
  by sorry

The theorem `CategoryTheory.MonoidalCategory.id_whiskerLeft` states that for any Category `C` (of type `Type u`) that is a Monoidal Category, and for any two objects `X` and `Y` in `C`, applying the `whiskerLeft` operation to the identity morphism (denoted `𝟙_ C`) and a given morphism `f` from `X` to `Y`, is equivalent to first applying the `hom` part of the `leftUnitor` to `X`, then composing that with the composition of `f` and the inverse (`inv`) of the `hom` part of the `leftUnitor` applied to `Y`. In essence, this theorem is about how the `whiskerLeft` operation interacts with the `leftUnitor` in a monoidal category.

For any Monoidal Category `C`, the composition of the identity morphism with a morphism `f` via whisker composition is equal to the composition of the `hom` part of the left unitor at `X` with `f` followed by the inverse of the `hom` part of the left unitor at `Y`.


IsConnected.isPreconnected

theorem IsConnected.isPreconnected :
    ∀ {α : Type u} [inst : TopologicalSpace α] {s : Set α}, IsConnected s → IsPreconnected s := by sorry

The theorem `IsConnected.isPreconnected` states that for any type `α` that has a topology (i.e., it is a topological space), and any set `s` of this type, if `s` is a connected set, then `s` is also preconnected. In terms of topology, a connected set is one that cannot be partitioned into two non-empty open sets. This theorem, therefore, establishes that if a set fulfills this condition, it also fulfills the conditions to be preconnected, which implies that there is no non-trivial open partition of the set.

If `α` is a topological space and `s` is a connected subset of `α`, then `s` is preconnected.


theorem Set.setOf_forall :
    ∀ {β : Type u_2} {ι : Sort u_4} (p : ι → β → Prop), {x | ∀ (i : ι), p i x} = ⋂ i, {x | p i x} := by sorry

This theorem, `Set.setOf_forall`, states that for any given type `β` and a type-indexed proposition `p` on `β`, the set of all elements `x` in `β` that satisfy the proposition `p` for all types `ι` is equal to the intersection of all sets `{x | p i x}` for each type `ι`. In other words, it represents the logical intersection of sets: any element in the intersection of all sets must satisfy the condition for all sets.

The set of all elements satisfying a type-indexed proposition for all types is equal to the intersection of the sets of elements satisfying the proposition for each type.


theorem Nat.factorial_pos : ∀ (n : ℕ), 0 < Nat.factorial n := by sorry

The theorem `Nat.factorial_pos` states that for every natural number `n`, the factorial of `n`, denoted by `Nat.factorial n`, is always greater than 0. In other words, the factorial function always returns a positive natural number when applied to any natural number.

For every natural number `n`, `Nat.factorial n` is a positive natural number.


theorem le_sub_iff_add_le :
    ∀ {α : Type u} [inst : AddGroup α] [inst_1 : LE α]
      [inst_2 : CovariantClass α α (Function.swap fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] {a b c : α},
      a ≤ c - b ↔ a + b ≤ c :=
  by sorry

This theorem, `le_sub_iff_add_le`, states that for any type `α` that forms an additive group and has a partial order `≤` satisfying certain properties, and for any elements `a`, `b`, `c` of this type, `a` is less than or equal to `c - b` if and only if `a + b` is less than or equal to `c`. In other words, the theorem establishes an equivalence between the condition of `a` being at most `c - b` and the condition of `a + b` being at most `c`. This theorem embodies a fundamental property of ordered additive groups.

For any additive group with partial order `≤` having the property that `a ≤ b` implies `a + c ≤ b + c`, we have `a ≤ c - b` if and only if `a + b ≤ c`.


Unitization.ext

theorem Unitization.ext :
    ∀ {R : Type u_1} {A : Type u_2} {x y : Unitization R A},
      Unitization.fst x = Unitization.fst y → Unitization.snd x = Unitization.snd y → x = y :=
  by sorry

The theorem `Unitization.ext` states that for any types `R` and `A`, and for any elements `x` and `y` of the minimal unitization of a non-unital `R`-algebra `A` (which is a pair consisting of an element from `R` and an element from `A`), if the `R` component (obtained using the `Unitization.fst` function) of `x` equals the `R` component of `y`, and the `A` component (obtained using the `Unitization.snd` function) of `x` equals the `A` component of `y`, then `x` equals `y`. In other words, two elements of the minimal unitization are equal if and only if their corresponding components are equal.

For any non-unital `R`-algebra `A` and its minimal unitization, two elements with equal `R` and `A` components are equal.


/-- **Alias** of `Left.add_pos`. -/
theorem add_pos :
    ∀ {α : Type u_1} [inst : AddZeroClass α] [inst_1 : Preorder α]
      [inst_2 : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x < x_1] {a b : α}, 0 < a → 0 < b → 0 < a + b :=
  by sorry

The `add_pos` theorem states that for any type `α` that is an instance of `AddZeroClass` and `Preorder` and where addition (`+`) is a `CovariantClass`, if `a` and `b` are such that both `a` and `b` are greater than zero (`0`), then the sum of `a` and `b` is also greater than zero. Specifically, if `0 < a` and `0 < b`, then `0 < a + b`. This is an alias of the `Left.add_pos` theorem.

If `α` is a type with `AddZeroClass`, `Preorder`, and covariant addition, and `0 < a` and `0 < b` hold in `α`, then `0 < a + b`.


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

This theorem states that for any type `α` that is a linear ordered semifield, given any three elements `a`, `b`, and `c` of `α` such that `c` is non-negative and `a` is less than or equal to `b`, the value of `a` divided by `c` is less than or equal to `b` divided by `c`.

For all linear ordered semifields α and elements a, b, and c in α with c > 0 and a <= b, we have a / c <= b / c.


theorem Complex.abs_ofReal : ∀ (r : ℝ), Complex.abs ↑r = |r| := by sorry

This theorem states that for any real number `r`, the absolute value of `r`, when treated as a complex number, is equal to the absolute value of `r` in the real number domain. In other words, when we interpret a real number as a complex number and calculate its complex absolute value, we get the same result as if we had just computed the normal absolute value of the real number.

For any real number `r`, the absolute value of `r` as a complex number equals the absolute value of `r` in the real numbers. (abs(r) = abs(complex of r) in Lean 4)


theorem Nat.mul_one : ∀ (n : ℕ), n * 1 = n := by sorry

This theorem, named `Nat.mul_one`, states that for all natural numbers `n`, the product of `n` and 1 is `n` itself. In mathematical notation, this is often written as ∀n ∈ ℕ, n * 1 = n. Essentially, it formalizes the property of the multiplicative identity in natural numbers, which says that any number multiplied by 1 remains unchanged.

For all natural numbers n, n * 1 equals n.


theorem AddUnits.add_neg : ∀ {α : Type u} [inst : AddMonoid α] (a : AddUnits α), ↑a + ↑(-a) = 0 := by sorry

This theorem, `AddUnits.add_neg`, states that for any type `α` that has an addition operation defined on it such that it forms an additive monoid, for any additive unit `a` on `α`, the sum of `a` and its negative counterpart `-a` equals to zero. This essentially proves the property of additivity in a monoid where adding an element with its additive inverse results in the neutral element, in this case 0.

For any additive monoid type `α` with additive unit `a`, `a + (-a) = 0`.


/-- `e.symm` is a left inverse of `e`, written as `e.symm (e y) = y`. -/
theorem AddEquiv.symm_apply_apply :
    ∀ {M : Type u_6} {N : Type u_7} [inst : Add M] [inst_1 : Add N] (e : M ≃+ N) (x : M), (AddEquiv.symm e) (e x) = x :=
  by sorry

The theorem `AddEquiv.symm_apply_apply` states that for any two types `M` and `N` that have addition operations, and any isomorphism `e` between these types, applying `e` to an element of `M` and then applying the inverse of `e` (denoted as `AddEquiv.symm e`) results in the original element of `M`. In other words, the inverse of `e` is a left inverse of `e`, mathematically expressed as `e.symm (e y) = y` for any `y` in `M`.

For any additive type isomorphism `e`: `e.symm (e x) = x` for all `x` in the domain of `e`.


theorem neg_eq_iff_eq_neg : ∀ {G : Type u_3} [inst : InvolutiveNeg G] {a b : G}, -a = b ↔ a = -b := by sorry

This theorem states that for any given type `G` which has an involutive negation property (meaning that negating something twice returns the original thing), the negative of an element `a` from `G` being equal to another element `b` from `G` is logically equivalent to `a` being equal to the negative of `b`.

For any type `G` with an involutive negation and elements `a` and `b` in `G`, `-a = b` is logically equivalent to `a = -b`.


theorem Infinite.of_injective :
    ∀ {α : Sort u_4} {β : Sort u_5} [inst : Infinite β] (f : β → α), Function.Injective f → Infinite α := by sorry

The theorem `Infinite.of_injective` states that for any two types `α` and `β`, if `β` is infinite and there exists an injective function `f` from `β` to `α`, then `α` is also infinite. In other words, if we can map every element of `β` to a unique element of `α` (which is what it means for `f` to be injective) and `β` has infinitely many elements, then `α` must also have infinitely many elements.

If `β` is an infinite type and there exists an injective function from `β` to `α`, then `α` is infinite.


theorem Unique.eq_default : ∀ {α : Sort u_1} [inst : Unique α] (a : α), a = default := by sorry

Given any type α (which is of sort `u_1`) and an instance of `Unique α` (which means that there is exactly one object of type α), the theorem `Unique.eq_default` states that any object `a` of type α is equal to the default object of type α. In other words, for a unique type, any object of that type must be the default object.

For any unique type α, any of its objects is equal to the default object.


theorem mul_mul_mul_comm : ∀ {G : Type u_3} [inst : CommSemigroup G] (a b c d : G), a * b * (c * d) = a * c * (b * d) :=
  by sorry

This theorem, named `mul_mul_mul_comm`, states that for any type `G` that is a commutative semigroup, the sequence of multiplication between four elements `a`, `b`, `c`, and `d` can be rearranged without changing the result. More specifically, multiplying `a` and `b` and then multiplying the result by the product of `c` and `d` (`a * b * (c * d)`) results in the same value as multiplying `a` and `c` and then multiplying the result by the product of `b` and `d` (`a * c * (b * d)`). This property is a generalization of the commutative property of multiplication.

For any commutative semigroup type `G`, the associativity of multiplication holds: `(a * b) * (c * d) = a * (b * c) * d`.


theorem le_of_not_le : ∀ {α : Type u} [inst : LinearOrder α] {a b : α}, ¬a ≤ b → b ≤ a := by sorry

The theorem `le_of_not_le` states that for all types `α` such that `α` has a linear order, for any two elements `a` and `b` of `α`, if it is not the case that `a` is less than or equal to `b`, then `b` is less than or equal to `a`. This theorem is essentially stating the trichotomy property of the linear order, which means that for any two elements in a set, one and only one of the following is true: the first element is less than the second, the first element is equal to the second, or the first element is greater than the second.

If `α` is a type with a linear order and `a` and `b` are elements of `α` with `a` not less than or equal to `b`, then `b` is less than or equal to `a`.


/-- A map that preserves distances is an isometry  -/
theorem Isometry.of_dist_eq :
    ∀ {α : Type u} {β : Type v} [inst : PseudoMetricSpace α] [inst_1 : PseudoMetricSpace β] {f : α → β},
      (∀ (x y : α), dist (f x) (f y) = dist x y) → Isometry f :=
  by sorry

The theorem `Isometry.of_dist_eq` states that for any types `α` and `β` which are pseudometric spaces, a function `f` from `α` to `β` is an isometry if it preserves the distances between all points `x` and `y` in `α`. In other words, if for every pair of elements `(x, y)` in `α`, the distance between `f(x)` and `f(y)` in `β` is equal to the distance between `x` and `y` in `α`, then `f` is an isometry.

If `f: α → β` preserves the distances between all pairs of points in pseudometric spaces `α` and `β`, then `f` is an isometry.


theorem IsClosed.closure_subset_iff :
    ∀ {X : Type u} {s t : Set X} [inst : TopologicalSpace X], IsClosed t → (closure s ⊆ t ↔ s ⊆ t) := by sorry

This theorem states that for any type `X` with a given topological space structure, and any two sets `s` and `t` of type `X`, if `t` is a closed set, then the closure of `s` is a subset of `t` if and only if `s` itself is a subset of `t`. Here, the closure of a set `s` is defined as the smallest closed set containing `s`. Note that `IsClosed t` checks if `t` is a closed set, and `s ⊆ t` checks if all elements of `s` are also in `t`.

For any topological space `(X, τ)` and sets `s` and `t` in `X`, `s ⊆ t` implies the closure of `s` is a subset of `t` if and only if `t` is closed.


theorem Complex.exp_zero : Complex.exp 0 = 1 := by sorry

The theorem `Complex.exp_zero` states that the value of the complex exponential function at zero is equal to one. In other words, it asserts that `exp(0) = 1` in the field of complex numbers, which echoes the familiar rule from real-number calculus.

The complex exponential function evaluates to 1 at 0. (exp(0) = 1 in the complex numbers)


Nat.ModEq.symm

theorem Nat.ModEq.symm : ∀ {n a b : ℕ}, a ≡ b [MOD n] → b ≡ a [MOD n] := by sorry

The theorem `Nat.ModEq.symm` states that for any three natural numbers `n`, `a`, and `b`, if `a` is congruent to `b` modulo `n` (denoted as `a ≡ b [MOD n]`), then `b` is also congruent to `a` modulo `n` (denoted as `b ≡ a [MOD n]`). In other words, the congruence relation modulo `n` is symmetric.

If `a` is congruent to `b` modulo `n`, then `b` is congruent to `a` modulo `n` (i.e., `a ≡ b [MOD n]` implies `b ≡ a [MOD n]`).


theorem Asymptotics.IsBigO_def :
    ∀ {α : Type u_17} {E : Type u_18} {F : Type u_19} [inst : Norm E] [inst_1 : Norm F] (l : Filter α) (f : α → E)
      (g : α → F), f =O[l] g = ∃ c, Asymptotics.IsBigOWith c l f g :=
  by sorry

The theorem `Asymptotics.IsBigO_def` states that for any types `α`, `E`, and `F`, with `E` and `F` having a norm, any filter `l` on `α`, and any two functions `f` and `g` from `α` to `E` and `F` respectively, we have that `f` is Big O of `g` with respect to the filter `l` if and only if there exists a real number `c` such that `f` is eventually bounded by `c * ‖g‖` for the filter `l`. In the mathematical notation, this translates to \(f = O(g)\) if and only if ∃c, `f` is \(O(c \cdot g)\) where the Big O notation denotes that `f` is asymptotically bounded by `g` times a constant factor.

For any types `α`, `E` with `E` having a norm, and functions `f : α -> E` and `g : α -> E` with `g` having a norm, `f` is Big O of `g` with respect to a filter `l` on `α` if and only if there exists a constant `c` such that the absolute values of `f` are eventually bounded by `c` times the norm of `g` for the filter `l`.


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

This theorem, `norm_ne_zero_iff`, states that for any type `E`, that is a normed add group, and any element `a` of this type, the norm of `a` is not equal to zero if and only if `a` is not equal to zero. In other words, in a normed add group, an element has a nonzero norm if and only if the element itself is not zero.

In a normed add group, the norm of an element is nonzero if and only if the element is nonzero.


theorem sub_le_iff_le_add' :
    ∀ {α : Type u} [inst : AddCommGroup α] [inst_1 : LE α]
      [inst_2 : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] {a b c : α}, a - b ≤ c ↔ a ≤ b + c :=
  by sorry

This theorem, `sub_le_iff_le_add'`, states that for any type `α` that forms an additive commutative group and has a less than or equal to (`≤`) relation satisfying the covariant property, given any three elements `a`, `b`, and `c` of this type, the statement "the difference between `a` and `b` is less than or equal to `c`" is equivalent to the statement "`a` is less than or equal to the sum of `b` and `c`". In short, it encapsulates the relationship between subtraction and addition in the context of inequalities.

For any additive commutative group type `α` with covariant `≤` relation, `a ≤ b + c` is equivalent to `a - b ≤ c`.


theorem Nat.prime_of_mem_factors : ∀ {n p : ℕ}, p ∈ Nat.factors n → Nat.Prime p := by sorry

The theorem `Nat.prime_of_mem_factors` states that for any natural numbers `n` and `p`, if `p` is an element in the factorization of `n` (`p` is a factor of `n`), then `p` is a prime number. In other words, all factors of a number `n` obtained using the function `Nat.factors` are prime numbers.

For any natural number `n` and its factor `p`, if `p` is in the factorization of `n` (i.e., `p` divides `n`), then `p` is a prime number.


theorem ENNReal.one_ne_top : 1 ≠ ⊤ := by sorry

This theorem states that the number 1 is not equal to positive infinity (`⊤`) in the extended non-negative real numbers (`ENNReal`). In other words, in the context of the extended non-negative real number system, the real number 1 and positive infinity are distinct entities.

The theorem asserts that 1 and  Positive Infinity (⊤) in the extended non-negative real numbers (ENNReal) are distinct.


MeasureTheory.Filtration.mono

theorem MeasureTheory.Filtration.mono :
    ∀ {Ω : Type u_1} {ι : Type u_3} {m : MeasurableSpace Ω} [inst : Preorder ι] {i j : ι}
      (f : MeasureTheory.Filtration ι m), i ≤ j → ↑f i ≤ ↑f j :=
  by sorry

The theorem `MeasureTheory.Filtration.mono` states that for any measurable space `Ω`, any type `ι` (with a preorder defined on it), and any filtration `f` of `m` indexed by `ι`, for any two indices `i` and `j` from `ι`, if `i` is less than or equal to `j` (i.e., `i ≤ j`), then the measure space at index `i` is a subset of the measure space at index `j` (i.e., `↑f i ≤ ↑f j`). In other words, this theorem is about the monotonocity of filtrations in measure theory, indicating that as we progress through the indexing set `ι` in non-decreasing order, the corresponding measure spaces do not decrease.

For any measurable space and any filtration indexed by a preordered type, the measure space at a smaller index is included in the measure space at a larger index.


theorem MeasureTheory.AEEqFun.aestronglyMeasurable :
    ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] {μ : MeasureTheory.Measure α}
      [inst_1 : TopologicalSpace β] (f : α →ₘ[μ] β), MeasureTheory.AEStronglyMeasurable (↑f) μ :=
  by sorry

This theorem states that for any measure space `α` and topological space `β`, given a measure `μ` on `α` and a function `f` from `α` to `β` that is almost everywhere equal with respect to `μ`, this function `f` is also almost everywhere strongly measurable with respect to `μ`. In other words, the function `f` is almost everywhere equivalent to some strongly measurable function.

If `α` is a measure space, `β` is a topological space, `μ` is a measure on `α`, and `f: α → β` is almost everywhere equal to some strongly measurable function, then `f` is almost everywhere strongly measurable with respect to `μ`.


theorem Nat.minFac_prime : ∀ {n : ℕ}, n ≠ 1 → Nat.Prime (Nat.minFac n) := by sorry

The theorem `Nat.minFac_prime` states that for any natural number `n` that is not equal to 1, the smallest prime factor of `n`, as determined by the `Nat.minFac` function, is indeed a prime number, as defined by the `Nat.Prime` property. In other words, the `Nat.minFac` function always returns a prime number, provided that the input is not 1.

For any natural number `n` not equal to 1, the prime number returned by `Nat.minFac` is indeed a prime factor of `n`.


theorem Ordinal.pos_iff_ne_zero : ∀ {o : Ordinal.{u_3}}, 0 < o ↔ o ≠ 0 := by sorry

The theorem `Ordinal.pos_iff_ne_zero` states that for any ordinal `o`, `o` is greater than zero if and only if `o` is not equal to zero. In other words, an ordinal number is positive if and only if it is not the zero ordinal. This theorem provides a characterization of positive ordinals in terms of non-zero ordinals.

An ordinal is positive if and only if it is different from the zero ordinal.


Exists.snd

theorem Exists.snd : ∀ {b : Prop} {p : b → Prop} (h : Exists p), p ⋯ := by sorry

This theorem, `Exists.snd`, states that for every property `p` dependent on a proposition `b` and for any proof `h` that there exists some element satisfying the property `p`, the property `p` holds true. In terms of logic, it's stating that if there is an existence proof of a particular property, then that property is indeed valid.

If there exists an element with property `p` in a proposition `b`, then `p` holds for that element.


theorem isClosed_univ : ∀ {X : Type u} [inst : TopologicalSpace X], IsClosed Set.univ := by sorry

This theorem states that for any type `X` equipped with a topology (that is, `X` is taken to be a topological space), the universal set (i.e., the set containing all elements of `X`) is a closed set. In mathematical terms, this represents the universally true fact that in any given topological space, the entire space itself is always considered a closed set.

In any topological space, the universal set is closed.


/-- Negating the orientation negates the value of `oangle`.  -/
theorem Orientation.oangle_neg_orientation_eq_neg :
    ∀ {V : Type u_1} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V]
      [inst_2 : Fact (FiniteDimensional.finrank ℝ V = 2)] (o : Orientation ℝ V (Fin 2)) (x y : V),
      Orientation.oangle (-o) x y = -Orientation.oangle o x y :=
  by sorry

This theorem states that for any orientation `o`, and any vectors `x` and `y` in a two-dimensional real inner product space `V`, the oriented angle from `x` to `y` under the negation of `o` is the negation of the oriented angle from `x` to `y` under `o`. In other words, negating the orientation effectively reverses the direction in which angles are measured.

For any orientation `o` and vectors `x` and `y` in a 2-dimensional real inner product space, the oriented angle from `x` to `y` under the negation of `o` is the negation of the oriented angle from `x` to `y` under `o`.


theorem interior_maximal :
    ∀ {X : Type u} {s t : Set X} [inst : TopologicalSpace X], t ⊆ s → IsOpen t → t ⊆ interior s := by sorry

The theorem `interior_maximal` states that for any Type `X` and any two sets `s` and `t` of type `X`, given a topology on `X`, if `t` is a subset of `s` and `t` is an open set, then `t` must be a subset of the interior of `s`. In terms of topology, this theorem is saying that the interior of a set is the largest open subset, meaning that any open subset of a set is contained within the interior of that set.

If `s` is a set in a topological space `X` and `t` is an open subset of `s`, then `t` is a subset of the interior of `s`.


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

This theorem states that for any type `α` with a preorder and a locally finite order, and any two elements `a` and `b` of `α`, the finset of elements `x` such that `a < x` and `x < b` (denoted by `Finset.Ioo a b`) is equivalent to the set of elements `x` in `α` that are strictly greater than `a` and strictly less than `b` (denoted by `Set.Ioo a b`). In other words, the coercion of `Finset.Ioo a b` to a set gives us `Set.Ioo a b`.

For any type `α` with a preorder and a locally finite order, the set of elements strictly between `a` and `b` equals the finite set of elements strictly less than `b` and strictly greater than `a`.


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

This theorem, `Nat.lt_of_succ_lt_succ`, asserts that for any two natural numbers 'n' and 'm', if the successor of 'n' is less than the successor of 'm', then 'n' is less than 'm'. In mathematical terms, this theorem expresses the property that if `n+1 < m+1`, then it must be that `n < m`. It's a basic property of the natural numbers under the order relation.

If `n+1 < m+1` implies `n < m` for natural numbers `n` and `m`.


theorem Set.biUnion_of_singleton : ∀ {α : Type u_1} (s : Set α), ⋃ x ∈ s, {x} = s := by sorry

The theorem `Set.biUnion_of_singleton` states that for any set `s` of an arbitrary type `α`, the union over all elements `x` in the set `s` of the singleton sets containing `x` is equal to the set `s` itself. In more mathematical terms, for any set `s`, if you take every element `x` in `s`, form the singleton set `{x}`, and then take the union of all these singleton sets, you get back the original set `s`.

For any set `s`, the union of the singleton sets `{x}` for all `x` in `s` equals `s`.


theorem Nat.prime_two : Nat.Prime 2 := by sorry

The theorem `Nat.prime_two` asserts that the number 2 is a prime number. In the context of natural numbers, a prime number is defined as a natural number greater than or equal to 2 whose only divisors are itself and 1. Therefore, this theorem is confirming that 2, which is divisible only by itself and 1, satisfies this property and is therefore a prime number.

The theorem `Nat.prime_two` asserts that 2 is a prime number in the natural numbers, i.e., it is a natural number greater than 1 that has no divisors other than 1 and itself.


theorem Polynomial.monic_X_sub_C :
    ∀ {R : Type u} [inst : Ring R] (x : R), Polynomial.Monic (Polynomial.X - Polynomial.C x) := by sorry

The theorem `Polynomial.monic_X_sub_C` states that for any type `R` equipped with a ring structure (denoted by `inst : Ring R`) and for any element `x` in `R`, the polynomial `X - Cx` (representing the polynomial with variable `X` minus the constant polynomial of `x`) is monic. In mathematical terms, the leading coefficient of the polynomial `X - Cx` is always 1, irrespective of the ring `R` and the element `x` in `R`.

For any ring `R` and element `x` in `R`, the polynomial `X - Cx` is monic (has a leading coefficient of 1).


theorem Finset.univ_unique : ∀ {α : Type u_1} [inst : Fintype α] [inst_1 : Unique α], Finset.univ = {default} := by
  sorry

The theorem `Finset.univ_unique` states that for any type `α` which is a finite type (`Fintype α`) and also has a unique element (`Unique α`), the universal finite set of type `α` (denoted by `Finset.univ`) is a set containing only the default element of `α`. In other words, if there's exactly one element in the type, then the universal finite set of that type consists solely of that unique element.

If `α` is a finite type with a unique element, then `Finset.univ` is the singleton set containing that unique element.


Computable.comp

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

The theorem `Computable.comp` states that for any three types `α`, `β`, and `σ`, given that they are `Primcodable` (which means there exists a primitive recursive encoding of these types), if a function `f` from `β` to `σ` is computable and a function `g` from `α` to `β` is also computable, then the composition of these two functions, represented as `f(g(a))`, is also computable. This composition means applying function `g` to `a` first, and then applying function `f` to the result. This theorem embodies the property of closure under composition for computable functions.

If `f` is a computable function from `β` to `σ` and `g` is a computable function from `α` to `β`, then the composition `f ∘ g` from `α` to `σ` is also computable.


theorem Matrix.mul_one :
    ∀ {m : Type u_2} {n : Type u_3} {α : Type v} [inst : NonAssocSemiring α] [inst_1 : Fintype n]
      [inst_2 : DecidableEq n] (M : Matrix m n α), M * 1 = M :=
  by sorry

The theorem `Matrix.mul_one` asserts that for any types `m` and `n`, and any type `α` of a non-associative semiring, given the conditions that `n` has both a finite type and decidable equality, then multiplication of any matrix `M` (which has its rows indexed by `m`, columns indexed by `n`, and entries in `α`) by the identity matrix gives back the original matrix `M`. In mathematical terms, it states that for any matrix `M`, we have `M * I = M`, where `I` is the identity matrix.

For any matrix `M` with type `m × n` over a non-associative semiring `α` with finite type and decidable equality, `M` multiplied by the identity matrix `I` of the same size results in `M` itself. In Lean notation: `(M : matrix α m n) → M * I = M`.


theorem exists_rat_btwn :
    ∀ {α : Type u_1} [inst : LinearOrderedField α] [inst_1 : Archimedean α] {x y : α}, x < y → ∃ q, x < ↑q ∧ ↑q < y :=
  by sorry

This theorem states that for any given type `α` that has an instance of a Linear Ordered Field and Archimedean property, and for any two elements `x` and `y` of this type such that `x` is less than `y`, there exists a rational number `q` such that `q` is greater than `x` and less than `y`. Essentially, it asserts that there's always a rational number between any two distinct elements of a type that behaves as a linearly ordered field and that also has the Archimedean property.

For any linearly ordered field `α` with the Archimedean property, given `x` and `y` in `α` with `x < y`, there exists a rational number `q` such that `x < q < y`.


theorem Disjoint.eq_bot :
    ∀ {α : Type u_1} [inst : SemilatticeInf α] [inst_1 : OrderBot α] {a b : α}, Disjoint a b → a ⊓ b = ⊥ := by sorry

The theorem `Disjoint.eq_bot` states that for any type `α` that forms a semilattice with an infimum operation and has a bottom element, if two elements `a` and `b` of `α` are disjoint (meaning that any element `x` that is less than or equal to both `a` and `b` is also less than or equal to the bottom element), then the infimum of `a` and `b` is the bottom element. In mathematical terms, if `a` and `b` are disjoint in a semilattice, then their greatest lower bound (their infimum) is the smallest element of the lattice.

In a semilattice with a bottom element, if `a` and `b` are disjoint elements, then their infimum is the bottom element.


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

This theorem, `sInf_image`, states that for any types `α` and `β`, given `α` is a complete lattice, for any set `s` of type `β`, and any function `f` mapping elements of `β` to `α`, the infimum (the greatest lower bound) of the image of `s` under `f` (represented as `f '' s`) is equal to the infimum of `f a` for each element `a` in `s`. In mathematical terms, this theorem expresses that $\inf \{f(a) | a \in s\} = \inf_{a \in s} f(a)$.

The infimum of the image of a set under a function equals the infimum of the function values on the set.


theorem Mathlib.Data.Finset.Basic._auxLemma.118 : ∀ {a b c : Prop}, (a ∧ b ∨ a ∧ c) = (a ∧ (b ∨ c)) := by sorry

This theorem, `Mathlib.Data.Finset.Basic._auxLemma.118`, states that for any three propositions `a`, `b`, and `c`, the relation `(a ∧ b ∨ a ∧ c) = (a ∧ (b ∨ c))` holds true. This theorem illustrates a property of logical operations where the conjunction (`∧`, logical "and") of a proposition `a` with either `b` or `c` (denoted by `b ∨ c`, logical "or") is equivalent to the disjunction (`∨`) of the conjunction of `a` with `b` and `a` with `c` (`a ∧ b ∨ a ∧ c`). Essentially, it showcases the distributive law of logic.

The theorem `Mathlib.Data.Finset.Basic._auxLemma.118` in Lean 4 states that `(a ∧ (b ∨ c)) = (a ∧ b ∨ a ∧ c)` for any propositions `a`, `b`, and `c`, which expresses the distributive property of logical conjunction over logical disjunction.


theorem Finset.coe_mul :
    ∀ {α : Type u_2} [inst : DecidableEq α] [inst_1 : Mul α] (s t : Finset α), ↑(s * t) = ↑s * ↑t := by sorry

This theorem, named `Finset.coe_mul`, states that for any type `α` which has decidable equality and a multiplication operation, given two finite sets `s` and `t` of type `α`, the set of all products of elements from `s` and `t` (expressed as `s * t`) is equal to the Cartesian product of `s` and `t` (expressed as `↑s * ↑t`). Here `↑s` and `↑t` represent the conversion (coercion) of the finsets `s` and `t` to sets of `α`. In other words, the theorem shows that multiplication of two finite sets is equivalent to the Cartesian product of the sets when the sets are considered as sets of a type with multiplication.

For any type `α` with decidable equality and multiplication, the finite sets `s` and `t` of `α` have equal elements when regarded as sets, i.e., `s * t` (the set of products) is equivalent to `↑s * ↑t` (the Cartesian product).


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

The theorem `Real.rpow_def_of_pos` states that for any real number `x` that is greater than zero, and for any other real number `y`, the exponentiation of `x` to the power of `y` is equal to the real exponential function of the product of the real logarithm of `x` and `y`. In mathematical terms, this means for all `x > 0` and any `y`, we have `x^y = exp(log(x) * y)`.

For all `x > 0` in the real numbers, `x^y` equals the exponential function `exp(log(x) * y)`.


theorem PowerSeries.coeff_mk :
    ∀ {R : Type u_1} [inst : Semiring R] (n : ℕ) (f : ℕ → R), (PowerSeries.coeff R n) (PowerSeries.mk f) = f n := by
  sorry

The theorem `PowerSeries.coeff_mk` states that for any semiring `R`, any natural number `n`, and any function `f` from natural numbers to `R`, the `n`th coefficient of the formal power series constructed using function `f` is `f(n)`. This simply means that the power series created with `f` as the coefficient generating function accurately reflects the coefficients specified by `f`.

For any semiring R, natural number n, and function f from natural numbers to R, the n-th coefficient of the power series formed from f is f(n).


theorem sup_bot_eq : ∀ {α : Type u} [inst : SemilatticeSup α] [inst_1 : OrderBot α] (a : α), a ⊔ ⊥ = a := by sorry

This theorem states that for any type `α` that is a semilattice with a supremum operation and has a least element `⊥`, the supremum of any element `a` of `α` and `⊥` is equal to `a`. This essentially means that the least element `⊥` does not affect the supremum operation, confirming the property of `⊥` as the least element in the ordered set.

For any semilattice `α` with a least element `⊥`, the supremum of any element `a` in `α` and `⊥` is equal to `a`.


theorem Finset.filter_subset :
    ∀ {α : Type u_1} (p : α → Prop) [inst : DecidablePred p] (s : Finset α), Finset.filter p s ⊆ s := by sorry

This theorem states that for any type `α`, any decidable predicate `p` on `α`, and any finite set `s` of type `α`, the set of elements in `s` that satisfy the predicate `p` (denoted as `Finset.filter p s`) is a subset of `s`. In other words, filtering a finite set by a predicate cannot produce new elements that were not in the original set.

For any type `α`, decidable predicate `p` on `α`, and finite set `s` of type `α`, `Finset.filter p s` is a subset of `s`.


Filter.Tendsto.mul

theorem Filter.Tendsto.mul :
    ∀ {α : Type u_2} {M : Type u_3} [inst : TopologicalSpace M] [inst_1 : Mul M] [inst_2 : ContinuousMul M]
      {f g : α → M} {x : Filter α} {a b : M},
      Filter.Tendsto f x (nhds a) →
        Filter.Tendsto g x (nhds b) → Filter.Tendsto (fun x => f x * g x) x (nhds (a * b)) :=
  by sorry

The theorem `Filter.Tendsto.mul` states that for any given type `α`, type `M` (which is assumed to be a topological space with a multiplication operation and continuous multiplication), functions `f` and `g` from `α` to `M`, filter `x` on `α`, and elements `a` and `b` of `M`, if the function `f` tends towards the neighborhood of `a` under the filter `x` and the function `g` tends towards the neighborhood of `b` under the same filter `x`, then the function that maps `x` to the product of `f(x)` and `g(x)` tends towards the neighborhood of the product `a * b` under the filter `x`. This theorem is basically asserting the continuity of multiplication in a topological space.

Given topological spaces `α` with continuous multiplication `M`, if functions `f` and `g` from `α` to `M` tend to `a` and `b` respectively under filter `x`, then their product function `x mapsto f x * g x` tends to `a * b` under filter `x`.


theorem HomologicalComplex.dTo_comp_dFrom :
    ∀ {ι : Type u_1} {V : Type u} [inst : CategoryTheory.Category.{v, u} V]
      [inst_1 : CategoryTheory.Limits.HasZeroMorphisms V] {c : ComplexShape ι} (C : HomologicalComplex V c) (j : ι),
      CategoryTheory.CategoryStruct.comp (HomologicalComplex.dTo C j) (HomologicalComplex.dFrom C j) = 0 :=
  by sorry

The theorem `HomologicalComplex.dTo_comp_dFrom` states that for any type `ι`, type `V` which is a category with zero morphisms, and complex shape `c`, for any homological complex `C` of type `V` with shape `c` and any `j` of type `ι`, the composition of the differential mapping into `C.X j` and the differential mapping out of `C.X j` (denoted as `HomologicalComplex.dTo C j` and `HomologicalComplex.dFrom C j` respectively in Lean 4) is equal to zero. This is a principle in homological algebra that the differential mappings in a chain complex compose to zero, which is encoded in Lean 4 in this theorem.

For any homological complex in a category with zero morphisms, the composition of the differential mappings from and into any complex degree is zero.


theorem Set.iUnion_eq_univ_iff :
    ∀ {α : Type u_1} {ι : Sort u_4} {f : ι → Set α}, ⋃ i, f i = Set.univ ↔ ∀ (x : α), ∃ i, x ∈ f i := by sorry

This theorem states that for any type `α` and any indexing type `ι`, if you have a function `f` that maps from the indexing type to a set of the type `α`, then the union of all the sets `f i` (for all `i` in `ι`) equals the universal set of `α` if and only if for every element `x` of type `α`, there exists an index `i` such that `x` is an element of the set `f i`. In terms of set theory, this is saying that the union of a collection of sets covers the entire universal set if and only if every element in the universe is in at least one of the sets in the collection.

Given a function from an indexing type to sets of a type `α`, the union of these sets equals the universal set of `α` if and only if every element of `α` is in some image set.


theorem iff_true_intro : ∀ {a : Prop}, a → (a ↔ True) := by sorry

This theorem, "iff_true_intro", states that for any proposition 'a', if 'a' is true, then 'a' is logically equivalent to 'True'. In other words, if we have a proof of 'a', we can conclude that 'a' is both true and that 'True' implies 'a'. This theorem is a fundamental concept in propositional logic and a basic tool in the Lean 4 theorem prover.

If a proposition 'a' is true, then 'a' is logically equivalent to 'True'.


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

This theorem states that for any commutative semiring `R` and semiring `A`, given an `R`-algebra structure on `A` and any element `x` of `A`, the algebra homomorphism from the polynomial ring `R[X]` to `A` generated by evaluating `X` at `x` (as defined by `Polynomial.aeval`) sends the polynomial `X` (the polynomial indeterminate or variable) to `x`. In other words, applying this homomorphism to the polynomial `X` gives back the original `x` in `A` that was used to create the homomorphism. This theorem captures the intuition that a polynomial evaluation at a certain point replaces the variable of the polynomial with the point of evaluation.

For any commutative semiring `R`, semiring `A`, `R`-algebra structure on `A`, and element `x` in `A`, the algebra homomorphism from `R[X]` to `A` generated by evaluating `X` at `x` maps the polynomial indeterminate `X` to `x`.


theorem Int.ofNat_le : ∀ {m n : ℕ}, ↑m ≤ ↑n ↔ m ≤ n := by sorry

This theorem, `Int.ofNat_le`, states that for all natural numbers `m` and `n`, the statement "the integer representation of `m` is less than or equal to the integer representation of `n`" is equivalent to " `m` is less than or equal to `n`". In other words, it specifies the order preservation property under the natural number to integer mapping.

The theorem `Int.ofNat_le` asserts that for all natural numbers `m` and `n`, `m ≤ n` if and only if `Int.ofNat m ≤ Int.ofNat n`.


theorem sub_ne_zero : ∀ {G : Type u_3} [inst : AddGroup G] {a b : G}, a - b ≠ 0 ↔ a ≠ b := by sorry

This theorem, `sub_ne_zero`, states that for any type `G` that is an additive group, the difference between any two elements `a` and `b` of `G` is not equal to zero if and only if `a` is not equal to `b`. In other words, within any additive group, if two elements are not equal, their difference won't be zero and conversely, if their difference is non-zero, the two elements are distinct.

For any additive group G and all elements a, b in G, a ≠ b if and only if a - b ≠ 0.


theorem Set.image_eq_range :
    ∀ {α : Type u_1} {β : Type u_2} (f : α → β) (s : Set α), f '' s = Set.range fun x => f ↑x := by sorry

The theorem `Set.image_eq_range` states that for any two types `α` and `β`, any function `f` from `α` to `β`, and any set `s` of type `α`, the image of `s` under `f` is equal to the range of the function that maps each element `x` in `s` to `f` applied to `x`. In more mathematical terms, it says that the set of all values `f(x)` for `x` in `s` is the same as the set of all possible outputs of the function `f` where the domain is restricted to `s`.

For any function `f` from type `α` to type `β` and any set `s` of type `α`, the image of `s` under `f` equals the range of the function `x ↔→ f x`.


theorem List.length_reverse : ∀ {α : Type u} (as : List α), List.length (List.reverse as) = List.length as := by sorry

This theorem states that for any list of elements of any type, the length of the list remains the same even after it is reversed. More formally, for all types `α` and for any list `as` of type `α`, the length of the list `as` after it is reversed using the function `List.reverse` is equal to the original length of the list `as`. This is denoted in LaTeX as, for any list $\text{as}$, $\text{List.length}(\text{List.reverse(as)}) = \text{List.length(as)}$.

For any list `as` of type `α`, the length of the reversed list `List.reverse as` is equal to the original length of `as`. In mathematical notation, `List.length (List.reverse as) = List.length as`.


theorem MeasureTheory.lintegral_mono :
    ∀ {α : Type u_1} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} ⦃f g : α → ENNReal⦄,
      f ≤ g → ∫⁻ (a : α), f a ∂μ ≤ ∫⁻ (a : α), g a ∂μ :=
  by sorry

The `MeasureTheory.lintegral_mono` theorem states that, for any type `α`, any measurable space `m` over `α`, any measure `μ` on that measurable space, and any two functions `f` and `g` from `α` to the extended non-negative real numbers (`ENNReal`), if `f` is less than or equal to `g` (i.e., `f` is pointwise less than or equal to `g`), then the Lebesgue integral (`∫⁻`) of `f` with respect to `μ` is less than or equal to the Lebesgue integral of `g` with respect to `μ`. This theorem formalizes the idea that, in measure theory, the integral of a function is monotonic with respect to pointwise order.

If `α` is a type, `m` is a measurable space over `α`, `μ` is a measure on `m`, `f` and `g` are functions from `α` to the extended non-negative real numbers, and `f ≤ g` pointwise, then `∫⁻ f dμ ≤ ∫⁻ g dμ`.


theorem MeasureTheory.Measure.map_map :
    ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {m0 : MeasurableSpace α} [inst : MeasurableSpace β]
      [inst_1 : MeasurableSpace γ] {μ : MeasureTheory.Measure α} {g : β → γ} {f : α → β},
      Measurable g →
        Measurable f →
          MeasureTheory.Measure.map g (MeasureTheory.Measure.map f μ) = MeasureTheory.Measure.map (g ∘ f) μ :=
  by sorry

This theorem states that for any three types `α`, `β`, and `γ` with associated measurable spaces, and any measure `μ` on the type `α`, if we have two measurable functions `f` from `α` to `β` and `g` from `β` to `γ`, then the pushforward measure obtained by first mapping `μ` through `f` and then through `g` is the same as the pushforward measure obtained by mapping `μ` through the composition of `g` and `f`. In other words, the operation of taking pushforward measures commutes with the operation of composing functions. This is often referred to as the change of variables theorem in measure theory.

Given measurable spaces `(α, Σα)`, `(β, Σβ)`, `(γ, Σγ)`, measures `μ` on `α`, and measurable functions `f: α → β` and `g: β → γ`, the pushforwards `f._measure_theory_.Pushforward μ f` and `g._measure_theory_.Pushforward (f._measure_theory_.Pushforward μ f) g` are equal.


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

This theorem states that for all natural numbers 'a' and 'b', if 'a' is not equal to 'b', then 'a' is either less than 'b' or 'a' is greater than 'b'. It captures a fundamental property of natural numbers, where two distinct numbers must have an order relation where one is less than the other.

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


/-- Constants are `C^∞`.
 -/
theorem contDiff_const :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type uE} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {F : Type uF} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {n : ℕ∞}
      {c : F}, ContDiff 𝕜 n fun x => c :=
  by sorry

This theorem states that for any nontrivially normed field `𝕜`, normed addative commutative group `E` and `F`, and any constant `c` of type `F`, the function that maps any element of `E` to `c` is continuously differentiable of any order `n`, denoted as `ContDiff 𝕜 n`. In other words, constants are infinitely differentiable (`C^∞`).

For any nontrivially normed field `𝕜`, any normed additive commutative group `E`, and any constant `c` in `𝕜`, the constant function mapping `E` to `c` is infinitely differentiable.


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

This theorem, `abs_of_nonpos`, states that for any type `α` that is a lattice and an additive group, and any element `a` of type `α`, if `a` is less than or equal to zero and the type `α` has a certain covariance property for addition and comparison, then the absolute value of `a` is equal to the negation of `a`. In mathematical terms, if `a ≤ 0`, then `|a| = -a`.

For any lattice and additive group type `α`, if its additive and order structures have covariance property and `a` is an element of `α` with `a ≤ 0`, then `|a| = -a`.


theorem neg_injective : ∀ {G : Type u_3} [inst : InvolutiveNeg G], Function.Injective Neg.neg := by sorry

The theorem `neg_injective` states that for any type `G` that has the property of `InvolutiveNeg`, the minus or negation function (`Neg.neg`) is injective. In other words, if applying the negation function to two elements of `G` results in the same value, it implies that those two elements were originally the same. This is equivalent to saying that the negation function has the property that it never maps different elements to the same element.

For any type `G` with the `InvolutiveNeg` property, the negation function `Neg.neg` is a bijection (i.e., both injective and surjective). Specifically, it is injective as stated in the theorem.


theorem Set.insert_subset_iff : ∀ {α : Type u} {a : α} {s t : Set α}, insert a s ⊆ t ↔ a ∈ t ∧ s ⊆ t := by sorry

The theorem `Set.insert_subset_iff` asserts that for all types `α`, all elements `a` of type `α`, and all sets `s` and `t` of type `α`, the set resulting from the insertion of `a` into `s` is a subset of `t` if and only if `a` is an element of `t` and `s` is a subset of `t`. In other words, adding an element to a set preserves the subset relation if and only if the added element is also contained in the larger set.

For all types α, sets s and t of α, and element a of α, the set {a} ∪ s is a subset of t if and only if a ∈ t and s ⊆ t.


theorem measurableSet_Ioc :
    ∀ {α : Type u_1} [inst : TopologicalSpace α] [inst_1 : MeasurableSpace α] [inst_2 : OpensMeasurableSpace α]
      [inst_3 : LinearOrder α] [inst : OrderClosedTopology α] {a b : α}, MeasurableSet (Set.Ioc a b) :=
  by sorry

The theorem `measurableSet_Ioc` states that for any given type `α` equipped with a topology, a measure space, a linear order, and an order closed topology, for any two elements `a` and `b` of type `α`, the left-open right-closed interval `Set.Ioc a b` is a measurable set. In other words, the set of all elements `x` of type `α` which are strictly greater than `a` and less than or equal to `b` is measurable in the measure space on `α`.

For any type `α` with a measure space, topology, linear order, and order-closed topology, the left-open right-closed interval `Set.Ioc a b` is a measurable subset of `α` for all `a < b` in `α`.


theorem neg_nonpos_of_nonneg : ∀ {α : Type u} [inst : OrderedAddCommGroup α] {a : α}, 0 ≤ a → -a ≤ 0 := by sorry

This theorem, `neg_nonpos_of_nonneg`, states that for all types `α` that form an ordered additive commutative group, if a given element `a` of type `α` is non-negative (i.e., `a` is greater than or equal to 0), then the negation of `a` (denoted as `-a`) is less than or equal to 0. In other words, if a number is non-negative, its negative counterpart will be non-positive.

For all additive, commutative groups with ordering `α`, if `a` is non-negative then `-a` is non-positive.


theorem isClosed_iInter :
    ∀ {X : Type u} {ι : Sort w} [inst : TopologicalSpace X] {f : ι → Set X},
      (∀ (i : ι), IsClosed (f i)) → IsClosed (⋂ i, f i) :=
  by sorry

This theorem, named `isClosed_iInter`, states that for any type `X` with a topology, and any indexed collection of sets `{f : ι → Set X}`, if each set `f i` is closed, then the intersection of all these sets (denoted by `⋂ i, f i`) is also closed. In the context of topology, a set is said to be closed if its complement is an open set. The indexed collection is represented by a function `f` from the index set `ι` to the set of subsets of `X`. This theorem generalizes the idea that the intersection of a finite number of closed sets is also closed, to possibly infinite collections of closed sets.

If `X` is a topological space and `f : ι → Set X` is a family of closed sets, then the intersection `⋂ i, f i` is also closed.


theorem ContinuousMap.coe_mul :
    ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] [inst_2 : Mul β]
      [inst_3 : ContinuousMul β] (f g : C(α, β)), ⇑(f * g) = ⇑f * ⇑g :=
  by sorry

This theorem states that for any two continuous maps `f` and `g` from a topological space `α` to a topological space `β` that is also a multiplication space with continuous multiplication, the multiplication of the two continuous maps (`f * g`) is equal to the pointwise multiplication of the functions (`⇑f * ⇑g`). In other words, multiplication of continuous maps in the sense of the algebra of continuous functions corresponds directly to pointwise multiplication of the functions.

For any continuous functions `f` and `g` from a topological space to a topological multiplication space, `f * g` equals the pointwise multiplication `⇑f * ⇑g` of their functions.


theorem Set.finite_range : ∀ {α : Type u} {ι : Sort w} (f : ι → α) [inst : Finite ι], Set.Finite (Set.range f) := by
  sorry

The theorem `Set.finite_range` states that for all types `α` and `ι`, given a function `f` from `ι` to `α` and assuming that `ι` is finite (`inst : Finite ι`), the range of `f` is also finite. In other words, if the domain of a function is finite, then the set of all output values (the range) of the function is also finite.

If `ι` is a finite type, then the range of a function `f : ι → α` is a finite set.


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

This theorem states that for any type `α`, any index type `ι`, any dependent type `κ` indexed by `ι`, any family of sets `s` indexed by `ι` and `κ`, and any set `t` of type `α`, if each set `s i j` (for all `i` in `ι` and `j` in `κ i`) is a subset of `t`, then the union over all `i` and `j` of the sets `s i j` is also a subset of `t`. In mathematical terms, if $\forall i \in \text{index set } \text{I}, \forall j \in \text{dependent type } \text{K}_i, s_{i,j} \subseteq t$, then $\bigcup_{i \in \text{I}} \bigcup_{j \in \text{K}_i} s_{i,j} \subseteq t$.

If for each index `i` in an index set and each index `j` in the dependent type indexed by `i`, the set `s i j` is a subset of a given set `t`, then the union over all `i` and `j` of `s i j` is also a subset of `t`.