theorem UniqueProds.of_injective_mulHom :
    ∀ {G : Type u} {H : Type v} [inst : Mul G] [inst_1 : Mul H] (f : H →ₙ* G),
      Function.Injective ⇑f → UniqueProds G → UniqueProds H :=
  by sorry

The theorem `UniqueProds.of_injective_mulHom` states that for any two types `G` and `H` that have multiplication (`Mul`) defined, if there is a multiplication-preserving function `f` from `H` to `G` (denoted as `f : H →ₙ* G`) that is injective (meaning that equal outputs imply equal inputs), then the property of having unique products (denoted as `UniqueProds`) is preserved from `G` to `H`. In other words, if `G` has unique products and we have an injective multiplication-preserving function from `H` to `G`, then `H` also has unique products.

If `G` and `H` are types with multiplication, `f : H → G` is an injective multiplication-preserving function, and `G` has unique products, then `H` also has unique products.


theorem List.exists_of_mem_map :
    ∀ {α : Type u_1} {b : α} {α_1 : Type u_2} {f : α_1 → α} {l : List α_1}, b ∈ List.map f l → ∃ a ∈ l, f a = b := by
  sorry

This theorem, `List.exists_of_mem_map`, states that for any types `α` and `α_1`, any function `f` from `α_1` to `α`, any list `l` of elements of type `α_1`, and any element `b` of type `α`, if `b` is an element of the list that results from mapping `f` over `l`, then there exists an element `a` in `l` such that applying `f` to `a` yields `b`. In other words, if `b` is in the image of the list `l` under the function `f`, then `b` is the image of some element of `l` under `f`.

If a list `l` of elements `α_1` maps to an element `b` of type `α` under a function `f: α_1 → α`, then there exists an element `a` in `l` such that `f(a) = b`.


theorem isOpen_sigma_iff :
    ∀ {ι : Type u_5} {σ : ι → Type u_7} [inst : (i : ι) → TopologicalSpace (σ i)] {s : Set (Sigma σ)},
      IsOpen s ↔ ∀ (i : ι), IsOpen (Sigma.mk i ⁻¹' s) :=
  by sorry

The theorem `isOpen_sigma_iff` states that for all types `ι` and `σ`, where `σ` is a function from `ι` to some type, and for each `i` in `ι`, there exists a topological space on `σ i`. Given a set `s` in the sigma type `Sigma σ`, the set `s` is open if and only if, for every `i` in `ι`, the preimage of `s` under the function `Sigma.mk i` is open.

In simpler terms, in the context of topology, the theorem is examining the open sets within a space that is a disjoint union of many spaces. It asserts that a set in this disjoint union is open if and only if each of its "slices" in the individual spaces that compose the union is open.

A set in the disjoint union of topological spaces, each indexed by a type `ι`, is open if and only if the preimage of the set under the canonical projection function is open in each indexed space.


theorem Set.Iio_inter_Iio :
    ∀ {α : Type u_1} [inst : LinearOrder α] {a b : α}, Set.Iio a ∩ Set.Iio b = Set.Iio (a ⊓ b) := by sorry

The theorem `Set.Iio_inter_Iio` states that for any type `α` that has a linear order, given any two elements `a` and `b` of the type `α`, the intersection of the left-infinite right-open intervals ending at `a` and `b` respectively, is equal to the left-infinite right-open interval ending at the infimum of `a` and `b` (denoted by `a ⊓ b`). In other words, the intersection of all elements less than `a` and all elements less than `b` is the set of all elements less than the smaller of `a` and `b`.

For any linear order type `α`, the interval `{x : α | x < a} ∩ {x : α | x < b} = {x : α | x < a ⊓ b}`, where `a ⊓ b` denotes the infimum of `a` and `b`.


theorem LinearMap.lift_rank_comp_le_right :
    ∀ {K : Type u} {V : Type v} {V' : Type v'} {V'' : Type v''} [inst : Ring K] [inst_1 : AddCommGroup V]
      [inst_2 : Module K V] [inst_3 : AddCommGroup V'] [inst_4 : Module K V'] [inst_5 : AddCommGroup V'']
      [inst_6 : Module K V''] (g : V →ₗ[K] V') (f : V' →ₗ[K] V''),
      Cardinal.lift.{v', v''} (LinearMap.rank (f ∘ₗ g)) ≤ Cardinal.lift.{v'', v'} (LinearMap.rank g) :=
  by sorry

The theorem `LinearMap.lift_rank_comp_le_right` states that: For any ring `K` and `K`-modules `V`, `V'`, and `V''`, given two linear maps `g : V →ₗ[K] V'` and `f : V' →ₗ[K] V''`, the lift (to the maximum of the universes of `V'` and `V''`) of the rank of the composition of the two maps (i.e., `f ∘ₗ g`) is less than or equal to the lift (to the maximum of the universes of `V''` and `V'`) of the rank of the linear map `g`. In mathematical terms, if we denote the rank of a linear map using the function `rank(.)`, this theorem can be expressed as: $\forall f,g: \text{rank}(f \circ g) \leq \text{rank}(g)$. This result is related to the dimension theory of vector spaces and the properties of linear transformations.

The rank of the composition of two linear maps is less than or equal to the rank of the second map.


theorem AkraBazziRecurrence.GrowsPolynomially.inv :
    ∀ {f : ℝ → ℝ}, AkraBazziRecurrence.GrowsPolynomially f → AkraBazziRecurrence.GrowsPolynomially fun x => (f x)⁻¹ :=
  by sorry

The theorem `AkraBazziRecurrence.GrowsPolynomially.inv` states that if a function `f`, mapping real numbers to real numbers, satisfies the Akra-Bazzi growth condition (i.e., `f` grows polynomially), then the reciprocal function `1 / f` also satisfies the same growth condition. In other words, for any given function `f`, if for every `b` in the open interval (0,1), there exist positive constants `c₁` and `c₂` such that for all sufficiently large `x`, `f(u)` lies between `c₁ * f(x)` and `c₂ * f(x)` for `u` between `b * x` and `x`, then the same property holds for the function `1 / f`, where `1 / f` is defined as `fun x => (f x)⁻¹`.

If `f` is a real-valued function that grows polynomially according to the Akra-Bazzi condition, then the reciprocal function `1 / f` also satisfies the same condition.


theorem WithZero.coe_mul : ∀ {α : Type u} [inst : Mul α] {a b : α}, ↑(a * b) = ↑a * ↑b := by sorry

This theorem states that for any type `α` equipped with a multiplication operation, the operation of lifting a multiplication result from this type to the type with zero (`WithZero α`) is equivalent to first lifting the individual elements to `WithZero α` and then multiplying them. In mathematical terms, for any elements `a` and `b` of type `α`, `↑(a * b) = ↑a * ↑b` where `↑` denotes the lifting operation, and `*` represents multiplication in either `α` or `WithZero α` depending on the context.

For any type `α` with multiplication and a lifting operation to `WithZero α`, the lifted multiplication of elements equals the product of their lifted values: `↑(a * b) = ↑a * ↑b` for all `a, b` in `α`.


theorem MeasurableEquiv.symm_symm :
    ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] [inst_1 : MeasurableSpace β] (e : α ≃ᵐ β),
      e.symm.symm = e :=
  by sorry

This theorem states that for all types `α` and `β`, given that `α` and `β` are measurable spaces, the double application of the symmetry function (`.symm.symm`) on a measurable equivalence `e` between `α` and `β` results in `e` itself. In other words, it asserts that the symmetry of the symmetry of a measurable equivalence is the equivalence itself.

For all measurable spaces `α` and `β` and measurable equivalences `e` between them, `e.symm.symm` equals `e`.


theorem unitInterval.qRight.proof_1 : 0 ≤ 1 := by sorry

This theorem, named `unitInterval.qRight.proof_1`, states that zero is less than or equal to one. This is a fundamental concept in number comparisons and it holds true in the context of all real numbers. The Lean 4 proof for this theorem is not provided here.

The theorem `unitInterval.qRight.proof_1` asserts that 0 ≤ 1 in the context of real numbers.


theorem Polynomial.content_zero :
    ∀ {R : Type u_1} [inst : CommRing R] [inst_1 : IsDomain R] [inst_2 : NormalizedGCDMonoid R],
      Polynomial.content 0 = 0 :=
  by sorry

The theorem `Polynomial.content_zero` states that for any type `R`, where `R` forms a commutative ring and is also a domain with a normalized greatest common divisor monoid structure, the `content` of the zero polynomial is zero. In other words, the greatest common divisor (gcd) of the coefficients of the zero polynomial is zero.

In a commutative ring and domain with normalized greatest common divisors, the content of the zero polynomial is 0, meaning its coefficients have a gcd of 0.


theorem CategoryTheory.MorphismProperty.map_map :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {D : Type u_1}
      [inst_1 : CategoryTheory.Category.{u_3, u_1} D] (P : CategoryTheory.MorphismProperty C)
      (F : CategoryTheory.Functor C D) {E : Type u_2} [inst_2 : CategoryTheory.Category.{u_4, u_2} E]
      (G : CategoryTheory.Functor D E),
      CategoryTheory.MorphismProperty.map (CategoryTheory.MorphismProperty.map P F) G =
        CategoryTheory.MorphismProperty.map P (CategoryTheory.Functor.comp F G) :=
  by sorry

The theorem `CategoryTheory.MorphismProperty.map_map` states that for any two categories `C` and `D`, and any property `P` of morphisms in `C`, if we first apply a functor `F` from `C` to `D` to `P`, obtaining a property of morphisms in `D`, and then apply a functor `G` from `D` to a third category `E`, the result is the same as if we had first formed the composite functor `F ∘ G` from `C` to `E` and then applied it to `P`. This is essentially a statement about the commutativity of the process of applying functors to morphism properties.

For any categories C, D, E, functors F : C -> D and G : D -> E, and property P of morphisms in C, the composition of functors F and G preserves the property P, i.e., (F ∘ G)(P) = F(G(P)).


theorem ZFSet.pair_injective : Function.Injective2 ZFSet.pair := by sorry

The theorem `ZFSet.pair_injective` states that the function `ZFSet.pair`, which creates a Kuratowski ordered pair from two elements of the type `ZFSet`, is injective in both of its arguments. In other words, given any four elements `a₁`, `a₂`, `b₁`, `b₂` of `ZFSet`, if `ZFSet.pair a₁ b₁` equals `ZFSet.pair a₂ b₂`, then `a₁` must be equal to `a₂` and `b₁` must be equal to `b₂`. This maps mathematically to the injective property of the function `α × β → γ` in the domain of ZFSet, where different ordered pairs have distinct results.

If `a₁`, `a₂`, `b₁`, `b₂` are elements of `ZFSet` such that `ZFSet.pair a₁ b₁` equals `ZFSet.pair a₂ b₂`, then `a₁` equals `a₂` and `b₁` equals `b₂`.


theorem deriv_const :
    ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {F : Type v} [inst_1 : NormedAddCommGroup F]
      [inst_2 : NormedSpace 𝕜 F] (x : 𝕜) (c : F), deriv (fun x => c) x = 0 :=
  by sorry

This theorem, `deriv_const`, states that for any nontrivially normed field `𝕜` and normed additive commutative group `F` (which is also a normed space over `𝕜`), the derivative at any point `x` in `𝕜` of a constant function (a function that maps every input to the same constant value `c` in `F`) is zero. This corresponds to the standard calculus result that the derivative of a constant function is always zero.

The derivative of a constant function is zero in the setting of a normed field and normed additive commutative group.


theorem Set.Iic_injective : ∀ {α : Type u_1} [inst : PartialOrder α], Function.Injective Set.Iic := by sorry

The theorem `Set.Iic_injective` states that for any type `α` where a partial order is defined, the function `Set.Iic`, which produces the left-infinite right-closed interval `{x | x ≤ b}`, is injective. In other words, if two such intervals are equal, then their endpoints must be the same. This means that for all elements `a₁`, `a₂` of the type `α`, if `Set.Iic a₁` equals `Set.Iic a₂`, then `a₁` equals `a₂`.

For any type `α` with a partial order, the function `Set.Iic` mapping an element to its left-infinite right-closed interval is injective. In other words, for all `α` elements `a₁` and `a₂`, if `Set.Iic a₁ = Set.Iic a₂`, then `a₁ = a₂`.


theorem Mathlib.Algebra.GroupWithZero.Basic._auxLemma.7 :
    ∀ {M₀ : Type u_2} [inst : CancelMonoidWithZero M₀] {a b c : M₀}, (a * c = b * c) = (a = b ∨ c = 0) := by sorry

This theorem states that for any type `M₀`, provided it is a cancellation monoid with zero, and for any elements `a`, `b`, and `c` of this type, the equality `a * c = b * c` is equivalent to the statement `a = b` or `c = 0`. In other words, if multiplication of `a` and `c` equals multiplication of `b` and `c`, then either `a` and `b` are equal or `c` is zero.

For any cancellation monoid with zero `M₀`, the equality `a * c = b * c` implies `a = b` or `c = 0`.


theorem WithTop.mul_lt_top' :
    ∀ {α : Type u_1} [inst : DecidableEq α] [inst_1 : MulZeroClass α] [inst_2 : LT α] {a b : WithTop α},
      a < ⊤ → b < ⊤ → a * b < ⊤ :=
  by sorry

The theorem `WithTop.mul_lt_top'` states that for any type `α` that has a decidable equality relation, a multiplication operation that respects zero (`MulZeroClass α`), and a less than relation (`LT α`), if `a` and `b` are elements of the type that includes `α` and an additional top element (`WithTop α`), and both `a` and `b` are less than this top element, then the product of `a` and `b` is also less than the top element. Essentially, this theorem guarantees that for two elements less than the top element in a `WithTop` structure with these properties, their multiplication will also stay within the bounds of the set and be less than the top element.

For any type `α` with decidable equality, `MulZeroClass α`, and `LT α`, in a `WithTop α`, if `a` and `b` are less than the top element, then their product `a * b` is also less than the top element.


theorem Function.mulSupport_subset_iff' :
    ∀ {α : Type u_1} {M : Type u_5} [inst : One M] {f : α → M} {s : Set α},
      Function.mulSupport f ⊆ s ↔ ∀ x ∉ s, f x = 1 :=
  by sorry

This theorem is stating that for any given types `α` and `M`, where `M` has an instance of `One` (meaning it has a designated "one" element), and any function `f` from `α` to `M`, and any set `s` of elements of type `α`, the `mulSupport` of `f` (which is the set of points `x` where `f(x)` is not equal to `1`) is a subset of `s` if and only if for every `x` that is not in `s`, `f(x)` equals `1`. In other words, if a point `x` is not in set `s`, then the value of the function `f` at `x` must be `1`, and this condition is both necessary and sufficient to ensure that all points where `f` does not equal `1` are contained within `s`.

For any function `f` from type `α` to a type `M` with a `One` instance, the set `{x : α | f x ≠ 1}` is a subset of a set `s` if and only if for all `x ∈ α \ s`, we have `f x = 1`.


theorem Primrec.list_append : ∀ {α : Type u_1} [inst : Primcodable α], Primrec₂ fun x x_1 => x ++ x_1 := by sorry

The theorem `Primrec.list_append` states that for any given type `α` which is primcodable, the function that appends two lists, namely `x` and `x_1`, is a binary primitive recursive function. In simpler terms, it means that list concatenation operation is primitive recursive for any kind of elements as long as the type of those elements is primcodable.

For any primcodable type α, the function that appends two lists of type list α is a primitive recursive function.


theorem QPF.id_map : ∀ {F : Type u → Type u} [inst : Functor F] [q : QPF F] {α : Type u} (x : F α), id <$> x = x := by
  sorry

This theorem, `QPF.id_map`, states that for any type `F` that is a functor and a Quasi-Polynomial Functor (QPF), and for any type `α` and value `x` of type `F α`, applying the identity function (`id`) using the functor's `fmap` operation (`<$>`) to `x` returns `x` itself. In other words, this theorem asserts the identity law for the functor `F` when `F` is also a QPF, stating that mapping the identity function over a value does not change the value.

For any Quasi-Polynomial Functor (QPF) `F` and type `α`, the application of the identity function through `F`'s `fmap` operation leaves the value unchanged: `id <$> x = x`.


MeasurableSet.isClopenable

/-- Given a Borel-measurable set in a Polish space, there exists a finer Polish topology making
it clopen. This is in fact an equivalence, see `isClopenable_iff_measurableSet`.  -/
theorem MeasurableSet.isClopenable :
    ∀ {α : Type u_1} [inst : TopologicalSpace α] [inst_1 : PolishSpace α] [inst_2 : MeasurableSpace α]
      [inst_3 : BorelSpace α] {s : Set α}, MeasurableSet s → PolishSpace.IsClopenable s :=
  by sorry

This theorem states that for any given Borel-measurable set in a Polish space (a completely metrizable, separable topological space), there always exists a finer topology that is still a Polish space, in which the given set is both open and closed (clopen). This theorem is actually one side of an equivalency, as referenced by `isClopenable_iff_measurableSet`. The latter suggests that a set being Borel-measurable is equivalent to the condition that there exists a finer Polish topology making it clopen.

For any Borel-measurable set in a Polish space, there exists a finer Polish topology making the set both open and closed (clopen).


theorem LinearMap.funLeft_comp :
    ∀ (R : Type u_1) (M : Type u_9) [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {m : Type u_20}
      {n : Type u_21} {p : Type u_22} (f₁ : n → p) (f₂ : m → n),
      LinearMap.funLeft R M (f₁ ∘ f₂) = LinearMap.funLeft R M f₂ ∘ₗ LinearMap.funLeft R M f₁ :=
  by sorry

This theorem states that for any semiring `R`, additively commutative monoid `M`, `R`-module structure on `M`, and arbitrary types `m`, `n`, and `p`, if we have two functions `f₁ : n → p` and `f₂ : m → n`, then constructing a linear map from `n → M` to `m → M` using the composition of `f₁` and `f₂` (`f₁ ∘ f₂`) is the same as composing the linear map constructed using `f₂` with the linear map constructed using `f₁`. In other words, the construction of these linear maps commutes with function composition.

For any semiring `R`, additively commutative monoid `M` with an `R`-module structure, and types `m`, `n`, `p`, if `f₁ : n → p` and `f₂ : m → n` are functions, then the linear maps from `n → M` to `m → M` constructed using `f₁ ∘ f₂` and `f₂ ∘ f₁` are equal.


/-- If `s ×ˢ t` is a null measurable set and `μ s ≠ 0`, then `t` is a null measurable set.  -/
theorem MeasureTheory.NullMeasurableSet.right_of_prod :
    ∀ {α : Type u_1} {β : Type u_3} [inst : MeasurableSpace α] [inst_1 : MeasurableSpace β]
      {μ : MeasureTheory.Measure α} {ν : MeasureTheory.Measure β} [inst_2 : MeasureTheory.SFinite ν] {s : Set α}
      {t : Set β},
      MeasureTheory.NullMeasurableSet (s ×ˢ t) (MeasureTheory.Measure.prod μ ν) →
        ↑↑μ s ≠ 0 → MeasureTheory.NullMeasurableSet t ν :=
  by sorry

This theorem states that for any two sets `s` and `t` of any two types `α` and `β`, respectively, equipped with measurable spaces and measures `μ` and `ν` respectively, if the product set `s ×ˢ t` is a null measurable set with respect to the product measure of `μ` and `ν`, and the measure of the set `s` is not zero, then the set `t` itself is a null measurable set with respect to the measure `ν`. This theorem holds under the assumption that the measure `ν` is sigma-finite. In other words, if a set in the product space is approximately measurable and the first factor has non-zero measure, then the second factor is also approximately measurable.

If `s` and `t` are measurable sets of types `α` and `β` respectively, equipped with sigma-finite measures `μ` and `ν`, and the product `s ×ˢ t` is null with respect to the product measure of `μ` and `ν`, then `t` is null with respect to `ν`, given that `μ(s) ≠ 0`.


theorem Subsingleton.set_cases :
    ∀ {α : Type u_1} [inst : Subsingleton α] {p : Set α → Prop}, p ∅ → p Set.univ → ∀ (s : Set α), p s := by sorry

This theorem, referred to as `Subsingleton.set_cases`, states that for any type `α` which is a Subsingleton (meaning it has at most one element), and for any property `p` applied to sets of `α`, if `p` holds for the empty set and `p` also holds for the universal set (the set containing all elements of `α`), then `p` must hold for any set of `α`. In essence, this theorem establishes that for Subsingleton types, any property that holds for the empty and universal sets must also hold for all sets of that type.

If `α` is a Subsingleton type and `p` is a property that holds for the empty set and the universal set of `α`, then `p` holds for every set of `α`.


theorem Polynomial.integralNormalization_coeff :
    ∀ {R : Type u} [inst : Semiring R] {f : Polynomial R} {i : ℕ},
      Polynomial.coeff (Polynomial.integralNormalization f) i =
        if Polynomial.degree f = ↑i then 1
        else Polynomial.coeff f i * Polynomial.leadingCoeff f ^ (Polynomial.natDegree f - 1 - i) :=
  by sorry

The theorem `Polynomial.integralNormalization_coeff` states that for any semiring `R`, any polynomial `f` over `R` and any natural number `i`, the coefficient of `X^i` in the integral normalization of `f` is 1 if the degree of `f` equals `i`. Otherwise, it is the product of the coefficient of `X^i` in `f` and the leading coefficient of `f` raised to the power of the natural degree of `f` minus `i` minus 1. Here, the leading coefficient of a polynomial is the coefficient of the highest power of `X` in it, and the natural degree of a polynomial enforces the degree of the polynomial to `ℕ`, by defining `natDegree 0 = 0`.

For any semiring R, polynomial f over R, and natural number i, the coefficient of X^i in the integral normalization of f is the leading coefficient of f raised to the power of deg(f) - i, where deg(f) is the degree of f, if i equals deg(f). Otherwise, it is the coefficient of X^i in f.


theorem Int.gcd_eq_natAbs : ∀ {a b : ℤ}, Int.gcd a b = Nat.gcd (Int.natAbs a) (Int.natAbs b) := by sorry

This theorem states that for any two integers `a` and `b`, the greatest common divisor (gcd) of `a` and `b` can be computed as the gcd of the absolute values of `a` and `b`. The absolute value of an integer is found using the `Int.natAbs` function, which returns the natural number corresponding to the integer's absolute value. In other words, the gcd of any two integers is equal to the gcd of their absolute values.

For any integers a and b, |a|gcd a b = |b|gcd a b, where |a| denotes the absolute value of integer a.


CategoryTheory.EssentiallySmall.mk'

/-- Constructor for `EssentiallySmall C` from an explicit small category witness.  -/
theorem CategoryTheory.EssentiallySmall.mk' :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {S : Type w} [inst_1 : CategoryTheory.SmallCategory S],
      (C ≌ S) → CategoryTheory.EssentiallySmall.{w, v, u} C :=
  by sorry

The theorem `CategoryTheory.EssentiallySmall.mk'` states that for any category `C` defined in some type universe `u` and with morphisms in universe `v`, if there exists a small category `S` (that is a category with objects and morphisms in the same universe level) such that `C` is equivalent to `S` (denoted by `C ≌ S`), then `C` is essentially small. In this context, a category is called essentially small if it is equivalent to a small category.

If a category `C` is equivalent to a small category `S`, then `C` is essentially small.


theorem Mathlib.Data.Set.Prod._auxLemma.3 : ∀ {a b c : Prop}, ((a ∧ b) ∧ c) = (a ∧ b ∧ c) := by sorry

This theorem states that for any three propositions `a`, `b`, and `c`, the statement "a and b and c" is logically equivalent to the statement "a and (b and c)". In other words, the logical conjunction operator, represented by `∧`, is associative. This means that the order in which the conjunctions are performed does not change the truth value of the whole expression.

The logical conjunction operation is associative, that is, `a ∧ (b ∧ c)` is equivalent to `(a ∧ b) ∧ c` for any propositions `a`, `b`, and `c`.


theorem Mathlib.Data.Set.Prod._auxLemma.8 : ∀ {α : Sort u_1} {a b : α}, (a = b) = (b = a) := by sorry

This theorem, from the Mathlib library and specifically from the Data.Set.Prod module, states that for all types `α` and for all elements `a` and `b` of that type, the statement that `a` equals `b` is equivalent to the statement that `b` equals `a`. In other words, it asserts the symmetry of equality: if `a` equals `b`, then `b` equals `a`, and vice versa.

The theorem asserts the symmetry of equality: for all types `α` and all elements `a` and `b` of type `α`, `a = b` is equivalent to `b = a`.


theorem Mathlib.Algebra.Lie.Normalizer._auxLemma.1 :
    ∀ {R : Type u_1} {L : Type u_2} {M : Type u_3} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L]
      [inst_3 : AddCommGroup M] [inst_4 : Module R M] [inst_5 : LieRingModule L M] [inst_6 : LieModule R L M]
      (N : LieSubmodule R L M) (m : M), (m ∈ LieSubmodule.normalizer N) = ∀ (x : L), ⁅x, m⁆ ∈ N :=
  by sorry

This theorem from the Mathlib library, specifically from the Algebra.Lie.Normalizer module, states that for any given commutative ring `R`, Lie ring `L`, and additive commutative group `M` that has a `R` module, a Lie `L` ring module, and is a Lie module over `R` and `L`, a certain condition holds. This condition is that for any Lie submodule `N` of `M` and any element `m` of `M`, `m` is in the normalizer of `N` if and only if for every element `x` of `L`, the Lie bracket of `x` and `m` is an element of `N`. In LaTeX mathematics, this is expressed as \(m \in \text{N.normalizer} \Leftrightarrow \forall x \in L, [x,m] \in N\).

A Lie ring module M over a commutative ring R, which is also a Lie module over M and has a given Lie submodule N, satisfies the condition that an element m of M is in the normalizer of N if and only if the Lie bracket [x,m] of any x in L lies in N.


theorem Real.sinh_add_cosh : ∀ (x : ℝ), Real.sinh x + Real.cosh x = Real.exp x := by sorry

The theorem states that for all real numbers `x`, the sum of the real hyperbolic sine of `x` and the real hyperbolic cosine of `x` is equal to the real exponential of `x`. In mathematical terms, this can be written as $\sinh(x) + \cosh(x) = e^x$ for all $x \in \mathbb{R}$.

For all real numbers x, $\sinh(x) + \cosh(x) = e^x$.


theorem ProbabilityTheory.kernel.iIndepFun.indepFun_add_left :
    ∀ {α : Type u_1} {Ω : Type u_2} {ι : Type u_3} {_mα : MeasurableSpace α} {_mΩ : MeasurableSpace Ω}
      {κ : ↥(ProbabilityTheory.kernel α Ω)} {μ : MeasureTheory.Measure α} {β : Type u_8} {m : MeasurableSpace β}
      [inst : Add β] [inst_1 : MeasurableAdd₂ β] {f : ι → Ω → β} [inst_2 : ProbabilityTheory.IsMarkovKernel κ],
      ProbabilityTheory.kernel.iIndepFun (fun x => m) f κ μ →
        (∀ (i : ι), Measurable (f i)) →
          ∀ (i j k : ι), i ≠ k → j ≠ k → ProbabilityTheory.kernel.IndepFun (f i + f j) (f k) κ μ :=
  by sorry

This theorem is about the independence of functions in the context of probability theory. Specifically, it states that for any types `α`, `Ω`, `ι`, and `β`, given a measurable space for `α` and `Ω`, a marked kernel `κ` from `α` to `Ω`, a measure `μ` on `α`, a measurable space `m` on `β`, an addition operation on `β`, a measurable binary addition on `β`, a function `f` from `ι` to a function from `Ω` to `β`, and assuming that `κ` is a Markov kernel, if the kernel of the function `m` and `f` with respect to `κ` and `μ` is independent, and every function `f(i)` for `i` in `ι` is measurable, then for any three distinct elements `i`, `j`, `k` of `ι`, the function `f(i) + f(j)` is independent of `f(k)` with respect to the kernel `κ` and the measure `μ`.

Given measurable spaces `α`, `Ω`, `β`, a Markov kernel `κ` from `α` to `Ω`, a measure `μ` on `α`, a measurable space `m` on `β` with measurable binary addition, a function `f` from `ι` to `Ω -> β` such that `κ` is the kernel of `m` and `f` with respect to `κ` and `μ`, and `f(i)` measurable for all `i` in `ι`, if `f(i)`, `f(j)`, and `f(k)` are independent for any distinct `i`, `j`, `k` in `ι` with respect to `κ` and `μ`, then `f(i) + f(j)` is independent of `f(k)` with respect to `κ` and `μ`.


ContinuousAt.codRestrict

/-- **Alias** of the reverse direction of `continuousAt_codRestrict_iff`. -/
theorem ContinuousAt.codRestrict :
    ∀ {X : Type u} {Y : Type v} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {f : X → Y} {t : Set Y}
      (h1 : ∀ (x : X), f x ∈ t) {x : X}, ContinuousAt f x → ContinuousAt (Set.codRestrict f t h1) x :=
  by sorry

The theorem `ContinuousAt.codRestrict` states that for any topological spaces `X` and `Y`, given a function `f` from `X` to `Y` and a set `t` of `Y` such that every output of `f` belongs to `t`, if `f` is continuous at a point `x` in `X`, then the function `f` restricted to the set `t` (using `Set.codRestrict`) is also continuous at `x`. Essentially, this theorem guarantees that restricting the codomain of a continuous function to a set that includes all its outputs does not affect the continuity of the function at a given point.

If `f: X → Y` is continuous at `x ∈ X` and `t ⊆ Y` contains all images of `f`, then `f|t: X → t` is continuous at `x`.


theorem MeasureTheory.upperCrossingTime_lt_of_le_upcrossingsBefore :
    ∀ {Ω : Type u_1} {a b : ℝ} {f : ℕ → Ω → ℝ} {N n : ℕ} {ω : Ω},
      0 < N → a < b → n ≤ MeasureTheory.upcrossingsBefore a b f N ω → MeasureTheory.upperCrossingTime a b f N n ω < N :=
  by sorry

This theorem states that for any types `Ω` representing a set of outcomes, real numbers `a` and `b` with `a` less than `b`, a function `f` mapping natural numbers and outcomes to real numbers, and natural numbers `N` and `n` with `N` greater than zero and `n` less than or equal to the number of upcrossings before time `N`, the upper crossing time of `f` at values `a` and `b` before time `N` for any outcome `ω` is less than `N`. In other words, it says that if the number of times the function `f` upcrosses between `a` and `b` before time `N` is greater than or equal to a certain number `n`, then the `n`-th upper crossing time of `f` between `a` and `b` occurs before time `N`.

For any function `f` mapping natural numbers and outcomes to real numbers, if there exist types `Ω`, real numbers `a` < `b`, natural numbers `N` > 0, and `n` <= number of upcrossings before `N` of `f(x, ω)` between `a` and `b`, then the `n`-th upper crossing time of `f(x, ω)` between `a` and `b` occurs before time `N`.


theorem Hyperreal.ofSeq_lt_ofSeq :
    ∀ {f g : ℕ → ℝ}, Hyperreal.ofSeq f < Hyperreal.ofSeq g ↔ ∀ᶠ (n : ℕ) in ↑(Filter.hyperfilter ℕ), f n < g n := by
  sorry

This theorem, `Hyperreal.ofSeq_lt_ofSeq`, states that for any two sequences of real numbers `f` and `g`, the hyperreal number constructed from sequence `f` is less than the hyperreal number constructed from sequence `g` if and only if for "almost all" natural numbers `n` (in the sense of the ultrafilter extending the cofinite filter), the `n`-th term of sequence `f` is less than the `n`-th term of sequence `g`.

For any sequences of real numbers `f` and `g`, their corresponding hyperreal numbers satisfy the relationship `Hyperreal.ofSeq f < Hyperreal.ofSeq g` if and only if `f(n) < g(n)` for all but finitely many natural numbers `n`.


theorem NormedAddGroupHom.bounds_bddBelow :
    ∀ {V₁ : Type u_2} {V₂ : Type u_3} [inst : SeminormedAddCommGroup V₁] [inst_1 : SeminormedAddCommGroup V₂]
      {f : NormedAddGroupHom V₁ V₂}, BddBelow {c | 0 ≤ c ∧ ∀ (x : V₁), ‖f x‖ ≤ c * ‖x‖} :=
  by sorry

This theorem states that for any normed additive commutative groups `V1` and `V2`, and any normed additive group homomorphism `f` from `V1` to `V2`, the set of all real numbers `c` satisfying two conditions (1: `c` is non-negative, and 2: the norm of `f(x)` is less than or equal to `c` times the norm of `x` for all `x` in `V1`) is bounded from below. In other words, there exists a lower bound for the set of scalars that can bound the norm of the function `f` on every element of `V1`.

For any normed additive commutative groups V1 and V2, and normed additive group homomorphism f from V1 to V2, there exists a positive real number c such that for all x in V1, ||fx|| ≤ c * ||x|| holds.


theorem Mathlib.Topology.Order.Basic._auxLemma.7 :
    ∀ {α : Type u} {β : Type v} {f : α → β} {l : Filter α} {s : Set β},
      Filter.Tendsto f l (Filter.principal s) = ∀ᶠ (a : α) in l, f a ∈ s :=
  by sorry

The theorem `Mathlib.Topology.Order.Basic._auxLemma.7` states that for any types `α` and `β`, a function `f` from `α` to `β`, a filter `l` on `α`, and a set `s` of `β`, the function `f` tends to the principal filter of `s` under the filter `l` if and only if almost every element `a` in the filter `l` satisfies that `f(a)` is an element of `s`. In other words, the function `f` maps almost all elements in the neighborhood described by the filter `l` into the set `s`. Here, "almost every element" refers to the concept of "eventually", meaning that apart from possibly a finite number of exceptions, all elements satisfy the condition.

A function from a type to another tends to the principal filter of a set under a given filter if and only if almost all elements in the filter map to elements in the set.


theorem List.forall₂_same : ∀ {α : Type u_1} {Rₐ : α → α → Prop} {l : List α}, List.Forall₂ Rₐ l l ↔ ∀ x ∈ l, Rₐ x x :=
  by sorry

This theorem states that for any type `α` and any binary relation `Rₐ` on elements of `α`, and any list `l` of elements of type `α`, `List.Forall₂ Rₐ l l` if and only if for every element `x` in the list `l`, `Rₐ x x` holds. In other words, every element in the list satisfies the relation with itself if and only if the relation holds pairwise between corresponding elements of the list and itself.

For any type `α` and binary relation `R` on `α`, `List.Forall₂ R l l` if and only if for all `x` in `l`, `R x x`.


theorem Polynomial.leadingCoeff_X_sub_C :
    ∀ {S : Type v} [inst : Ring S] (r : S), Polynomial.leadingCoeff (Polynomial.X - Polynomial.C r) = 1 := by sorry

This theorem states that for any ring `S` and any element `r` of `S`, the leading coefficient of the polynomial `Polynomial.X - Polynomial.C r` is `1`. In other words, if we subtract a constant polynomial `r` from the polynomial variable `X`, the coefficient of the highest power term in the resulting polynomial is always `1`, regardless of the specific ring we are working in or the value of `r`.

For any ring `S` and element `r` in `S`, the leading coefficient of `Polynomial.X - Polynomial.const r` is `1`.


theorem CategoryTheory.Limits.image.map_ι :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {f g : CategoryTheory.Arrow C}
      [inst_1 : CategoryTheory.Limits.HasImage f.hom] [inst_2 : CategoryTheory.Limits.HasImage g.hom] (sq : f ⟶ g)
      [inst_3 : CategoryTheory.Limits.HasImageMap sq],
      CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.image.map sq) (CategoryTheory.Limits.image.ι g.hom) =
        CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.image.ι f.hom) sq.right :=
  by sorry

This theorem states that in an arbitrary category `C`, given two morphisms, `f` and `g`, in the arrow category of `C` (meaning that they are given by pairs of objects and morphisms in `C`), if `f` and `g` both have images, and there is a morphism `sq` between `f` and `g` which also has an image, then the composition of the image map of `sq` and the inclusion of the image of `g` into its target is equal to the composition of the inclusion of the image of `f` into its target and the right part of `sq`. This can be written in mathematical terms as: `(ImageMap sq) ∘ (ImageInclusion g) = (ImageInclusion f) ∘ (sq.right)`.

In an arbitrary category, if morphisms `f` and `g` have images and there is an image-preserving morphism `sq` between them, then the inclusion of `g`'s image into its target followed by the image map of `sq` is equal to the inclusion of `f`'s image into its target followed by `sq`'s right component.


theorem SetTheory.Game.PGame.equiv_iff_game_eq : ∀ {x y : SetTheory.PGame}, x ≈ y ↔ ⟦x⟧ = ⟦y⟧ := by sorry

This theorem states that for any two pre-games `x` and `y` in the domain of Set Theory, `x` is equivalent to `y` if and only if the game equivalence classes of `x` and `y` are equal. In other words, two pre-games are considered equivalent if they belong to the same equivalence class under the game equivalence relation.

Two pre-games in Set Theory are equal if and only if their game equivalence classes are equal.


theorem Set.ite_inter_self : ∀ {α : Type u} (t s s' : Set α), Set.ite t s s' ∩ t = s ∩ t := by sorry

This theorem states that for any type `α` and any three sets `t`, `s`, and `s'` of type `α`, the intersection of the set defined by the "if-then-else" function `Set.ite` applied to `t`, `s`, and `s'` with the set `t` is equal to the intersection of the sets `s` and `t`. In mathematical terms, `Set.ite(t, s, s') ∩ t = s ∩ t`. This means that when we use the `Set.ite` function to create a set from `t`, `s`, and `s'`, any elements shared between that resultant set and `t` will also be shared between `s` and `t`.

For any type `α` and sets `t, s, s'` of type `α`, `Set.ite(t, s, s') �cap t = s ∩ t`.


theorem Multiset.exists_mem_of_rel_of_mem :
    ∀ {α : Type u_1} {β : Type v} {r : α → β → Prop} {s : Multiset α} {t : Multiset β},
      Multiset.Rel r s t → ∀ {a : α}, a ∈ s → ∃ b ∈ t, r a b :=
  by sorry

This theorem states that for all types `α` and `β`, and a relation `r` between `α` and `β`, if there is a `Multiset.Rel r` relationship between a multiset `s` of type `α` and a multiset `t` of type `β`, then, for any element `a` in multiset `s`, there exists an element `b` in multiset `t` such that the relation `r` holds between `a` and `b`. In other words, if two multisets are related by a certain relationship, then any element in the first multiset is related by this relationship to some element in the second multiset.

For all types `α`, `β` and relations `r` between `α` and `β`, if there is a multiset inclusion `s ⊆ t` of multisets `s` of type `α` and `t` of type `β` such that `Multiset.Rel r s t`, then for all `a` in `s`, there exists `b` in `t` with `r a b`.


theorem Tropical.untrop_le_iff :
    ∀ {R : Type u} [inst : LE R] {x y : Tropical R}, Tropical.untrop x ≤ Tropical.untrop y ↔ x ≤ y := by sorry

The theorem `Tropical.untrop_le_iff` states that for any type `R` equipped with a less than or equal to relation (denoted `LE R`), and for any two elements `x` and `y` of the type `Tropical R`, the inequality of their underlying elements in `R` (obtained by `Tropical.untrop` method) is equivalent to the inequality of `x` and `y` in the tropicalized type `Tropical R`. In other words, the inequality holds in `Tropical R` if and only if it holds in `R` after applying the `untrop` function to `x` and `y`.

For any type `R` with a total order and tropical semiring structure `Tropical R`, the inequality `x LE y` in `Tropical R` holds if and only if `Tropical.untrop x LE Tropical.untrop y` holds in `R`.


theorem Nat.card_uIcc : ∀ (a b : ℕ), (Finset.uIcc a b).card = Int.natAbs (↑b - ↑a) + 1 := by sorry

This theorem, `Nat.card_uIcc`, states that for any two natural numbers `a` and `b`, the cardinality (or the number of elements) of the set that includes all elements lying between `a` and `b` (inclusive) is equal to the absolute value of the difference between `b` and `a`, incremented by 1. In mathematical terms, if `Finset.uIcc a b` is the set of all natural numbers from `a` to `b` inclusive, then the size of this set is $|b - a| + 1$. The absolute value ensures that the result is non-negative, regardless of whether `b` is greater than or less than `a`.

The cardinality of the set of natural numbers between two numbers `a` and `b` (inclusive) equals the absolute difference between `b` and `a` plus one.


theorem IsGroupHom.mem_ker :
    ∀ {G : Type u_1} {H : Type u_2} [inst : Group H] (f : G → H) {x : G}, x ∈ IsGroupHom.ker f ↔ f x = 1 := by sorry

This theorem states that for any types `G` and `H`, with `H` being a group, and any function `f` from `G` to `H`, an element `x` of `G` is in the kernel of `f` (i.e., maps to the identity of `H`) if and only if the function `f` applied to `x` equals the identity element of the group `H`. It provides a characterization of the kernel of a group homomorphism as the preimage of the trivial subgroup of `H` (i.e., the subgroup consisting only of the identity). In mathematical terms, for a group homomorphism `f : G → H`, `x` lies in `ker(f)` if and only if `f(x) = 1`.

For any group homomorphism f : G -> H, an element x of G lies in the kernel of f if and only if f(x) = 1.


theorem Nat.gcd_ne_zero_right : ∀ {n m : ℕ}, n ≠ 0 → Nat.gcd m n ≠ 0 := by sorry

The theorem `Nat.gcd_ne_zero_right` states that for all natural numbers `n` and `m`, if `n` is not equal to zero, then the greatest common divisor (gcd) of `m` and `n` is also not equal to zero. In mathematical terms, this translates to "For all natural numbers m and n, if n ≠ 0, then gcd(m, n) ≠ 0.".

If a natural number `n` is non-zero, then the greatest common divisor of `n` and another natural number `m` is also non-zero.


theorem ChainComplex.single₀_map_f_zero :
    ∀ {V : Type u} [inst : CategoryTheory.Category.{v, u} V] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms V]
      [inst_2 : CategoryTheory.Limits.HasZeroObject V] {A B : V} (f : A ⟶ B),
      ((ChainComplex.single₀ V).map f).f 0 = f :=
  by sorry

This theorem, `ChainComplex.single₀_map_f_zero`, states that for any category `V` that has zero morphisms and a zero object, and for any two objects `A` and `B` in `V` with a morphism `f` from `A` to `B`, the morphism at degree zero (`f 0`) in the chain complex generated by applying the functor `ChainComplex.single₀ V` to `f`, is equal to `f` itself. In other words, the functor `ChainComplex.single₀ V` preserves the original morphism `f` at degree zero when mapping it into a chain complex.

For any category with zero morphisms and a zero object, the morphism at degree 0 in the chain complex generated by applying `ChainComplex.single₀` to a morphism is equal to the morphism itself.


theorem hnot_hnot_hnot : ∀ {α : Type u_2} [inst : CoheytingAlgebra α] (a : α), ￢￢￢a = ￢a := by sorry

This theorem states that for any type `α` that forms a Coheyting Algebra, the triple negation of an element `a` of type `α` is equal to the negation of `a`. In mathematical terms, if `￢` denotes the negation operation in the Coheyting Algebra, we have `￢￢￢a = ￢a` for all `a` in `α`.

In a Cohetting Algebra, the triple negation of an element equals the negation of that element. That is, for all `α` and `a` in `α`, `￢￢￢a = ￢a`.


theorem AddAction.mem_orbit :
    ∀ {M : Type u} [inst : AddMonoid M] {α : Type v} [inst_1 : AddAction M α] (a : α) (m : M),
      m +ᵥ a ∈ AddAction.orbit M a :=
  by sorry

The theorem `AddAction.mem_orbit` states that for any given add monoid `M`, any type `α` acting under `M`, any element `a` of type `α`, and any element `m` of the add monoid `M`, the result of applying the additive action of `m` to `a` (denoted `m +ᵥ a`) is a member of the orbit of `a` under the action of `M`. Here, the orbit of an element `a` under the action of `M` is defined as the set of all possible results of applying elements of `M` to `a` via the additive action.

For any add monoid M, type α with an additive action, element a of α, and m in M, we have m +ᵥ a ∈ orbit a, where orbit a is the set of all elements obtained by applying elements of M to a via addition.


/-- Subring closure of a set is monotone in its argument: if `s ⊆ t`,
then `closure s ≤ closure t`.  -/
theorem Subring.closure_mono :
    ∀ {R : Type u} [inst : Ring R] ⦃s t : Set R⦄, s ⊆ t → Subring.closure s ≤ Subring.closure t := by sorry

This theorem states that the operation of taking the subring closure of a set is monotone with respect to set inclusion in a given ring. In other words, if you have two sets `s` and `t` of elements from a ring `R` such that `s` is a subset of `t`, then the subring generated by `s` is a subring of (or equals to) the subring generated by `t`.

If `s` is a subset of `t` in a ring `R`, then the subring generated by `s` is contained in the subring generated by `t`.


IsLUB.insert

theorem IsLUB.insert :
    ∀ {γ : Type w} [inst : SemilatticeSup γ] (a : γ) {b : γ} {s : Set γ}, IsLUB s b → IsLUB (insert a s) (a ⊔ b) := by
  sorry

This theorem, `IsLUB.insert`, states that for any type `γ` that has a semilattice structure, given any two elements `a` and `b` of this type and a set `s` of elements of the same type, if `b` is a least upper bound of the set `s`, then the least upper bound of the set obtained by inserting `a` into `s` is the supremum of `a` and `b`. The supremum (`⊔`) is the smallest element that is greater than or equal to both `a` and `b` in the semilattice.

For any semilattice type `γ` and elements `a`, `b` in `γ`, if `b` is the least upper bound of a set `s` in `γ`, then `a⊔b` is the least upper bound of `s∪{a}`.


theorem CategoryTheory.InjectiveResolution.ι_f_zero_comp_complex_d :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroObject C]
      [inst_2 : CategoryTheory.Limits.HasZeroMorphisms C] {Z : C} (I : CategoryTheory.InjectiveResolution Z),
      CategoryTheory.CategoryStruct.comp (I.ι.f 0) (I.cocomplex.d 0 1) = 0 :=
  by sorry

This theorem, `CategoryTheory.InjectiveResolution.ι_f_zero_comp_complex_d`, states that for all categories `C` of type `u` that have zero objects and zero morphisms, and for any object `Z` in `C` with an injective resolution `I`, the composition of the morphism `I.ι.f 0` and the differential `I.cocomplex.d 0 1` in the chain complex equals the zero morphism. In other words, the differential of a zero morphism in a chain complex is zero when composed with another morphism.

For any injective resolution I of an object Z in a zero category C, the composition of I.ι.f 0 and I.cocomplex.d 0 1 is the zero morphism.


theorem Mathlib.Data.ENNReal.Inv._auxLemma.13 : ∀ {a : ENNReal}, (0 < a⁻¹) = (a ≠ ⊤) := by sorry

This theorem states that for every extended nonnegative real number `a`, the reciprocal of `a` is greater than zero if and only if `a` is not equal to infinity. In mathematical terms, for all `a` in extended nonnegative real numbers (usually denoted [0, ∞]), `0 < 1/a` if and only if `a ≠ ∞`.

The reciprocal of a non-negative extended real number `a` is positive if and only if `a` is finite.


theorem CauSeq.lt_of_eq_of_lt :
    ∀ {α : Type u_1} [inst : LinearOrderedField α] {f g h : CauSeq α abs}, f ≈ g → g < h → f < h := by sorry

The theorem `CauSeq.lt_of_eq_of_lt` states that for any linear ordered field `α` and for any Cauchy sequences `f`, `g`, and `h` of `α` with respect to the absolute value, if `f` is equivalent to `g` and `g` is less than `h`, then `f` is less than `h`. Essentially, this theorem is about the transitivity of inequality for Cauchy sequences in a specific context.

For any linear ordered field `α` and Cauchy sequences `f`, `g`, and `h` of `α`, if `f` is equivalent to `g` and `g` is less than `h`, then `f` is less than `h`.


theorem Sum.comp_elim :
    ∀ {γ : Sort u_1} {δ : Sort u_2} {α : Type u_3} {β : Type u_4} (f : γ → δ) (g : α → γ) (h : β → γ),
      f ∘ Sum.elim g h = Sum.elim (f ∘ g) (f ∘ h) :=
  by sorry

The theorem `Sum.comp_elim` states that for any types `α`, `β`, `γ`, and `δ`, and for any functions `f : γ → δ`, `g : α → γ`, and `h : β → γ`, the composition of `f` with the function `Sum.elim g h` (which is defined on the sum type `α ⊕ β` and maps each `α` to `γ` via `g` and each `β` to `γ` via `h`) is equal to `Sum.elim (f ∘ g) (f ∘ h)`. This means that the functions `f` and `Sum.elim g h` commute, i.e., the order in which they are applied does not matter.

For any types `α`, `β`, `γ`, `δ`, and functions `f : γ → δ`, `g : α → γ`, and `h : β → γ`, the function composition `f ∘ Sum.elim g h` equals `Sum.elim (f ∘ g) (f ∘ h)` on the sum type `α ⊕ β`.


theorem le_ciSup_of_le :
    ∀ {α : Type u_1} {ι : Sort u_4} [inst : ConditionallyCompleteLattice α] {a : α} {f : ι → α},
      BddAbove (Set.range f) → ∀ (c : ι), a ≤ f c → a ≤ iSup f :=
  by sorry

This theorem states that for any type `α` with a conditionally complete lattice structure, a type `ι`, an `α`-valued function `f` mapping elements of type `ι`, and an element `a` of type `α`, if the range of the function `f` is bounded above, then for any element `c` of type `ι`, if `a` is less than or equal to `f(c)`, then `a` is also less than or equal to the supremum of the set of values that `f` can take. This supremum is obtained by first getting the range of the function `f` and then applying the supremum operation to this range.

For any conditionally complete lattice `α` and function `f` from type `ι` to `α` with a bounded above range, if `a ≤ f(c)` for some `c ∈ ι`, then `a ≤ sup (rang(f))`.


theorem Mathlib.Data.ENNReal.Inv._auxLemma.21 : ∀ {a b : ENNReal}, (a / b = 0) = (a = 0 ∨ b = ⊤) := by sorry

The theorem `Mathlib.Data.ENNReal.Inv._auxLemma.21` states that for all extended nonnegative real numbers `a` and `b`, the fraction `a / b` equals zero if and only if `a` equals zero or `b` equals positive infinity. Here, `ENNReal` represents the extended nonnegative real numbers, typically denoted as [0, ∞], and `⊤` represents positive infinity.

For all extended nonnegative real numbers `a` and `b`, `a / b = 0` if and only if `a = 0` or `b = ∞`.


/-- A space is totally disconnected iff its connected components are singletons.  -/
theorem totallyDisconnectedSpace_iff_connectedComponent_singleton :
    ∀ {α : Type u} [inst : TopologicalSpace α], TotallyDisconnectedSpace α ↔ ∀ (x : α), connectedComponent x = {x} := by
  sorry

This theorem states that a topological space is totally disconnected if and only if its connected components are singletons. More specifically, for any type `α` that represents a topological space, the space is totally disconnected (meaning that there does not exist a connected subset with more than one element) if and only if for all points `x` in the space, the connected component of `x` (which is the largest connected set containing `x`) is equal to the set containing `x` alone. This means that each point in the space forms a separate connected component by itself.

A topological space is totally disconnected if and only if every point belongs to a connected subset that is equal to the singleton set containing that point.


theorem PrimeSpectrum.isClosed_iff_zeroLocus :
    ∀ {R : Type u} [inst : CommSemiring R] (Z : Set (PrimeSpectrum R)),
      IsClosed Z ↔ ∃ s, Z = PrimeSpectrum.zeroLocus s :=
  by sorry

This theorem states that for any type `R` that is a commutative semiring, and any set `Z` of prime spectrums of `R`, `Z` is closed if and only if there exists some `s` such that `Z` is equal to the zero locus of `s` in the prime spectrum of `R`. In terms of algebraic geometry, it relates the topological property of being closed with the algebraic property of being the set of prime ideals that contain a given subset of the ring.

For a commutative semiring `R` and a set `Z` of its prime spectrum, `Z` is closed if and only if it is the zero locus of some element in the prime spectrum of `R`.


LocallyConvexSpace.ofBases

theorem LocallyConvexSpace.ofBases :
    ∀ (𝕜 : Type u_1) (E : Type u_2) [inst : OrderedSemiring 𝕜] [inst_1 : AddCommMonoid E] [inst_2 : Module 𝕜 E]
      [inst_3 : TopologicalSpace E] {ι : Type u_3} (b : E → ι → Set E) (p : E → ι → Prop),
      (∀ (x : E), Filter.HasBasis (nhds x) (p x) (b x)) →
        (∀ (x : E) (i : ι), p x i → Convex 𝕜 (b x i)) → LocallyConvexSpace 𝕜 E :=
  by sorry

The theorem `LocallyConvexSpace.ofBases` states that for any types `𝕜` and `E`, where `𝕜` is an ordered semiring, `E` is an additive commutative monoid and a module over `𝕜`, and `E` is also a topological space, and any types `ι`, `b` as a function mapping from `E` to `ι` and yielding a set of `E`, and `p` as a function mapping from `E` to `ι` and yielding a proposition, the following holds: If every point `x` in `E` has a neighborhood filter (a collection of neighborhoods of `x`) that has a basis described by `b` and `p`, and every `b` that is true under `p` is a convex set, then the type `E` is a locally convex space over `𝕜`.

In simpler terms, if every point in our space `E` has a filter whose bases are convex sets, then `E` is a locally convex space. This theorem bridges the concepts of topological spaces, filter bases, and convexity in a mathematical structure known as a locally convex space.

If every point in an additive commutative `𝕜`-module `E`, topological space, equipped with an ordered semiring `𝕜`, has a neighborhood filter with a convex basis, then `E` is a locally convex space over `𝕜`.


theorem le_mul_self : ∀ {α : Type u} [inst : CanonicallyOrderedCommMonoid α] {a b : α}, a ≤ b * a := by sorry

This theorem, `le_mul_self`, states that for any type `α` that is a canonically ordered commutative monoid, for any elements `a` and `b` of this type, `a` is less than or equal to the product of `b` and `a`. In other words, in a canonically ordered commutative monoid, multiplication by any element doesn't decrease the value of the original element.

In a commutative monoid endowed with a canonical order, for all elements `a` and `b`, we have `a <= b * a`.


theorem MeasureTheory.nullMeasurableSet_univ :
    ∀ {α : Type u_2} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α},
      MeasureTheory.NullMeasurableSet Set.univ μ :=
  by sorry

This theorem states that for any type `α`, any measurable space `m0` on `α`, and any measure `μ` on that measurable space, the universal set (the set of all elements in `α`) is a null-measurable set. In other words, the universal set can be approximated by a measurable set up to a set of null measure. This is a universal property of the universal set in the context of measure theory.

In measure theory, the universal set of any measurable space is null-measurable.


/-- The list version of `Multiset.le_iff_count`.  -/
theorem List.subperm_ext_iff :
    ∀ {α : Type u_1} [inst : DecidableEq α] {l₁ l₂ : List α},
      List.Subperm l₁ l₂ ↔ ∀ x ∈ l₁, List.count x l₁ ≤ List.count x l₂ :=
  by sorry

This theorem, named `List.subperm_ext_iff`, is about lists in Lean and is an analogue of the `Multiset.le_iff_count` for lists. It takes as input a type `α` with a given decidable equality and two lists `l₁` and `l₂` of this type. The theorem states that `l₁` is a sub-permutation of `l₂` (denoted as `List.Subperm l₁ l₂`) if and only if for every element `x` in `l₁`, the count of `x` in `l₁` is less than or equal to the count of `x` in `l₂`. In other words, `l₁` is a sub-permutation of `l₂` if every element of `l₁` appears in `l₂` at least as many times as it appears in `l₁`.

A list `l₁` is a sub-permutation of list `l₂` if and only if for every element `x` in `l₁`, the number of occurrences of `x` in `l₁` is less than or equal to the number of occurrences of `x` in `l₂`.


theorem Num.zneg_toZNumNeg : ∀ (n : Num), -Num.toZNumNeg n = Num.toZNum n := by sorry

The theorem `Num.zneg_toZNumNeg` states that for every number of type `Num`, the negation of the result of the function `toZNumNeg` applied to the number is equal to the result of the function `toZNum` applied to the same number. In other words, for all natural numbers `n`, negating the conversion of `n` to a negative `ZNum` yields the same result as directly converting `n` to a `ZNum`.

For every natural number `n`, `toZNum (toZNumNeg n)` equals `toZNumNeg n`.


theorem AddMonoidHom.map_finsum_of_injective :
    ∀ {M : Type u_2} {N : Type u_3} {α : Sort u_4} [inst : AddCommMonoid M] [inst_1 : AddCommMonoid N] (g : M →+ N),
      Function.Injective ⇑g → ∀ (f : α → M), g (finsum fun i => f i) = finsum fun i => g (f i) :=
  by sorry

This theorem states that for any types `M`, `N` and `α` (where `M` and `N` are commutative additive monoids), if we have an additive monoid homomorphism `g` from `M` to `N` that is injective, then for any function `f` from `α` to `M`, the value of `g` applied to the finite sum of `f` over all elements `i` of `α` is equal to the finite sum of `g(f(i))` over all elements `i` of `α`. In mathematical terms, this theorem is saying that the map `g` commutes with the finite sum operation.

If `g` is an injective additive monoid homomorphism from commutative additive monoid `M` to commutative additive monoid `N`, then for any function `f` from set `α` to `M`, `g(∑ i in α f i) = ∑ i in α g(f i)`.


theorem Set.le_chainHeight_iff :
    ∀ {α : Type u_1} [inst : LT α] {s : Set α} {n : ℕ},
      ↑n ≤ Set.chainHeight s ↔ ∃ l ∈ Set.subchain s, List.length l = n :=
  by sorry

The theorem `Set.le_chainHeight_iff` states that for any type `α` that has a less than relation (`LT α`), any set `s` of type `α`, and any natural number `n`, `n` is less than or equal to the chain height of set `s` if and only if there exists a list `l` in the subchains of set `s` such that the length of list `l` is `n`. In essence, this theorem relates the chain height of a set, which is the maximum length of a strictly ascending sequence in the set, with the existence of a strictly ascending list of specific length within the set.

The chain height of a set equals the length of a strict ascending sequence in it if and only if there exists such a sequence of length equal to a given natural number.


theorem Polynomial.taylor_taylor :
    ∀ {R : Type u_2} [inst : CommSemiring R] (f : Polynomial R) (r s : R),
      (Polynomial.taylor r) ((Polynomial.taylor s) f) = (Polynomial.taylor (r + s)) f :=
  by sorry

This theorem states that for any commutative semiring `R`, any polynomial `f` of `R`, and any two elements `r` and `s` of `R`, the Taylor expansion of `f` at `r` after the Taylor expansion at `s` is equal to the Taylor expansion of `f` at `r + s`. This implies that the order of Taylor expansions does not matter, and they can be combined into a single Taylor expansion at the sum of the original points.

For any commutative semiring `R`, given polynomials `f` and elements `r` and `s` of `R`, the Taylor expansions of `f` at `r` after the Taylor expansion at `s` and at `r + s` are equal.


theorem interior_subset_closure : ∀ {X : Type u} {s : Set X} [inst : TopologicalSpace X], interior s ⊆ closure s := by
  sorry

The theorem `interior_subset_closure` states that for any set `s` in a given topological space `X`, the interior of `s` is a subset of the closure of `s`. This is a fundamental theorem in topology that connects two important concepts: the interior of a set, which is the largest open subset contained within `s`, and the closure of a set, which is the smallest closed set containing `s`. The theorem, thus, provides a relationship between the 'open' and 'closed' aspects of a topological space.

The interior of a set is contained in its closure.


theorem Submodule.smul_mono :
    ∀ {R : Type u} {M : Type v} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {I J : Ideal R}
      {N P : Submodule R M}, I ≤ J → N ≤ P → I • N ≤ J • P :=
  by sorry

The theorem `Submodule.smul_mono` states that for any commutative semiring `R`, and any additive commutative monoid `M` that is also a module over `R`, if `I` and `J` are ideals in `R` and `N` and `P` are submodules of `M`, then if `I` is a subset of `J` and `N` is a subset of `P`, then `I` times `N` is a subset of `J` times `P`. In mathematical terms, this can be stated as: if `I ≤ J` and `N ≤ P`, then `I • N ≤ J • P`, where `•` represents the action of the ring on the module.

If `I` is an ideal contained in `J` and `N` is a submodule contained in `P` in a commutative semiring `R` with an additive commutative monoid `M` as a module, then `I` multiplied by `N` is a subset of `J` multiplied by `P`.


/-- The (open) thickening of a set contains the closure of the set.  -/
theorem Metric.closure_subset_thickening :
    ∀ {α : Type u} [inst : PseudoEMetricSpace α] {δ : ℝ}, 0 < δ → ∀ (E : Set α), closure E ⊆ Metric.thickening δ E := by
  sorry

This theorem states that, for any given type `α` that is a pseudo emetric space, for any real number `δ` that is greater than zero, and for any set `E` of type `α`, the closure of `E` is a subset of the `δ`-thickening of `E`. In other words, all the points in the topological closure of a set `E` are included within the open `δ`-thickening of `E`, which consists of points that are at a distance less than `δ` from some point of `E`.

For any pseudo metric space `α` and `δ` > 0, the closure of a set `E` in `α` is contained in the `δ`-thickening of `E`.


Matroid.Base.finite

theorem Matroid.Base.finite :
    ∀ {α : Type u_1} {M : Matroid α} {B : Set α} [inst : Matroid.FiniteRk M], M.Base B → Set.Finite B := by sorry

The theorem `Matroid.Base.finite` states that for any type `α`, any matroid `M` of type `α`, and any set `B` of type `α`, given an instance where the rank of the matroid `M` is finite (`Matroid.FiniteRk M`), if `B` is a base of the matroid `M` (`M.Base B`), then the set `B` is finite (`Set.Finite B`). Essentially, this theorem asserts that every base of a matroid with finite rank is a finite set.

If `M` is a matroid of finite rank over type `α`, then any base `B` of `M` is a finite set.


theorem Matrix.Commute.zpow_right :
    ∀ {n' : Type u_1} [inst : DecidableEq n'] [inst_1 : Fintype n'] {R : Type u_2} [inst_2 : CommRing R]
      {A B : Matrix n' n' R}, Commute A B → ∀ (m : ℤ), Commute A (B ^ m) :=
  by sorry

The theorem `Matrix.Commute.zpow_right` states that for any type `n'` with decidable equality and finite elements, any type `R` that is a commutative ring, and any two matrices `A` and `B` of type `Matrix n' n' R`, if `A` and `B` commute, then for any integer `m`, `A` commutes with `B` raised to the power of `m`. In other words, if the multiplication of two matrices `A` and `B` commutes (i.e., `A * B = B * A`), then the multiplication of `A` and the `m`-th power of `B` also commutes for any integer `m`.

If matrices `A` and `B` of size `n' x n'` over a commutative ring `R` with decidable equality and finite elements commute, then `A` commutes with the power `B^m` for any integer `m`.


theorem Real.ediam_Icc : ∀ (a b : ℝ), EMetric.diam (Set.Icc a b) = ENNReal.ofReal (b - a) := by sorry

This theorem, named `Real.ediam_Icc`, states that for any two real numbers `a` and `b`, the diameter of the set that is the left-closed right-closed interval from `a` to `b` is equal to the non-negative part of the difference `b - a`. In other words, in a set of real numbers where the set is an interval that includes both ends (`a` and `b`), the "distance" between the furthest apart elements in the set (which is the diameter) is exactly the non-negative difference between `b` and `a`. This distance is zero if `b - a` is negative and `b - a` otherwise.

The diameter of the interval [a, b] equals |b - a|.


theorem PowerSeries.order.proof_1 :
    ∀ {R : Type u_1} [inst : Semiring R] (φ : PowerSeries R), ¬φ = 0 → ∃ n, (PowerSeries.coeff R n) φ ≠ 0 := by sorry

The theorem `PowerSeries.order.proof_1` states that for any non-zero formal power series `φ` over a semiring `R`, there exists an integer `n` such that the `n`th coefficient of the power series is non-zero. This essentially means that every non-zero power series has a non-zero coefficient at some position.

Every non-zero formal power series over a semiring has a non-zero coefficient at some position.


theorem ProbabilityTheory.isProbabilityMeasureGamma :
    ∀ {a r : ℝ}, 0 < a → 0 < r → MeasureTheory.IsProbabilityMeasure (ProbabilityTheory.gammaMeasure a r) := by sorry

This theorem states that for all real numbers `a` and `r`, if both `a` and `r` are greater than zero, then the measure defined by the gamma distribution (i.e., `ProbabilityTheory.gammaMeasure a r`) is a probability measure. In other words, the gamma distribution with parameters `a` and `r`, when both are positive, qualifies as a probability measure under the rules of measure theory.

For all positive real numbers `a` and `r`, the gamma distribution `ProbabilityTheory.gammaMeasure a r` is a probability measure.


theorem BoxIntegral.Prepartition.mem_restrict :
    ∀ {ι : Type u_1} {I J J₁ : BoxIntegral.Box ι} (π : BoxIntegral.Prepartition I),
      J₁ ∈ BoxIntegral.Prepartition.restrict π J ↔ ∃ J' ∈ π, ↑J₁ = ↑J ⊓ ↑J' :=
  by sorry

The theorem `BoxIntegral.Prepartition.mem_restrict` states that for any type `ι`, and any three boxes `I`, `J`, and `J₁` of type `ι`, along with a prepartition `π` of box `I`, a box `J₁` is in the restricted prepartition of `π` to box `J` if and only if there exists a box `J'` in `π` such that the intersection of the boxes `J` and `J'` (in the underlying set) is equal to the underlying set of box `J₁`.

For any type ι, box I, prepartition π of I, and boxes J, J₁, J is in the restricted prepartition of π to J if and only if there exists a box J' in π such that J ∩ J' = J₁.


theorem Set.preimage_kernImage :
    ∀ {α : Type u_1} {β : Type u_2} {f : α → β}, GaloisConnection (Set.preimage f) (Set.kernImage f) := by sorry

The theorem `Set.preimage_kernImage` states that for any two types `α` and `β`, and any function `f` from `α` to `β`, there exists a Galois connection between the preimage function under `f` and the kernel image function of `f`. In other words, for any two sets `a` and `b`, `a` is a subset of the preimage of `b` under `f` if and only if `b` is a subset of the kernel image of `a` under `f`. This is a relationship between two operations on sets that is similar to adjoint functors in category theory.

For any function between types `f : α → β`, the preimage and kernel image functions `f⁁⁻¹` and `f.ker` form a Galois connection, that is, `a ⊆ f⁁⁻¹ b` if and only if `b ⊆ f.ker a`.


theorem Nat.totient_prime : ∀ {p : ℕ}, Nat.Prime p → Nat.totient p = p - 1 := by sorry

This theorem, `Nat.totient_prime`, states that for every natural number `p`, if `p` is prime, then the value of Euler's totient function at `p` is `p - 1`. Euler's totient function, denoted here as `Nat.totient`, counts the number of natural numbers strictly less than `p` which are coprime with `p`. In other words, the theorem shows that for any prime number `p`, there are `p - 1` numbers less than `p` that share no common factors with `p` apart from 1.

For every prime natural number `p`, the number of natural numbers less than `p` coprime to `p` equals `p - 1`.


HomogeneousIdeal.ext

theorem HomogeneousIdeal.ext :
    ∀ {ι : Type u_1} {σ : Type u_2} {A : Type u_4} [inst : Semiring A] [inst_1 : SetLike σ A]
      [inst_2 : AddSubmonoidClass σ A] {𝒜 : ι → σ} [inst_3 : DecidableEq ι] [inst_4 : AddMonoid ι]
      [inst_5 : GradedRing 𝒜] {I J : HomogeneousIdeal 𝒜},
      HomogeneousIdeal.toIdeal I = HomogeneousIdeal.toIdeal J → I = J :=
  by sorry

This theorem states that for any given types `ι`, `σ`, and `A` where `A` is a semiring, `σ` is a set-like structure in `A` and supports addition with a submonoid structure, `ι` has a decidable equality and addition structure, `𝒜` is a map from `ι` to `σ`, and a graded ring is defined over `𝒜`, then for any two homogeneous ideals `I` and `J` over `𝒜`, if their conversions to ideals in `A` (using the `HomogeneousIdeal.toIdeal` function) are equal, then the homogeneous ideals `I` and `J` are themselves equal. This theorem asserts the injectivity of the conversion operation from a homogeneous ideal to an ideal.

Given types `ι`, `σ`, and `A`, where `A` is a semiring, `σ` is a set-like semigroup over `A`, `ι` has decidable equality and addition, `𝒜 : ι → σ`, and a graded ring is defined over `𝒜`, the conversion function `HomogeneousIdeal.toIdeal` from homogeneous ideals over `𝒜` to ideals in `A` is injective.


theorem Nat.bitwise_zero_right :
    ∀ {f : Bool → Bool → Bool} (n : ℕ), Nat.bitwise f n 0 = if f true false = true then n else 0 := by sorry

The theorem `Nat.bitwise_zero_right` states that for any natural number `n` and any Boolean function `f`, applying the function `Nat.bitwise` with `f`, `n`, and `0` is equivalent to checking if `f true false` equals `true`. If `f true false` does equal `true`, then `Nat.bitwise f n 0` results in `n`, otherwise it results in `0`. In short, it establishes an important property of the `Nat.bitwise` function when the second natural number in the operation is zero.

The theorem `Nat.bitwise_zero_right` asserts that for all natural numbers `n` and Boolean functions `f`, `Nat.bitwise f n 0` equals `n` if and only if `f true false` equals `true`.


theorem MeasureTheory.Measure.exists_isOpen_measure_lt_top :
    ∀ {α : Type u_1} {m0 : MeasurableSpace α} [inst : TopologicalSpace α] (μ : MeasureTheory.Measure α)
      [inst_1 : MeasureTheory.IsLocallyFiniteMeasure μ] (x : α), ∃ s, x ∈ s ∧ IsOpen s ∧ ↑↑μ s < ⊤ :=
  by sorry

This theorem states that for any type `α` with a measurable space structure `m0` and a topological space structure, given a measure `μ` on `α` which is locally finite, for any point `x` in `α`, there exists a set `s` such that `x` belongs to `s`, `s` is an open set in the topological space, and the measure of `s` under `μ` is finite (strictly less than infinity).

For any measurable and locally finite measure `μ` on a type `α` with both measurable space and topological space structures, for every point `x` in `α`, there exists an open set `s` containing `x` with finite measure under `μ`.


LieEquiv.injective

theorem LieEquiv.injective :
    ∀ {R : Type u} {L₁ : Type v} {L₂ : Type w} [inst : CommRing R] [inst_1 : LieRing L₁] [inst_2 : LieRing L₂]
      [inst_3 : LieAlgebra R L₁] [inst_4 : LieAlgebra R L₂] (e : L₁ ≃ₗ⁅R⁆ L₂), Function.Injective ⇑e.toLieHom :=
  by sorry

The theorem `LieEquiv.injective` states that for all types `R`, `L₁`, and `L₂` such that `R` is a commutative ring, `L₁` and `L₂` are both Lie rings, and `L₁` and `L₂` are Lie algebras over `R`, if `e` is a Lie algebra equivalence from `L₁` to `L₂`, then the underlying function of the Lie homomorphism associated with `e` is injective. In other words, if two elements in `L₁` are mapped to the same element in `L₂` by `e`, then those two elements must have been the same to begin with.

If `e` is a Lie algebra equivalence between Lie rings `L₁` and `L₂` over a commutative ring `R`, then the underlying function of the associated Lie homomorphism is injective.


theorem Polynomial.content_C :
    ∀ {R : Type u_1} [inst : CommRing R] [inst_1 : IsDomain R] [inst_2 : NormalizedGCDMonoid R] {r : R},
      Polynomial.content (Polynomial.C r) = normalize r :=
  by sorry

This theorem states that for any commutative ring `R` which is also a domain and a normalized GCD monoid, and for any element `r` of `R`, the content of the constant polynomial `r` is equal to the normalization of `r`. In other words, the greatest common divisor (gcd) of the coefficients of the polynomial, which is simply `r` itself in this case, is equal to `r` multiplied by the norm unit of `r`. Here, the content function `Polynomial.content` computes the gcd of the coefficients of a polynomial, and the `normalize` function multiplies an element by its norm unit. The constant polynomial `r` is represented by `Polynomial.C r`, which is a ring homomorphism that takes an element of the ring and returns a constant polynomial with that element as the coefficient.

For any commutative domain and normalized GCD monoid ring `R` and its element `r`, the content (greatest common divisor of coefficients) of the constant polynomial `r` equals the normalization of `r` (`r` multiplied by its norm unit).


theorem Equiv.Perm.isoCycle'.proof_2 :
    ∀ {α : Type u_1} [inst : DecidableEq α] (s : { s // Cycle.Nodup s ∧ Cycle.Nontrivial s }),
      Equiv.Perm.IsCycle (Cycle.formPerm ↑s ⋯) :=
  by sorry

This theorem states that for any type `α` with a decidable equality property (`DecidableEq α`), given a cycle `s` that has no duplicates (`Cycle.Nodup s`) and is made up of at least two unique elements (`Cycle.Nontrivial s`), the permutation formed from this cycle (`Cycle.formPerm ↑s`) is itself a non-identity cycle (`Equiv.Perm.IsCycle`). In other words, any nontrivial cycle without duplicates can be interpreted as a non-identity permutation in such a way that any two nonfixed points of the permutation are related by repeated application of the permutation.

Given a decidably equal type `α` with a nontrivial, nodup cycle `s`, the permutation formed from `s` is a non-identity cycle.


theorem Equiv.Perm.isoCycle'.proof_1 :
    ∀ {α : Type u_1} (s : { s // Cycle.Nodup s ∧ Cycle.Nontrivial s }), Cycle.Nodup ↑s := by sorry

This theorem states that for any type α, if we have a cycle `s` which is a structure containing two properties - that the cycle has no duplicate elements (expressed as `Cycle.Nodup s`) and that the cycle consists of at least two unique elements (expressed as `Cycle.Nontrivial s`), then the property that the cycle has no duplicate elements (`Cycle.Nodup`) holds true for `s`. Essentially, it asserts that if a cycle is both nontrivial and contains no duplicates, then it indeed contains no duplicates.

If a cycle is nontrivial and has no duplicate elements, then it has no duplicate elements.


theorem Finset.smul_finset_inter :
    ∀ {α : Type u_2} {β : Type u_3} [inst : DecidableEq β] [inst_1 : Group α] [inst_2 : MulAction α β] {s t : Finset β}
      {a : α}, a • (s ∩ t) = a • s ∩ a • t :=
  by sorry

This theorem, `Finset.smul_finset_inter`, states that for any types `α` and `β`, given that `β` has a decidable equality, `α` forms a group and there's a multiplication action from `α` to `β`. If `s` and `t` are finite sets of type `β` and `a` is an element of type `α`, then the operation of scaling the intersection of `s` and `t` by `a` is equal to the intersection of individually scaling `s` and `t` by `a`. This is analogous to the distributive property of multiplication over intersection in set theory.

For any type `α` forming a group with decidable equality, and a multiplication action from `α` to type `β`, if `s` and `t` are finite sets of type `β`, then scaling the intersection of `s` and `t` by an element `a` in `α` is equal to the intersection of individually scaling `s` and `t` by `a`.


theorem eVariationOn.eq_zero_iff :
    ∀ {α : Type u_1} [inst : LinearOrder α] {E : Type u_2} [inst_1 : PseudoEMetricSpace E] (f : α → E) {s : Set α},
      eVariationOn f s = 0 ↔ ∀ x ∈ s, ∀ y ∈ s, edist (f x) (f y) = 0 :=
  by sorry

This theorem states that for any type `α` having a linear order and any type `E` in a pseudo emetric space, and for any function `f` from `α` to `E`, the extended real valued variation of `f` on a set `s` of `α` is zero if and only if the extended distance between the image of any two elements `x` and `y` in `s` under `f` is zero. In other words, the variation of the function `f` on the set `s` is zero precisely when `f` is constant on `s`.

For any function from a linearly ordered type to a pseudometric space, the variation of the function on a set is zero if and only if the images of any two distinct elements in the set have zero distance.


theorem LieModule.finite_weightSpace_ne_bot :
    ∀ (R : Type u_2) (L : Type u_3) (M : Type u_4) [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L]
      [inst_3 : LieAlgebra.IsNilpotent R L] [inst_4 : AddCommGroup M] [inst_5 : Module R M] [inst_6 : LieRingModule L M]
      [inst_7 : LieModule R L M] [inst_8 : NoZeroSMulDivisors R M] [inst_9 : IsNoetherian R M],
      Set.Finite {χ | LieModule.weightSpace M χ ≠ ⊥} :=
  by sorry

The theorem `LieModule.finite_weightSpace_ne_bot` states that for any commutative ring `R`, any Lie ring `L`, and any module `M` over `R`, if `L` is a nilpotent Lie algebra over `R`, `M` is an additive commutative group and a module over `R`, `L` acts on `M` making `M` a Lie module over `L` under `R`, `R` has no zero divisors when scalar multiplying `M`, and `M` is a Noetherian module over `R`, then the set of linear functionals (or weights) `χ` such that the weight space of `M` under `χ` is not the zero submodule is finite. In other words, there are only finitely many weights that give non-zero weight spaces, under the given conditions.

Given a commutative ring R, a Lie ring L over R, and an R-module M making M a Lie module over L under R such that L is nilpotent, M is a Noetherian, commutative additive group, and R has no zero divisors when scalar multiplying M, the set of weights χ for which the weight space of M under χ is non-zero is finite.


/-- If a field `F` is of exponential characteristic `q`, then `Polynomial.expand F (q ^ n) f`
and `f` have the same separable degree.  -/
theorem Polynomial.natSepDegree_expand :
    ∀ {F : Type u} [inst : Field F] (f : Polynomial F) (q : ℕ) [hF : ExpChar F q] {n : ℕ},
      Polynomial.natSepDegree ((Polynomial.expand F (q ^ n)) f) = Polynomial.natSepDegree f :=
  by sorry

The theorem `Polynomial.natSepDegree_expand` states that for any field `F` of exponential characteristic `q`, and for any polynomial `f` over `F`, if we expand `f` by a factor of `q^n` (where `n` is any natural number), the separable degree of the expanded polynomial is the same as the separable degree of the original polynomial. The separable degree of a polynomial is defined as the number of distinct roots it has over its splitting field. In other words, expansion by a factor of `q^n` does not change the number of unique roots of the polynomial.

For any polynomial `f` over a field of characteristic `q`, the separable degree of `f` equals the separable degree of `f` expanded by a factor of `q^n`.


theorem Function.update_sup :
    ∀ {ι : Type u_1} {π : ι → Type u_2} [inst : DecidableEq ι] [inst_1 : (i : ι) → SemilatticeSup (π i)]
      (f : (i : ι) → π i) (i : ι) (a b : π i),
      Function.update f i (a ⊔ b) = Function.update f i a ⊔ Function.update f i b :=
  by sorry

This theorem states that for a function `f` mapping from type `ι` to a semilattice `π i` (for different `i`), the operation of updating the function at a certain point `i` with the supremum (`⊔`; greatest lower bound) of two values `a` and `b` is the same as the supremum of updating the function at the same point `i` first with `a` and then with `b`. This holds for all `i`, `a`, and `b` in the respective domains and for all functions `f` from `ι` to `π i`. Here, `DecidableEq ι` means that equality between elements of type `ι` is decidable, and `SemilatticeSup (π i)` means that `π i` forms a semilattice with the supremum operation.

For any function `f` from a decidably equipped type `ι` to a semilattice `π i`, updating `f` at `i` with the supremum of `a` and `b` is equal to updating it first with `a` and then with `b`, for all `i`, `a`, and `b` in their respective domains.


theorem Equiv.summable_iff :
    ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : AddCommMonoid α] [inst_1 : TopologicalSpace α] {f : β → α}
      (e : γ ≃ β), Summable (f ∘ ⇑e) ↔ Summable f :=
  by sorry

The theorem `Equiv.summable_iff` states that for any three types `α`, `β`, `γ` where `α` is an additive commutative monoid and also a topological space, and given a function `f` from `β` to `α` and a bijection `e` from `γ` to `β`, the composition of `f` with `e` is summable if and only if `f` itself is summable. In other words, changing the domain of the summable function via a bijection doesn't affect its summability.

For any additive commutative monoid and topological space `α`, function `f` from a set `β` to `α`, and bijection `e` from `γ` to `β`, the composition of `f` with `e` is summable if and only if `f` is summable.


theorem Asymptotics.IsLittleO.trans_isTheta :
    ∀ {α : Type u_1} {E : Type u_3} {F : Type u_4} {G' : Type u_8} [inst : Norm E] [inst_1 : Norm F]
      [inst_2 : SeminormedAddCommGroup G'] {l : Filter α} {f : α → E} {g : α → F} {k : α → G'},
      f =o[l] g → g =Θ[l] k → f =o[l] k :=
  by sorry

This theorem states that for any types `α`, `E`, `F`, `G'` and any functions `f : α → E`, `g : α → F`, `k : α → G'` with respect to a filter `l`, if `f` is little-o of `g` and `g` is Theta of `k`, then `f` is little-o of `k`. Here, little-o (`f =o[l] g`) means `f` grows no quicker than `g` and Theta (`g =Θ[l] k`) means `g` grows at the same rate as `k`, in an asymptotic sense. The necessary conditions are that `E` and `F` are normed and `G'` is a seminormed additive commutative group.

If `f : α → E`, `g : α → F`, and `k : α → G'` are functions, `α` is any type, `E` and `F` are normed types, `G'` is a seminormed additive commutative group, `l` is a filter, `f =o[l] g` (`f` is little-o of `g`), and `g =Θ[l] k` (`g` is Theta of `k`), then `f =o[l] k` (`f` is little-o of `k`).


theorem NumberField.Units.dirichletUnitTheorem.unitLattice_span_eq_top :
    ∀ (K : Type u_1) [inst : Field K] [inst_1 : NumberField K],
      Submodule.span ℝ ↑(NumberField.Units.unitLattice K) = ⊤ :=
  by sorry

This theorem states that for any number field `K`, the span over the real numbers of the lattice formed by the image of the logarithmic embedding, referred as `NumberField.Units.unitLattice K`, is equal to the entire space, denoted by `⊤`. In other words, this theorem is asserting that the mentioned lattice spans the entire real number space for any given number field `K`.

For any number field `K`, the logarithmic embedding of `NumberField.Units.unitLattice K` spans the real numbers, i.e., their span equals the entire real number space.


theorem congrArg₂ :
    ∀ {α : Sort u_1} {β : Sort u_2} {γ : Sort u_3} (f : α → β → γ) {x x' : α} {y y' : β},
      x = x' → y = y' → f x y = f x' y' :=
  by sorry

The theorem `congrArg₂` states that for all types `α`, `β`, and `γ`, and a function `f` from `α` and `β` to `γ`, if `x` equals `x'` and `y` equals `y'`, then applying `f` to `x` and `y` is the same as applying `f` to `x'` and `y'`. In other words, if two pairs of inputs to a two-argument function are equal respectively, then the outputs of the function applied to these two pairs are also equal.

For all types α, β, γ and functions f : α → β → γ, if x = x' and y = y', then f x y = f x' y'.


theorem Rat.cast_id : ∀ (n : ℚ), ↑n = n := by sorry

This theorem asserts that for any rational number 'n', casting 'n' to a rational number results in 'n' itself. In other words, if a variable is already a rational number, casting it as a rational number doesn't change its value.

For any rational number 'n', the conversion of 'n' to a rational number yields the same value.


Differentiable.differentiableAt

theorem Differentiable.differentiableAt :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {f : E → F}
      {x : E}, Differentiable 𝕜 f → DifferentiableAt 𝕜 f x :=
  by sorry

The theorem `Differentiable.differentiableAt` states that for any non-trivially normed field `𝕜`, any normed additive commutative group `E` and `F`, any normed space over `𝕜` for `E` and `F`, any function `f` from `E` to `F`, and any point `x` in `E`, if the function is differentiable everywhere (`Differentiable 𝕜 f`), then it is also differentiable at the specific point `x` (`DifferentiableAt 𝕜 f x`). In mathematical terms, this means that if a function `f` is differentiable over its entire domain, then it admits a derivative at any particular point in its domain.

If a function is differentiable at every point in its domain over a non-trivially normed field, then it is differentiable at any specific point in its domain.


theorem Matrix.transpose_pow :
    ∀ {m : Type u_2} {α : Type v} [inst : CommSemiring α] [inst_1 : Fintype m] [inst_2 : DecidableEq m]
      (M : Matrix m m α) (k : ℕ), Matrix.transpose (M ^ k) = Matrix.transpose M ^ k :=
  by sorry

The theorem `Matrix.transpose_pow` states that for any type `m` and any type `α` that is a commutative semiring, if `m` is a finite type with decidable equality, then for any matrix `M` with indices and entries in `m` and `α` respectively and any natural number `k`, the transpose of `M` to the power `k` is equal to the transpose of `M` all to the power `k`. In simpler terms, raising a matrix to a power and then taking its transpose is the same as first taking the transpose and then raising the resulting matrix to the power.

For any finite commutative semiring type `m` with decidable equality, matrix `M` with indices in `m` and entries in a commutative semiring `α`, the transpose of `M` raised to the power `k` equals the power `k` of the transpose of `M`.


theorem AList.lookup_isSome :
    ∀ {α : Type u} {β : α → Type v} [inst : DecidableEq α] {a : α} {s : AList β},
      Option.isSome (AList.lookup a s) = true ↔ a ∈ s :=
  by sorry

This theorem states that for any type `α`, any type `β` that depends on `α`, any instance of decidable equality on `α`, and any key-value pair `a` and `s` of type `α` and `AList β` respectively, the function `Option.isSome` applied to the result of looking up `a` in `s` is `true` if and only if `a` is an element of `s`. In other words, it establishes a correspondence between the successful lookup of an element in an association list and the presence of that element in the list.

For any type `α`, any type `β`, and any association list `s : AList β` of pairs between type `α` and type `β`, the option type `Option.isSome (s.find ?a)` is equal to `true` if and only if `a` is an element of `s`.


theorem CategoryTheory.Limits.biproduct.ι_fromSubtype_assoc :
    ∀ {J : Type w} {C : Type u} [inst : CategoryTheory.Category.{v, u} C]
      [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] (f : J → C) [inst_2 : CategoryTheory.Limits.HasBiproduct f]
      (p : J → Prop) [inst_3 : CategoryTheory.Limits.HasBiproduct (Subtype.restrict p f)] (j : Subtype p) {Z : C}
      (h : ⨁ f ⟶ Z),
      CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.biproduct.ι (Subtype.restrict p f) j)
          (CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.biproduct.fromSubtype f p) h) =
        CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.biproduct.ι f ↑j) h :=
  by sorry

This theorem states that, for any types `J` and `C`, given a category structure on `C`, the presence of zero morphisms in `C`, a function `f` from `J` to `C`, and the existence of a biproduct for the function `f`, along with a property `p` on `J`, and the existence of a biproduct for the restricted function `f` to the subtype `p`, for any subtype `j` of `p` and any object `Z` of `C`, and a morphism `h` from the biproduct of `f` to `Z`, composing the inclusion morphism from `j` into the biproduct of the restricted function `f` to the subtype `p` with the composition of the morphism from the biproduct of the subtype `p` to the biproduct of `f` and the morphism `h`, is equal to the composition of the inclusion morphism from `j` into the biproduct of `f` and the morphism `h`. In simpler terms, this theorem asserts a certain commutativity property in the context of category theory and its notion of biproducts.

For any type `J`, category `C` with zero morphisms, function `f` from `J` to `C`, and biproduct `B` of `f`, given property `p` on `J`, subtype `j` of `p`, object `Z` of `C`, and morphism `h` from `B` to `Z`, the compositions of the inclusion morphism from `j` into `B` with the morphism from `B` to `Z` and the inclusion morphism from `j` into the biproduct of `f` to `p` with `h` are equal.


theorem lt_inf_iff : ∀ {α : Type u} [inst : LinearOrder α] {a b c : α}, a < b ⊓ c ↔ a < b ∧ a < c := by sorry

This theorem states that for any type `α` that has a linear order, and any three elements `a`, `b`, `c` of type `α`, `a` is less than the infimum (greatest lower bound) of `b` and `c` if and only if `a` is less than both `b` and `c`. This is expressed with the mathematical symbols as $a < \inf\{b, c\} \iff a < b \land a < c$.

For any linear order type `α` and elements `a`, `b`, `c` of type `α`, `a` is below the infimum of `b` and `c` if and only if `a` is below both `b` and `c`. In mathematical notation: $a < \inf\{b, c\} \iff a < b \land a < c$.


theorem Polynomial.IsSplittingField.finiteDimensional :
    ∀ {K : Type v} (L : Type w) [inst : Field K] [inst_1 : Field L] [inst_2 : Algebra K L] (f : Polynomial K)
      [inst_3 : Polynomial.IsSplittingField K L f], FiniteDimensional K L :=
  by sorry

This theorem states that for any field `K` and `L`, where `K` is an algebra over `L`, if a polynomial `f` defined over field `K` is a splitting field over `L`, then `L` is a finite dimensional vector space over `K`. Here, a polynomial is said to be a splitting field if it splits into linear factors (roots) in the field. The notion of finite dimensionality for a vector space implies that the vector space can be spanned by a finite set of vectors.

If a polynomial `f` over field `K` is a splitting field for `K` over `L`, then `L` is a finite-dimensional vector space over `K`.


theorem ENNReal.iUnion_Iic_coe_nat : ⋃ n, Set.Iic ↑n = {⊤}ᶜ := by sorry

This theorem states that the union over all natural numbers `n` of the sets of extended non-negative real numbers less than or equal to `n` (the union of left-infinite right-closed intervals) is equal to the set of all extended non-negative real numbers excluding positive infinity (`{⊤}ᶜ`). In other words, it asserts that every non-infinite extended non-negative real number is less than or equal to some natural number.

The set of all extended non-negative real numbers less than or equal to the union of the left-infinite right-closed intervals over all natural numbers is equal to the set of all finite extended non-negative real numbers, excluding positive infinity.


theorem Multiset.fold.proof_1 :
    ∀ {α : Type u_1} (op : α → α → α) [hc : Std.Commutative op] [ha : Std.Associative op], LeftCommutative op := by
  sorry

This theorem states that for all types `α`, given a binary operation `op` on `α`, if `op` is both commutative and associative, then `op` is also left commutative. In other words, for any two elements `a₁` and `a₂` of type `α` and any element `b` of the same type, the result of applying `op` on `a₁` and the result of applying `op` on `a₂` and `b` is the same as applying `op` on `a₂` and the result of applying `op` on `a₁` and `b`. This is expressed in Lean 4 by `h a₁ (h a₂ b) = h a₂ (h a₁ b)` where `h` is `op`.

If a binary operation `op` on type `α` is commutative and associative, then it is left commutative, i.e., `a₁ op a₂ = a₂ op a₁` for all `a₁, a₂ : α`.


theorem DirectSum.of_zero_smul :
    ∀ {ι : Type u_1} [inst : DecidableEq ι] (A : ι → Type u_2) [inst_1 : AddZeroClass ι]
      [inst_2 : (i : ι) → AddCommMonoid (A i)] [inst_3 : DirectSum.GNonUnitalNonAssocSemiring A] {i : ι} (a : A 0)
      (b : A i), (DirectSum.of A i) (a • b) = (DirectSum.of A 0) a * (DirectSum.of A i) b :=
  by sorry

The theorem `DirectSum.of_zero_smul` states that for any type `ι` with decidable equality and any function `A` from `ι` to some Type `u_2` (with additional structures of additive zero class, an additive commutative monoid for each `i : ι` and a non-unital and non-associative semiring structure for the direct sum of `A i`), for any elements `a` of `A 0` and `b` of `A i`, the operation of mapping the scaled value `(a • b)` by the natural inclusion map `DirectSum.of A i` is equivalent to multiplying the inclusion-map-transformed `a` and `b` where `a` is transformed via `DirectSum.of A 0` and `b` is transformed via `DirectSum.of A i`. In essence, this theorem associates the scalar multiplication in the additively commutative monoids with the multiplication in the non-unital, non-associative semiring.

For any additively commutative monoid `A` indexed by a decidably equalizable type `ι` with non-unital, non-associative semiring structure on its direct sum, the scalar multiplication of elements `a` and `b` in `A 0` and `A i`, respectively, is equal to the multiplication of their images under the inclusion maps in the semiring.


WellFounded.mono

theorem WellFounded.mono :
    ∀ {α : Type u_1} {r r' : α → α → Prop}, WellFounded r → (∀ (a b : α), r' a b → r a b) → WellFounded r' := by sorry

This theorem, `WellFounded.mono`, states that for any type `α` and any two binary relations `r` and `r'` on `α`, if `r` is a well-founded relation (i.e., it does not have any infinite descending chains) and for all `a` and `b` in `α`, `r' a b` implies `r a b`, then `r'` is also a well-founded relation. In other words, the well-foundedness of a relation can be transferred to another relation if the second relation is a subset of the first.

If `r` is a well-founded relation on type `α` and `r'` is a relation on `α` such that `r' ⊆ r`, then `r'` is also well-founded.


theorem Int.sub_sub_self : ∀ (a b : ℤ), a - (a - b) = b := by sorry

This theorem states that for all integers `a` and `b`, the result of subtracting `a - b` from `a` is always `b`. In other words, it's saying that if you take an integer `a`, subtract `b` from it, and then subtract this result from `a` again, you will always end up with `b`. In mathematical notation, this is expressed as `a - (a - b) = b` for all integers `a` and `b`.

The theorem asserts that for all integers `a` and `b`, `a - (a - b) = b`.


theorem NormedAddGroupHom.IsQuotient.norm_le :
    ∀ {M : Type u_1} {N : Type u_2} [inst : SeminormedAddCommGroup M] [inst_1 : SeminormedAddCommGroup N]
      {f : NormedAddGroupHom M N}, NormedAddGroupHom.IsQuotient f → ∀ (m : M), ‖f m‖ ≤ ‖m‖ :=
  by sorry

This theorem states that for any two types `M` and `N`, which are seminormed additive commutative groups, and any normed additive group homomorphism `f` from `M` to `N` that is a quotient map, the norm of `f(m)` is less than or equal to the norm of `m` for any element `m` in `M`. In mathematical terms, this means that the norm (denoted by ‖·‖) is a non-increasing function under the homomorphism `f`.

For any seminormed additive commutative groups M and N, and any normed additive group homomorphism f from M to N that is a quotient map, the map f preserves the norm, i.e., ‖f(m)‖ ≤ ‖m‖ for all m in M.


theorem ContinuousLinearMap.measurable_apply :
    ∀ {𝕜 : Type u_2} [inst : NontriviallyNormedField 𝕜] {E : Type u_3} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {F : Type u_4} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F]
      [inst_5 : MeasurableSpace F] [inst_6 : BorelSpace F] (x : E), Measurable fun f => f x :=
  by sorry

This theorem states that for any non-trivially normed field `𝕜`, normed additive commutative groups `E` and `F`, and a normed space over `𝕜` for `E` and `F` with `F` being a measurable space and a Borel space, for any element `x` from `E`, the function application that maps every continuous linear map `f` to `f x` is measurable. In other words, if `f` is a continuous linear map and `x` is a point in the domain, then the function that takes `f` to `f(x)` is measurable. This means that the preimage of any measurable set under this function is also a measurable set.

For any non-trivially normed field `𝕜`, if `E` and `F` are normed additive commutative groups and `F` is a measurable Borel space, then the function that maps every continuous linear map from `E` to `F` to its application to a fixed `x` in `E` is measurable.


/-- Product over a sigma type equals the product of fiberwise products. For rewriting
in the reverse direction, use `Finset.prod_sigma'`.   -/
theorem Finset.prod_sigma :
    ∀ {α : Type u_3} {β : Type u_4} [inst : CommMonoid β] {σ : α → Type u_6} (s : Finset α) (t : (a : α) → Finset (σ a))
      (f : Sigma σ → β),
      (Finset.prod (Finset.sigma s t) fun x => f x) =
        Finset.prod s fun a => Finset.prod (t a) fun s => f { fst := a, snd := s } :=
  by sorry

The theorem `Finset.prod_sigma` states that for a given finite set `s` of type `α`, a function `t` mapping each element of `α` to a finite set of some type `σ a`, and a function `f` mapping each dependent pair of type `Sigma σ` to the commutative monoid `β`, the product of `f x` over the set of dependent pairs (`Finset.sigma s t`) is equal to the product of the product of `f { fst := a, snd := s }` over the set `t a` for each element `a` in `s`. In simpler terms, it asserts that the product over a sigma type equals the product of fiberwise products.

For a finite set `s` and functions `t: α → Σ σ` and `f: Σ σ → β`, the product of `f` over `Finset.sigma s t` equals the product of the fiberwise products of `f` over each set `t a` for each `a` in `s`.


theorem ProbabilityTheory.IsMeasurableRatCDF.nonneg :
    ∀ {α : Type u_1} [inst : MeasurableSpace α] {f : α → ℚ → ℝ},
      ProbabilityTheory.IsMeasurableRatCDF f → ∀ (a : α) (q : ℚ), 0 ≤ f a q :=
  by sorry

This theorem states that for any measurable space `α` and any function `f` from `α` to the set of rational numbers `ℚ` and then to real numbers `ℝ`, if `f` is a measurable rational cumulative distribution function (`IsMeasurableRatCDF`), then the output of `f` for any `α` and `ℚ` is always non-negative. In other words, the value of the rational cumulative distribution function at any point is always greater than or equal to zero.

For any measurable space `α` and measurable rational cumulative distribution function `f` from `α` to the rational numbers `ℚ` and then to real numbers `ℝ`, `f(x) ≥ 0` for all `x ∈ α`.


theorem TopologicalSpace.Opens.mem_iSup :
    ∀ {α : Type u_2} [inst : TopologicalSpace α] {ι : Sort u_5} {x : α} {s : ι → TopologicalSpace.Opens α},
      x ∈ iSup s ↔ ∃ i, x ∈ s i :=
  by sorry

This theorem states that for any type `α` with a topology (`TopologicalSpace α`), any index type `ι`, any element `x` of `α`, and any mapping `s` from `ι` to the collection of open subsets of `α` (`TopologicalSpace.Opens α`), the element `x` belongs to the supremum of the indexed collection `s` if and only if there exists an index `i` such that `x` belongs to the open set `s i`. In simpler terms, a point is in the union of a collection of open sets if and only if it is in at least one of the open sets in the collection.

For any topological space `α`, index type `ι`, and mapping `s` from `ι` to the opens of `α`, an element `x` in `α` lies in the supremum of `s` if and only if there exists an index `i` such that `x` is in `s i`. (Alternatively, `x` belongs to the union of the `s(i)` for some `i`.)


Set.Nontrivial.mono

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

The theorem `Set.Nontrivial.mono` states that for any type `α` and for any sets `s` and `t` of type `α`, if `s` is a nontrivial set and `s` is a subset of `t`, then `t` is also a nontrivial set. Here, a set is considered nontrivial if it contains at least two distinct elements. In other words, the nontriviality of a set is preserved under taking subsets.

If `α` is a type, `s` is a nontrivial subset of `t` (both of type `α`), then `t` is also a nontrivial set.


theorem Set.restrictPreimage_surjective :
    ∀ {α : Type u_1} {β : Type u_2} (t : Set β) {f : α → β},
      Function.Surjective f → Function.Surjective (Set.restrictPreimage t f) :=
  by sorry

The theorem `Set.restrictPreimage_surjective` states that for any types `α` and `β`, any set `t` of type `β`, and any function `f` from `α` to `β`, if the function `f` is surjective, then the restriction of `f` onto the preimage of the set `t` is also surjective. In other words, given a surjective function `f : α → β` and a set `t` of elements in `β`, every element in `t` can be mapped from some element in the preimage of `t` under `f`, which is the subset of `α` that consists of all elements which map to elements in `t` under `f`.

If `f : α → β` is a surjective function and `t ⊆ β` is a set, then the restriction of `f` to `f⁻¹(t) ⊆ α` is also surjective onto `t`.