theorem Submodule.le_topologicalClosure :
    ∀ {R : Type u} {M : Type v} [inst : Semiring R] [inst_1 : TopologicalSpace M] [inst_2 : AddCommMonoid M]
      [inst_3 : Module R M] [inst_4 : ContinuousConstSMul R M] [inst_5 : ContinuousAdd M] (s : Submodule R M),
      s ≤ Submodule.topologicalClosure s :=
  by sorry

This theorem states that for any semiring `R`, type `M` with a topological space and additive commutative monoid structures, and `M` being a module over `R` where scalar multiplication is continuous, also addition is continuous, any submodule `s` of `M` is a subset of its topological closure. In other words, it implies that every element of a given submodule is also an element of its topological closure in the context of topological modules.

In a topological module over a semiring, every submodule is contained in its topological closure where scalar multiplication and addition are continuous.


theorem CategoryTheory.IsPushout.of_isBilimit :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X Y : C}
      [inst_1 : CategoryTheory.Limits.HasZeroObject C] [inst_2 : CategoryTheory.Limits.HasZeroMorphisms C]
      {b : CategoryTheory.Limits.BinaryBicone X Y},
      CategoryTheory.Limits.BinaryBicone.IsBilimit b → CategoryTheory.IsPushout 0 0 b.inl b.inr :=
  by sorry

This theorem states that for any category `C` with zero objects and zero morphisms, and any pair `X, Y` of objects in `C` forming a binary bicone `b`, if `b` is a bilimit in `C`, then the morphisms `b.inl` and `b.inr` form a pushout at the zero morphism. In the language of category theory, a pushout is a universal construction which is the categorical dual of a pullback, while a bilimit is a limit for a diagram indexed by a finite category.

Given a category with zero objects and morphisms, if a binary bicone in this category is a bilimit, then its two components form a pushout at the zero morphism.


theorem ZFSet.mem_sUnion_of_mem : ∀ {x y z : ZFSet}, y ∈ z → z ∈ x → y ∈ ⋃₀ x := by sorry

This theorem states that for any three sets `x`, `y`, and `z` in the ZFSet (which is the Zermelo-Fraenkel set theory universe), if `y` is an element of `z` and `z` is an element of `x`, then `y` is an element of the union over all elements of `x` (written as ⋃₀ `x` in Lean 4). This captures the intuitive idea from set theory that if a set is nested within another set which is in turn nested within a larger set, then the innermost set is also a part of the largest set when we take the union of all its elements.

If `y` is an element of `z` and `z` is an element of `x`, then `y` is an element of the union of `x`.


theorem Multiset.filter_cons_of_neg :
    ∀ {α : Type u_1} {p : α → Prop} [inst : DecidablePred p] {a : α} (s : Multiset α),
      ¬p a → Multiset.filter p (a ::ₘ s) = Multiset.filter p s :=
  by sorry

The theorem `Multiset.filter_cons_of_neg` states that for any type `α`, any decidable predicate `p` on `α`, any element `a` of type `α`, and any multiset `s` of elements of type `α`, if `a` does not satisfy the predicate `p`, then the multiset obtained by filtering `p` on the multiset formed by adding `a` to `s` is identical to the multiset obtained by just filtering `p` on `s`. In simpler words, if an element doesn't satisfy the predicate, adding it to the multiset doesn't change the result of the filter operation.

For any type `α`, decidable predicate `p` on `α`, element `a` of type `α`, and multiset `s` of elements of type `α`, if `a` does not satisfy `p`, then adding `a` to `s` does not affect the multiset obtained by filtering `p` on `s`. In other words, `Multiset.filter p (s : set α) = Multiset.filter p (a :: s)` whenever `p a` is false.


theorem Ordinal.card_add : ∀ (o₁ o₂ : Ordinal.{u_3}), Ordinal.card (o₁ + o₂) = Ordinal.card o₁ + Ordinal.card o₂ := by
  sorry

This theorem states that for any two ordinals `o₁` and `o₂`, the cardinality of the sum of `o₁` and `o₂` is equal to the sum of the cardinalities of `o₁` and `o₂`. In other words, the operation of taking the cardinality of an ordinal commutes with the addition of ordinals. This is analogous to the cardinality of the union of two disjoint sets being equal to the sum of their cardinalities in set theory.

The cardinality of the sum of two ordinals is equal to the sum of their cardinalities.


theorem ValuationRing.mem_integer_iff :
    ∀ (A : Type u) [inst : CommRing A] (K : Type v) [inst_1 : Field K] [inst_2 : Algebra A K] [inst_3 : IsDomain A]
      [inst_4 : ValuationRing A] [inst_5 : IsFractionRing A K] (x : K),
      x ∈ Valuation.integer (ValuationRing.valuation A K) ↔ ∃ a, (algebraMap A K) a = x :=
  by sorry

This theorem states that for any integral domain `A` (with `A` being a commutative ring and a domain), any field of fractions `K` of `A` (given the algebra structure from `A` to `K` and `K` being a field), and any element `x` from `K`, `x` belongs to the ring of integers under the valuation induced by the valuation ring of `A` if and only if there exists an element `a` from `A` such that `a` maps to `x` under the algebraic map from `A` to `K`. In other words, `x` is in the valuation ring if and only if it is the image of some integer under the canonical map from `A` to its fraction field `K`.

For any commutative domain `A` with a valuation ring, an element `x` in its field of fractions `K` belongs to the valuation ring if and only if there exists an integer `a` in `A` mapping to `x` under the canonical homomorphism from `A` to `K`.


/-- The point provided by `ContractingWith.fixedPoint` is actually a fixed point.  -/
theorem ContractingWith.fixedPoint_isFixedPt :
    ∀ {α : Type u_1} [inst : MetricSpace α] {K : NNReal} {f : α → α} (hf : ContractingWith K f) [inst_1 : Nonempty α]
      [inst_2 : CompleteSpace α], Function.IsFixedPt f (ContractingWith.fixedPoint f hf) :=
  by sorry

The theorem `ContractingWith.fixedPoint_isFixedPt` states that for any type `α` which is a metric space and any function `f` from `α` to `α` that is contracting with a non-negative real number `K`, given that `α` is nonempty and a complete space, the point provided by the function `ContractingWith.fixedPoint` is actually a fixed point of `f`. In other words, if `f` is a contracting function in a nonempty complete metric space, then the point determined by `ContractingWith.fixedPoint` satisfies the property that `f` of this point equals the point itself.

If `α` is a nonempty complete metric space and `f: α → α` is a contracting function with constant `K`, then the point returned by `ContractingWith.fixedPoint f` is a fixed point of `f`, i.e., `f (ContractingWith.fixedPoint f) = ContractingWith.fixedPoint f`.


theorem ENNReal.tsum_add :
    ∀ {α : Type u_1} {f g : α → ENNReal}, ∑' (a : α), (f a + g a) = ∑' (a : α), f a + ∑' (a : α), g a := by sorry

The theorem `ENNReal.tsum_add` states that for any type `α` and any two functions `f` and `g` from `α` to the extended nonnegative real numbers (`ENNReal`), the sum over all `α` of the sums of `f(a)` and `g(a)` is equal to the sum of the sum over all `α` of `f(a)` and the sum over all `α` of `g(a)`. This principle is essentially the distributive law of addition over summation, asserting that the sum of two series is equal to the series of their sums, where the series and the sums are in the extended nonnegative real numbers.

For any type `α` and functions `f` and `g` from `α` to the extended nonnegative real numbers (`ENNReal`), the sum of the pointwise sum of `f` and `g` over all `α` is equal to the sum of the sums of `f` and `g` over all `α`.


/-- Introduction rule to prove that `b` is the supremum of `f`: it suffices to check that `b`
is larger than `f i` for all `i`, and that this is not the case of any `w<b`.
See `iSup_eq_of_forall_le_of_forall_lt_exists_gt` for a version in complete lattices.  -/
theorem ciSup_eq_of_forall_le_of_forall_lt_exists_gt :
    ∀ {α : Type u_1} {ι : Sort u_4} [inst : ConditionallyCompleteLattice α] {b : α} [inst_1 : Nonempty ι] {f : ι → α},
      (∀ (i : ι), f i ≤ b) → (∀ w < b, ∃ i, w < f i) → ⨆ i, f i = b :=
  by sorry

This theorem, `ciSup_eq_of_forall_le_of_forall_lt_exists_gt`, states that for any type `α` that forms a conditionally complete lattice, and given any function `f` from a nonempty type `ι` to `α`, if `b` is a value in `α` such that `f i` is always less than or equal to `b` for all `i` in `ι`, and for any value `w` that is less than `b`, there exists an `i` such that `w` is less than `f i`, then `b` is the supremum (or least upper bound) of `f`. In other words, `b` is the smallest value that is greater than or equal to all values of `f`, and there is no value less than `b` that has this property. This theorem is a rule that can be used to prove that a value is the supremum of a function in a conditionally complete lattice structure.

For any conditionally complete lattice `α` and function `f` from a nonempty type `ι` to `α`, if for all `i` in `ι`, `f i` is less than or equal to `b`, and for every `w` less than `b`, there exists an `i` with `w` less than `f i`, then `b` is the supremum (least upper bound) of `f`.


/-- An angle in a right-angled triangle expressed using `arctan`.  -/
theorem InnerProductGeometry.angle_add_eq_arctan_of_inner_eq_zero :
    ∀ {V : Type u_1} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] {x y : V},
      ⟪x, y⟫_ℝ = 0 → x ≠ 0 → InnerProductGeometry.angle x (x + y) = Real.arctan (‖y‖ / ‖x‖) :=
  by sorry

This theorem states that in a right-angled triangle, the angle can be expressed using the `arctan` function, given that the inner product of two vectors `x` and `y` is zero and vector `x` is not zero. More formally, for any normed add commutative group `V` that is also an inner product space over the real numbers, and any two vectors `x` and `y` in `V`, if the inner product of `x` and `y` is zero (indicating that they are orthogonal) and `x` is not the zero vector, then the angle between `x` and the vector obtained by adding `x` and `y` is equal to the `arctan` of the ratio of the norms of `y` and `x`. This corresponds to the trigonometric concept that in a right-angled triangle, the tangent of an angle is the ratio of the lengths of the opposite side to the adjacent side.

In a right-angled triangle with orthogonal vectors x and y, the angle between x and y is equal to the arctangent of the ratio of the norms of y and x.


theorem Set.ordConnectedProj.proof_1 :
    ∀ {α : Type u_1} [inst : LinearOrder α] (s : Set α) (x : ↑s), Set.Nonempty (Set.ordConnectedComponent s ↑x) := by
  sorry

This theorem states that for any type `α` that has a linear order and for any set `s` of type `α`, if `x` is an element of this set `s`, then the order-connected component of `x` in `s` is non-empty. In other words, there exists at least one element `y` such that the set of all points between `x` and `y` (inclusive) is a subset of `s`.

Given a type `α` with a linear order and a set `s` of `α`, for each `x` in `s`, there exists `y` in `s` such that the interval [`x`, `y`] is included in `s`.


theorem hasSum_subtype_iff_indicator :
    ∀ {α : Type u_1} {β : Type u_2} [inst : AddCommMonoid α] [inst_1 : TopologicalSpace α] {f : β → α} {a : α}
      {s : Set β}, HasSum (f ∘ Subtype.val) a ↔ HasSum (Set.indicator s f) a :=
  by sorry

This theorem establishes a relationship between the summability of a function `f` over a subset `s` of a type `β`, and the summability of the indicator function of `s` applied to `f`. Specifically, it states that for any types `α` and `β`, with `α` being an additive commutative monoid and also a topological space, a function `f` from `β` to `α`, a value `a` of type `α`, and a set `s` of type `β`, the function `f` has a sum `a` over the elements of `s` if and only if the indicator function of `s` applied to `f` has a sum `a`. The indicator function is defined such that it equals `f` at each point in `s` and `0` elsewhere.

For any additive commutative monoid and topological space type β, function f from β to an additive commutative monoid α, value a of type α, and set s of type β, the function f has a sum a over s if and only if the indicator function of s applied to f has a sum a.


IsClosedMap.comp

theorem IsClosedMap.comp :
    ∀ {X : Type u_1} {Y : Type u_2} {Z : Type u_3} {f : X → Y} {g : Y → Z} [inst : TopologicalSpace X]
      [inst_1 : TopologicalSpace Y] [inst_2 : TopologicalSpace Z],
      IsClosedMap g → IsClosedMap f → IsClosedMap (g ∘ f) :=
  by sorry

The theorem `IsClosedMap.comp` states that for any three types `X`, `Y`, and `Z` with associated topological spaces, if `f` is a closed map from `X` to `Y` and `g` is a closed map from `Y` to `Z`, then the composition of `g` and `f` (denoted by `g ∘ f`) is also a closed map from `X` to `Z`. In other words, the property of being a closed map is preserved under function composition in topological spaces.

If `f` is a closed map from `X` to `Y` and `g` is a closed map from `Y` to `Z`, then the composition `g ∘ f` is a closed map from `X` to `Z` in topological spaces.


theorem Submodule.mem_toAddSubmonoid :
    ∀ {R : Type u} {M : Type v} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] (p : Submodule R M)
      (x : M), x ∈ p.toAddSubmonoid ↔ x ∈ p :=
  by sorry

The theorem `Submodule.mem_toAddSubmonoid` states that for any semiring `R`, any additive commutative monoid `M` that is also a module over `R`, any submodule `p` of `M`, and any element `x` of `M`, `x` is a member of the additive submonoid associated with `p` if and only if `x` is a member of `p` itself. Essentially, it establishes the equivalence of membership between a submodule and its corresponding additive submonoid in the context of module theory.

For any semiring R, additive commutative monoid and R-module M, submodule p, and element x of M, x belongs to the additive submonoid of p if and only if x belongs to p.


ProbabilityTheory.kernel.Indep.symm

theorem ProbabilityTheory.kernel.Indep.symm :
    ∀ {α : Type u_1} {Ω : Type u_2} {_mα : MeasurableSpace α} {m₁ m₂ _mΩ : MeasurableSpace Ω}
      {κ : ↥(ProbabilityTheory.kernel α Ω)} {μ : MeasureTheory.Measure α},
      ProbabilityTheory.kernel.Indep m₁ m₂ κ μ → ProbabilityTheory.kernel.Indep m₂ m₁ κ μ :=
  by sorry

This theorem states that in probability theory, the independence of two measurable spaces with respect to a kernel and a measure is symmetric. Given two measurable spaces `m₁` and `m₂`, a measurable space `α` with its corresponding measure `μ`, and a kernel `κ` from `α` to `Ω` (the outcome space), if `m₁` and `m₂` are independent with respect to `κ` and `μ`, then `m₂` and `m₁` are also independent with respect to `κ` and `μ`.

If measurable spaces `m₁` and `m₂` are independent with respect to a kernel `κ` and measure `μ`, then `m₂` and `m₁` are also independent with respect to `κ` and `μ`.


theorem AffineSubspace.WSameSide.trans_wOppSide :
    ∀ {R : Type u_1} {V : Type u_2} {P : Type u_4} [inst : LinearOrderedField R] [inst_1 : AddCommGroup V]
      [inst_2 : Module R V] [inst_3 : AddTorsor V P] {s : AffineSubspace R P} {x y z : P},
      AffineSubspace.WSameSide s x y → AffineSubspace.WOppSide s y z → y ∉ s → AffineSubspace.WOppSide s x z :=
  by sorry

The theorem `AffineSubspace.WSameSide.trans_wOppSide` states that given an affine subspace `s` and three points `x`, `y`, and `z`, if `x` and `y` are weakly on the same side of `s` and `y` and `z` are weakly on opposite sides of `s`, and if `y` does not belong to `s`, then `x` and `z` are weakly on opposite sides of `s`.

In more detail, the "weakly on the same side" relation means that there exist two points in the subspace such that the vectors from each of these points to `x` and `y` are on the same ray (line passing through the origin). The "weakly on opposite sides" relation means that there exist two points in the subspace such that the vectors from each of these points to `y` and `z` are on the same ray, but pointed in opposite directions.

Given an affine subspace and three points x, y, z such that x and y are weakly on the same side and y and z are weakly on opposite sides with y not belonging to the subspace, then x and z are weakly on opposite sides of the subspace.


theorem Filter.map_map₂_antidistrib :
    ∀ {α : Type u_1} {α' : Type u_2} {β : Type u_3} {β' : Type u_4} {γ : Type u_5} {δ : Type u_7} {m : α → β → γ}
      {f : Filter α} {g : Filter β} {n : γ → δ} {m' : β' → α' → δ} {n₁ : β → β'} {n₂ : α → α'},
      (∀ (a : α) (b : β), n (m a b) = m' (n₁ b) (n₂ a)) →
        Filter.map n (Filter.map₂ m f g) = Filter.map₂ m' (Filter.map n₁ g) (Filter.map n₂ f) :=
  by sorry

This theorem states that for any types `α`, `α'`, `β`, `β'`, `γ`, and `δ`; a binary function `m : α → β → γ`; two filters `f : Filter α` and `g : Filter β`; a unary function `n : γ → δ`; a reversed binary function `m' : β' → α' → δ`; and two unary functions `n₁ : β → β'` and `n₂ : α → α'`, if for every pair of elements `(a : α, b : β)`, the function `n` applied to the result of `m a b` equals the result of `m'` applied to `n₁ b` and `n₂ a`, then the filter obtained by mapping `n` over the filter obtained from mapping the binary function `m` over filters `f` and `g` equals the filter obtained by mapping the binary function `m'` over the filters obtained from mapping `n₁` over `g` and `n₂` over `f`.

If for all `a : α` and `b : β`, `n(m a b) = m' (n₁ b) (n₂ a)` implies `(n ∘ f) = (m' ∘ (n₁ ∘ g) ∘ n₂) ∘ f`, then `(n ∘ (m ∘ (f × g))) = (m' ∘ (n₁ ∘ g) ∘ n₂) ∘ f`.


/-- A subgroup is finitely generated if and only if it is finitely generated as a submonoid.  -/
theorem Subgroup.fg_iff_submonoid_fg :
    ∀ {G : Type u_3} [inst : Group G] (P : Subgroup G), Subgroup.FG P ↔ Submonoid.FG P.toSubmonoid := by sorry

The theorem `Subgroup.fg_iff_submonoid_fg` states that for any group `G`, a subgroup `P` of `G` is finitely generated if and only if `P` is finitely generated when considered as a submonoid. Here, a subgroup (or submonoid) is finitely generated if it can be expressed as the closure of a finite subset of the group (or monoid).

A subgroup of a group is finitely generated if and only if considered as a submonoid, it is finitely generated.


theorem MeasureTheory.OuterMeasure.mkMetric'.le_pre :
    ∀ {X : Type u_2} [inst : EMetricSpace X] {m : Set X → ENNReal} {r : ENNReal} {μ : MeasureTheory.OuterMeasure X},
      μ ≤ MeasureTheory.OuterMeasure.mkMetric'.pre m r ↔ ∀ (s : Set X), EMetric.diam s ≤ r → ↑μ s ≤ m s :=
  by sorry

This theorem states that for any type `X` equipped with an `EMetricSpace` structure, a function `m` from sets of `X` to the extended nonnegative real numbers `ENNReal`, a real number `r`, and an outer measure `μ` on `X`, the outer measure `μ` is less than or equal to the maximal outer measure `MeasureTheory.OuterMeasure.mkMetric'.pre m r`, if and only if for all sets `s` of `X`, if the diameter of `s` (given by `EMetric.diam s`) is less than or equal to `r`, then the measure of `s` under `μ` (given by `↑μ s`) is less than or equal to `m s`. In other words, this theorem provides an equivalence between the inequality of two measures and a property about the diameter of all sets.

For any `EMetricSpace` `X` with an `ENNReal-valued` measure `μ` and a function `m` from sets of `X` to `ENNReal`, real number `r`, if `μ(s) ≤ MeasureTheory.OuterMeasure.mkMetric'.pre m r` for all sets `s` with `EMetric.diam s ≤ r`, then `μ ≤ m` as outer measures.


theorem FractionalIdeal.mul_le :
    ∀ {R : Type u_1} [inst : CommRing R] {S : Submonoid R} {P : Type u_2} [inst_1 : CommRing P] [inst_2 : Algebra R P]
      {I J K : FractionalIdeal S P}, I * J ≤ K ↔ ∀ i ∈ I, ∀ j ∈ J, i * j ∈ K :=
  by sorry

The theorem `FractionalIdeal.mul_le` states that for any commutative ring `R` with a submonoid `S`, and any type `P` that is also a commutative ring and an `R`-algebra, for any fractional ideals `I`, `J`, and `K` of `S` in `P`, the product of `I` and `J` is less than or equal to `K` if and only if for every element `i` in `I` and every element `j` in `J`, the product of `i` and `j` is an element of `K`. In other words, the product of two fractional ideals is contained within another fractional ideal if and only if every product of an element from each of the two fractional ideals is contained within the third fractional ideal.

For commutative rings R with submonoid S, and R-algebras P containing S, two fractional ideals I and J of S in P have the property that I * J ≤ K if and only if i * j ∈ K for all i ∈ I and j ∈ J.


theorem Multiset.toFinset_val :
    ∀ {α : Type u_1} [inst : DecidableEq α] (s : Multiset α), (Multiset.toFinset s).val = Multiset.dedup s := by sorry

This theorem, `Multiset.toFinset_val`, states that for all types `α` that have decidable equality and for all multisets `s` of type `α`, the underlying value (i.e., list of elements) of the finset obtained by applying the `toFinset` function to `s` is the same as the multiset obtained by applying the `dedup` function to `s`. In other words, it asserts that the process of converting a multiset to a finset effectively removes duplicates, resulting in a multiset with no duplicated elements.

For all types `α` with decidable equality and for all multisets `s` of type `α`, the `toFinset` function applied to `s` yields the same underlying list as applying `dedup` to `s`.


theorem CategoryTheory.ShortComplex.opcyclesMap'_comp :
    ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
      {S₁ S₂ S₃ : CategoryTheory.ShortComplex C} (φ₁ : S₁ ⟶ S₂) (φ₂ : S₂ ⟶ S₃)
      (h₁ : CategoryTheory.ShortComplex.RightHomologyData S₁) (h₂ : CategoryTheory.ShortComplex.RightHomologyData S₂)
      (h₃ : CategoryTheory.ShortComplex.RightHomologyData S₃),
      CategoryTheory.ShortComplex.opcyclesMap' (CategoryTheory.CategoryStruct.comp φ₁ φ₂) h₁ h₃ =
        CategoryTheory.CategoryStruct.comp (CategoryTheory.ShortComplex.opcyclesMap' φ₁ h₁ h₂)
          (CategoryTheory.ShortComplex.opcyclesMap' φ₂ h₂ h₃) :=
  by sorry

The theorem `CategoryTheory.ShortComplex.opcyclesMap'_comp` states that for any category `C` that has zero morphisms, given three short complexes `S₁`, `S₂`, and `S₃` in `C`, and morphisms `φ₁ : S₁ ⟶ S₂` and `φ₂ : S₂ ⟶ S₃`, the composition of the op-cycles maps induced by `φ₁` and `φ₂` is equal to the op-cycles map induced by the composition of `φ₁` and `φ₂`. Here, the op-cycles map is a specific map associated to a morphism in the category of short complexes, and the right homology data `h₁`, `h₂`, and `h₃` are associated to the short complexes `S₁`, `S₂`, and `S₃` respectively. The theorem thus establishes an important property about the interaction between morphism composition and the op-cycles map in the context of short complexes.

For any category `C` with zero morphisms, given three short complexes `S₁`, `S₂`, `S₃` and morphisms `φ₁ : S₁ ⟶ S₂` and `φ₂ : S₂ ⟶ S₃`, the op-cycles maps induced by their composition are equal to the composition of the op-cycles maps induced by each morphism.


theorem List.nodup_sublists' : ∀ {α : Type u} {l : List α}, List.Nodup (List.sublists' l) ↔ List.Nodup l := by sorry

The theorem `List.nodup_sublists'` states that for any given list `l` of an arbitrary type `α`, the list `l` has no duplicates if and only if the list of all non-contiguous sublists of `l` also has no duplicates. In other words, a list and its sublists share the same "no duplicate" property. This means, if any element appears at most once in `l`, then in the list of all non-contiguous sublists of `l`, each sublist also appears at most once, and vice versa.

For any list `l` of type `α`, `l` has no duplicates if and only if every non-contiguous sublist of `l` also has no duplicates.


theorem disjoint_nhds_atBot :
    ∀ {α : Type u} [inst : Preorder α] [inst_1 : NoBotOrder α] [inst_2 : TopologicalSpace α]
      [inst_3 : ClosedIicTopology α] (a : α), Disjoint (nhds a) Filter.atBot :=
  by sorry

This theorem states that for any type `α` that has a preorder structure, does not have a minimal element (NoBotOrder), has a topological structure, and where the interval semi-open to the left (ClosedIicTopology) is a closed set, the neighborhood filter at an element `a` of `α` (denoted as `nhds a`) and the filter representing the limit towards negative infinity (`Filter.atBot`) are disjoint. Disjointness here means that their infimum is the bottom element. In other words, there is no common smaller element between a neighborhood of `a` and the set of all elements that are less than or equal to any given element in the type `α`.

For any type `α` with a NoBotOrder preorder, a topology making ClosedIicTopology intervals closed, and without a minimal element, the neighborhood filter of an element `a` is disjoint from the filter representing the limit towards negative infinity, i.e., their infimum is the bottom element.


AddMonoid.closure.isAddSubmonoid

theorem AddMonoid.closure.isAddSubmonoid :
    ∀ {M : Type u_1} [inst : AddMonoid M] (s : Set M), IsAddSubmonoid (AddMonoid.Closure s) := by sorry

This theorem states that for any given type `M` that forms an `AddMonoid`, and for any set `s` of elements of type `M`, the closure of `s` under the operation of the `AddMonoid` forms an `AddSubmonoid`. In other words, if you start with a set of elements in an additive monoid and include all the elements that can be obtained by adding elements from that set, the resulting set is guaranteed to be an additive submonoid of the original monoid.

Given an additive monoid `M` and a subset `s` of `M`, the closure of `s` under the `AddMonoid` operation forms an additive submonoid.


/-- A set stable by supremum is `≤`-directed.  -/
theorem directedOn_of_sup_mem :
    ∀ {α : Type u} [inst : SemilatticeSup α] {S : Set α},
      (∀ ⦃i j : α⦄, i ∈ S → j ∈ S → i ⊔ j ∈ S) → DirectedOn (fun x x_1 => x ≤ x_1) S :=
  by sorry

This theorem states that for any type `α` that has a `SemilatticeSup` instance (meaning that it has a supremum operation defined), any set `S` of elements of this type is directed under the `≤` relation if and only if the supremum of any pair of elements in `S` is also in `S`. In other words, if the set `S` is closed under taking supremum, then for any pair of elements in `S`, there exists an element in `S` that is greater than or equal to both of the elements in the pair.

For any type `α` with a `SemilatticeSup` instance, a set `S` of `α` is directed if and only if it is closed under taking suprema.


theorem OneMemClass.coe_one :
    ∀ {A : Type u_4} {M₁ : Type u_5} [inst : SetLike A M₁] [inst_1 : One M₁] [hA : OneMemClass A M₁] (S' : A), ↑1 = 1 :=
  by sorry

This theorem, `OneMemClass.coe_one`, asserts that for any types `A` and `M₁`, if `A` behaves like a set of `M₁`, and `M₁` has an identity element under a certain operation, and there exists a class `OneMemClass` such that the number 1 is in this class, then the identity element is 1 when coe-function is applied on 1. In essence, it's stating that if we coerce the number 1 (in the context of a certain class and type conditions), it will remain 1.

If `A` is a set-like type, `M₁` has an identity element `e` for some operation, and `1` is in class `OneMemClass`, then `coe (1 : M₁) = e`.


theorem CategoryTheory.OverPresheafAux.YonedaCollection.mk_fst :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {A : CategoryTheory.Functor Cᵒᵖ (Type v)}
      {F : CategoryTheory.Functor (CategoryTheory.CostructuredArrow CategoryTheory.yoneda A)ᵒᵖ (Type v)} {X : C}
      (s : CategoryTheory.yoneda.obj X ⟶ A) (x : F.obj (Opposite.op (CategoryTheory.CostructuredArrow.mk s))),
      CategoryTheory.OverPresheafAux.YonedaCollection.fst (CategoryTheory.OverPresheafAux.YonedaCollection.mk s x) =
        s :=
  by sorry

This theorem states that for any category `C`, functor `A` from the opposite category of `C` to the category of types, a functor `F` from the opposite category of costructured arrows from the Yoneda embedding to `A` to the category of types, and an object `X` of `C`, if we have a natural transformation `s` from the Yoneda functor at `X` to `A`, and an object `x` of the functor `F` at the opposite of a costructured arrow constructed from `s`, then the first component of the YonedaCollection constructed from `s` and `x` is `s`. In other words, the first component of a YonedaCollection is the natural transformation used to construct it.

For any category C, functor A from C��opp to Type, functor F from (C��opp ⥤ Arrows (Yoneda C)) to Type, object X of C, natural transformation s from Yoneda X to A, and object x of F at the opposite of a constructed arrow from s, the first component of the YonedaCollection constructed from s and x is s.


theorem List.mem_union_iff :
    ∀ {α : Type u_1} [inst : BEq α] [inst_1 : LawfulBEq α] {x : α} {l₁ l₂ : List α}, x ∈ l₁ ∪ l₂ ↔ x ∈ l₁ ∨ x ∈ l₂ := by
  sorry

This theorem states that for any type `α`, under the conditions that `α` has an equality test (`BEq α`) and that this equality test is lawful (`LawfulBEq α`), an element `x` of type `α` is in the union of two lists (`l₁ ∪ l₂`) if and only if `x` is in the first list `l₁` or in the second list `l₂`. In mathematical terms, given two lists `l₁` and `l₂`, an element `x` is a member of the union of `l₁` and `l₂` if and only if `x` is a member of `l₁` or `l₂`.

For any type `α` with lawful equality `BEq α`, an element `x` belongs to the union of two lists `l₁ ∪ l₂` if and only if `x` is in `l₁` or `l₂`.


theorem CategoryTheory.transferNatTransSelf_comp :
    ∀ {C : Type u₁} {D : Type u₂} [inst : CategoryTheory.Category.{v₁, u₁} C]
      [inst_1 : CategoryTheory.Category.{v₂, u₂} D] {L₁ L₂ L₃ : CategoryTheory.Functor C D}
      {R₁ R₂ R₃ : CategoryTheory.Functor D C} (adj₁ : L₁ ⊣ R₁) (adj₂ : L₂ ⊣ R₂) (adj₃ : L₃ ⊣ R₃) (f : L₂ ⟶ L₁)
      (g : L₃ ⟶ L₂),
      CategoryTheory.CategoryStruct.comp ((CategoryTheory.transferNatTransSelf adj₁ adj₂) f)
          ((CategoryTheory.transferNatTransSelf adj₂ adj₃) g) =
        (CategoryTheory.transferNatTransSelf adj₁ adj₃) (CategoryTheory.CategoryStruct.comp g f) :=
  by sorry

This theorem, `CategoryTheory.transferNatTransSelf_comp`, concerns the composition of natural transformations in the context of category theory. More specifically, for any two categories `C` and `D`, and functors `L₁`, `L₂`, `L₃`, `R₁`, `R₂`, `R₃` between these categories, if `L₁`, `L₂`, `L₃` are left adjoint to `R₁`, `R₂`, `R₃` respectively, and there exist morphisms `f : L₂ ⟶ L₁` and `g : L₃ ⟶ L₂`, then the composition of the transferred natural transformations from `adj₁` to `adj₂` and from `adj₂` to `adj₃` is equal to the transferred natural transformation from `adj₁` to `adj₃` of the composition of the morphisms `g` and `f`. This highlights that the operation of transferring natural transformations respects the composition of morphisms.

Given functors `L₁`, `L₂`, `L₃`, `R₁`, `R₂`, `R₃` between categories `C` and `D` with `L₁ ⊣ R₁`, `L₂ ⊣ R₂`, `L₃ ⊣ R₃`, if there exist morphisms `f : L₂ ⟶ L₁` and `g : L₃ ⟶ L₂`, then the transferred natural transformations `adj₁ ∘ adj₂` and `adj₁ ∘ adj₃ ∘ (g ∘ f)` are equal.


theorem Equiv.swap_mul_self : ∀ {α : Type u} [inst : DecidableEq α] (i j : α), Equiv.swap i j * Equiv.swap i j = 1 := by
  sorry

The theorem `Equiv.swap_mul_self` states that for any type `α` that has decidable equality, and any two elements `i` and `j` of `α`, the permutation that swaps `i` and `j` twice is equal to the identity permutation. In other words, performing the swap operation twice will result in the original configuration, leaving all elements unchanged.

For any type `α` with decidable equality, the swap permutation `i j => j i` is equal to the identity permutation on `α`.


theorem Nat.prod_factorial_dvd_factorial_sum :
    ∀ {α : Type u_1} (s : Finset α) (f : α → ℕ),
      (Finset.prod s fun i => Nat.factorial (f i)) ∣ Nat.factorial (Finset.sum s fun i => f i) :=
  by sorry

The theorem `Nat.prod_factorial_dvd_factorial_sum` states that for any finite set `s` and any function `f` mapping elements of `s` to natural numbers, the factorial of the sum of the function values - `Nat.factorial (Finset.sum s fun i => f i)` - is divisible by the product of the factorials of each function value - `Finset.prod s fun i => Nat.factorial (f i)`. In other words, the product of the factorials of a set of numbers divides the factorial of the sum of those numbers.

For any finite set and function mapping its elements to natural numbers, the factorial of the sum of function values is divisible by the product of the factorial of each function value.


theorem SimplicialObject.Splitting.cofan_inj_eq :
    ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] {X : CategoryTheory.SimplicialObject C}
      (s : SimplicialObject.Splitting X) {Δ : SimplexCategoryᵒᵖ} (A : SimplicialObject.Splitting.IndexSet Δ),
      CategoryTheory.Limits.Cofan.inj (SimplicialObject.Splitting.cofan s Δ) A =
        CategoryTheory.CategoryStruct.comp (s.ι (SimplexCategory.len A.fst.unop))
          (X.map (SimplicialObject.Splitting.IndexSet.e A).op) :=
  by sorry

The theorem `SimplicialObject.Splitting.cofan_inj_eq` states that for any category `C`, any simplicial object `X` in `C`, any splitting `s` of `X`, any `Δ` in the opposite simplex category, and any index set `A` associated to `Δ`, the injection from the `A`th object of `Δ` into the cofan of `s` at `Δ` is equal to the composition of the `ι` component of `s` applied to the length of the first component of `A` with the mapping of the simplicial object `X` applied to the epimorphism associated to `A`. This theorem relates the structure of the cofan to the structure of the splitting in the category of simplicial objects.

For any simplicial object X in a category C, any splitting s of X, and any epimorphism A in the opposite simplex category with domain Δ and image the i-th object of Δ, the injection from the image of A under the cofan of s at Δ is equal to the composition of s(i) with the mapping of X from the source of A.


theorem neg_add_lt_iff_lt_add :
    ∀ {α : Type u} [inst : AddGroup α] [inst_1 : LT α]
      [inst_2 : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x < x_1] {a b c : α}, -b + a < c ↔ a < b + c :=
  by sorry

This theorem states that, for any type `α` that is an additive group and has a less than operation (`LT`), and for any three elements `a`, `b`, and `c` of this type, the inequality `-b + a < c` is equivalent to `a < b + c`. This is specified under the condition that `α` has a CovariantClass with respect to addition and the less than operation, which is a way of saying that `α` behaves in a certain way with respect to these two operations.

For any additive group `α` with a less than operation, the inequalities `-b + a < c` and `a < b + c` are equivalent.


theorem map_eq_zero :
    ∀ {M₀ : Type u_2} {G₀ : Type u_3} {F : Type u_6} [inst : MonoidWithZero M₀] [inst_1 : GroupWithZero G₀]
      [inst_2 : Nontrivial M₀] [inst_3 : FunLike F G₀ M₀] [inst_4 : MonoidWithZeroHomClass F G₀ M₀] (f : F) {a : G₀},
      f a = 0 ↔ a = 0 :=
  by sorry

This theorem, `map_eq_zero`, states that for all types `M₀`, `G₀`, and `F`, given that `M₀` is a monoid with a zero element, `G₀` is a group with a zero element, `M₀` is nontrivial (has at least two distinct elements), `F` is a function-like from `G₀` to `M₀`, and `F` is a homomorphism from a monoid with a zero element to another monoid with zero, for any function `f` of type `F` and any element `a` of `G₀`, `f a` equals zero if and only if `a` equals zero. In less formal terms, this theorem states that under these conditions, a homomorphism from a group with zero to a monoid with zero sends an element to zero if and only if the element itself is zero.

Given a homomorphism `F` from a group `G₀` with identity `e` to a monoid `M₀` with identity and zero `0`, if `F(e) = 0` and `F(a) = 0` for some `a` in `G₀`, then `a = e`.


theorem eq_sub_iff_add_eq' : ∀ {G : Type u_3} [inst : AddCommGroup G] {a b c : G}, a = b - c ↔ c + a = b := by sorry

This theorem states that for any three elements `a`, `b`, and `c` in an additive commutative group `G`, `a` equals `b` subtracted by `c` if and only if `c` added to `a` equals `b`. This theorem leverages the commutative and inverse properties of addition in such groups.

For all elements `a`, `b`, and `c` in an additive commutative group, `a = b - c` if and only if `a + c = b`.


theorem Ordinal.log_zero_right : ∀ (b : Ordinal.{u_1}), Ordinal.log b 0 = 0 := by sorry

The theorem `Ordinal.log_zero_right` states that for any ordinal `b`, the ordinal logarithm of `0` base `b` is `0`. In other words, in the context of ordinals, the logarithm of `0` to any base is `0`, similar to how the logarithm of `1` to any base is `0` in real numbers.

For any ordinal `b`, the ordinal logarithm of `0` base `b` equals `0`.


theorem Multiset.filter_cons_of_pos :
    ∀ {α : Type u_1} {p : α → Prop} [inst : DecidablePred p] {a : α} (s : Multiset α),
      p a → Multiset.filter p (a ::ₘ s) = a ::ₘ Multiset.filter p s :=
  by sorry

The theorem `Multiset.filter_cons_of_pos` states that for any type `α`, any decidable predicate `p` over `α`, any element `a` of type `α`, and any multiset `s` of type `α`, if `a` satisfies the predicate `p`, then filtering the multiset formed by adding `a` to `s` with the predicate `p` results in a multiset where `a` is added to the multiset obtained by filtering `s` with `p`. In other words, if we have a multiset `s` and an element `a` that satisfies a certain condition `p`, then the filtered multiset where `a` is added to `s` is the same as the multiset where `a` is added to the filtered `s`.

For any type `α`, decidable predicate `p` over `α`, element `a` of type `α`, and multiset `s` of type `α`, if `a ∈ s.filter (p)`, then `a ∈ (s.filter (p) : set α).insert a`.


theorem Equiv.infinite_iff : ∀ {α : Sort u_1} {β : Sort u_2}, α ≃ β → (Infinite α ↔ Infinite β) := by sorry

This theorem states that for any two types `α` and `β`, if `α` is equivalent to `β` (denoted as `α ≃ β`), then `α` is infinite if and only if `β` is infinite. In the context of set theory, two types are equivalent if there is a bijection between them. Therefore, this theorem essentially says that the property of being infinite is preserved under bijection.

If `α` is equivalent to `β` (`α ≃ β`), then `α` is infinite if and only if `β` is infinite.


theorem CategoryTheory.id_nonzero :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] (X : C)
      [inst_2 : CategoryTheory.Simple X], CategoryTheory.CategoryStruct.id X ≠ 0 :=
  by sorry

This theorem, `CategoryTheory.id_nonzero`, states that for any category `C` that has zero morphisms and any object `X` in `C` which is simple (i.e., has no non-trivial direct summands), the identity morphism on `X` is not a zero morphism. In other words, the identity morphism on a simple object in a category with zero morphisms is always nonzero.

In any category with zero morphisms, the identity morphism of a simple object is non-zero.


theorem Submodule.mkQ_apply :
    ∀ {R : Type u_1} {M : Type u_2} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] (p : Submodule R M)
      (x : M), (Submodule.mkQ p) x = Submodule.Quotient.mk x :=
  by sorry

The theorem `Submodule.mkQ_apply` states that for any ring `R`, any additive commutative group `M` that is also an `R`-module, and any submodule `p` of `M`, the function `Submodule.mkQ` applied to an element `x` of `M` is equal to the function `Submodule.Quotient.mk` applied to the same element `x`. In other words, the mapping from a module `M` to the quotient of `M` by a submodule `p` as a linear map, when applied to an element of the module, yields the same result as the map associating to an element of `M` the corresponding element of `M/p`, where `p` is a submodule of `M`.

For any ring `R`, additive commutative group `M` that is an `R`-module, and submodule `p` of `M`, the application of `Submodule.mkQ` to an element `x` of `M` is equivalent to the application of `Submodule.Quotient.mk` to `x`, i.e., `Submodule.mkQ x = Submodule.Quotient.mk x` in `M/p`.


theorem Lagrange.degree_interpolate_lt :
    ∀ {F : Type u_1} [inst : Field F] {ι : Type u_2} [inst_1 : DecidableEq ι] {s : Finset ι} {v : ι → F} (r : ι → F),
      Set.InjOn v ↑s → Polynomial.degree ((Lagrange.interpolate s v) r) < ↑s.card :=
  by sorry

The theorem `Lagrange.degree_interpolate_lt` states that for any field `F`, any type `ι` with decidable equality, any finite set `s` of type `ι`, any function `v` from `ι` to `F` that is injective on `s`, and any function `r` from `ι` to `F`, the degree of the polynomial obtained by interpolating `r` using the Lagrange method with nodes given by `v` on the set `s` is strictly less than the cardinality of `s`. This means that the Lagrange interpolation polynomial is of degree less than the number of nodes.

For any injective function `v` mapping a finite set `s` to a field `F`, the degree of the Lagrange interpolation polynomial of `F`-valued function `r` using `v` is strictly less than the cardinality of `s`.


theorem EReal.coe_ennreal_strictMono : StrictMono ENNReal.toEReal := by sorry

The theorem `EReal.coe_ennreal_strictMono` states that the function `ENNReal.toEReal`, which is the canonical map from nonnegative extended real numbers (`ENNReal`) to extended real numbers (`EReal`), is strictly monotone. In other words, for any two nonnegative extended real numbers `a` and `b`, if `a` is less than `b`, then the image of `a` under the function `ENNReal.toEReal` is less than the image of `b` under the same function.

The function `ENNReal.toEReal` maps nonnegative extended real numbers to extended real numbers strictly increasing their values.


theorem PosNum.succ'_pred' : ∀ (n : PosNum), Num.succ' (PosNum.pred' n) = n := by sorry

This theorem states that for every positive number 'n', the successor of the predecessor of 'n' is 'n' itself. Here, the successor and predecessor functions are defined for types `Num` (which includes zero and positive numbers) and `PosNum` (which includes only positive numbers), respectively. In mathematical terms, it means for all positive numbers 'n', `n = succ(pred(n))`, where `succ` and `pred` are functions that get the successor and the predecessor of a number, respectively. This theorem essentially ensures the correctness of these functions in the context of positive numbers.

For every positive number 'n', the predecessor of its successor is 'n' itself. (Or, more mathematically, `pred(succ(n)) = n` for all positive numbers 'n'.).


theorem MeasureTheory.condexp_zero :
    ∀ {α : Type u_1} {F' : Type u_3} [inst : NormedAddCommGroup F'] [inst_1 : NormedSpace ℝ F']
      [inst_2 : CompleteSpace F'] {m m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α},
      MeasureTheory.condexp m μ 0 = 0 :=
  by sorry

The theorem `MeasureTheory.condexp_zero` states that for any types `α` and `F'`, where `F'` is a normed additive commutative group and also a real normed space, and `α` is associated with two measurable spaces `m` and `m0` and a measure `μ`, the conditional expectation of the zero function (a function that maps every element of `α` to zero in `F'`) is always the zero function, regardless of the underlying measurable spaces and measure. In mathematical terms, this is saying that $E[0 | \mathcal{F}] = 0$, where $E$ denotes the expectation, 0 denotes the zero function and $\mathcal{F}$ denotes the σ-algebra.

For any measurable spaces `m` and `m0` with measure `μ`, and any normed additive commutative group `F'` that is also a real normed space, the conditional expectation of the zero function from `α` to `F'` is the zero function.


theorem not_irreducible_zero : ∀ {α : Type u_1} [inst : MonoidWithZero α], ¬Irreducible 0 := by sorry

This theorem states that zero is not irreducible for any type `α` provided that `α` is a monoid with zero. In mathematical terms, an element in a monoid is called irreducible if it is non-zero and cannot be expressed as a product of two non-unit elements. Thus, according to this theorem, zero does not meet these criteria and is therefore not considered irreducible in the context of a monoid with zero.

In a monoid with zero, zero is not an irreducible element.


theorem abs_mul_self : ∀ {α : Type u_1} [inst : LinearOrderedRing α] (a : α), |a * a| = a * a := by sorry

This theorem states that for any element 'a' from a linearly ordered ring 'α', the absolute value of the product of 'a' and itself is equal to the product of 'a' and itself. This is essentially saying that the square of any number in a linearly ordered ring is always non-negative, hence taking the absolute value doesn't change its value.

For any element 'a' in a linearly ordered ring, |a^2| = |a| \* |a|.


theorem HomologicalComplex.homologyMap_comp :
    ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_3, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
      {ι : Type u_2} {c : ComplexShape ι} {K L M : HomologicalComplex C c} (φ : K ⟶ L) (ψ : L ⟶ M) (i : ι)
      [inst_2 : HomologicalComplex.HasHomology K i] [inst_3 : HomologicalComplex.HasHomology L i]
      [inst_4 : HomologicalComplex.HasHomology M i],
      HomologicalComplex.homologyMap (CategoryTheory.CategoryStruct.comp φ ψ) i =
        CategoryTheory.CategoryStruct.comp (HomologicalComplex.homologyMap φ i) (HomologicalComplex.homologyMap ψ i) :=
  by sorry

The theorem `HomologicalComplex.homologyMap_comp` establishes the associativity of homology maps in a homological complex. Specifically, given a category `C` with zero morphisms, and `K`, `L`, and `M` as homological complexes in `C`, along with morphisms `φ` from `K` to `L` and `ψ` from `L` to `M`, for any index `i` such that `K`, `L`, and `M` all have homology at `i`, the composition of the homology maps corresponding to `φ` and `ψ` is equal to the homology map corresponding to the composition of `φ` and `ψ`. In mathematical notation, this can be represented as `(φ * ψ)_* = φ_* * ψ_*`, where `_ *` denotes the homology map of a morphism.

For homological complexes $K$, $L$, $M$ in a category with zero morphisms and morphisms $\varphi: K \to L$ and $\psi: L \to M$, the homology maps satisfy $(\varphi \circ \psi)_\ast = \varphi_\ast \circ \psi_\ast$.


theorem lt_isLUB_iff :
    ∀ {α : Type u} [inst : LinearOrder α] {s : Set α} {a b : α}, IsLUB s a → (b < a ↔ ∃ c ∈ s, b < c) := by sorry

This theorem states that for any type `α` with a linear order, and any set `s` of type `α`, and any two elements `a` and `b` of type `α`, if `a` is a least upper bound of `s`, then `b` is less than `a` if and only if there exists an element `c` in `s` such that `b` is less than `c`. In other words, an element `b` is less than the least upper bound `a` of a set `s` precisely when there is an element `c` in the set `s` that `b` fails to exceed.

For any linear order `α`, set `s` of type `α`, and elements `a` and `b` of type `α`, if `a` is the least upper bound of `s`, then `b` is strictly less than `a` if and only if there exists an element `c` in `s` such that `b` is strictly less than `c`.


theorem AlternatingMap.coe_injective :
    ∀ {R : Type u_1} [inst : Semiring R] {M : Type u_2} [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {N : Type u_3}
      [inst_3 : AddCommMonoid N] [inst_4 : Module R N] {ι : Type u_7}, Function.Injective DFunLike.coe :=
  by sorry

The theorem `AlternatingMap.coe_injective` states that for any semiring `R`, any type `M` with the structure of an `R`-module and an additive commutative monoid, any type `N` also with the structure of an `R`-module and an additive commutative monoid, and any type `ι`, the coercion from `DFunLike` to a function is injective. In other words, if two `DFunLike` objects have the same function when coerced, then they were originally the same `DFunLike` object.

For any semirings R, types M and N with R-module and additive commutative monoid structures, and type ι, the coercion from DFunLike (R-module M x additive commutative monoid) to (M ⟹ N) is injective.


theorem Ideal.top_mul : ∀ {R : Type u} [inst : CommSemiring R] (I : Ideal R), ⊤ * I = I := by sorry

This theorem states that for any given commutative semiring 'R' and any ideal 'I' in 'R', the product of the top element (denoted by '⊤') of the semiring and the ideal 'I' is equal to 'I' itself. In the context of rings and ideals, the top element '⊤' typically represents the whole ring. Therefore, this theorem essentially asserts that multiplying the whole ring with any ideal results in the ideal.

For any commutative semiring 'R' and ideal 'I', we have '⊤ * I = I'.


theorem Int.lt_iff_add_one_le : ∀ (a b : ℤ), a < b ↔ a + 1 ≤ b := by sorry

This theorem states that for any two integers `a` and `b`, `a` is less than `b` if and only if `a + 1` is less than or equal to `b`. This is a fundamental concept in the notion of ordering on the integers, reflecting that the next integer after `a` (`a+1`) is either equal to `b` or precedes `b`.

For all integers a and b, a < b if and only if a + 1 <= b.


theorem Set.Iic_union_Ici : ∀ {α : Type u_1} [inst : LinearOrder α] {a : α}, Set.Iic a ∪ Set.Ici a = Set.univ := by
  sorry

The theorem `Set.Iic_union_Ici` states that for any type `α` that has a linear order and any element `a` of type `α`, the union of the set of all elements that are less than or equal to `a` (`Set.Iic a`) and the set of all elements that are greater than or equal to `a` (`Set.Ici a`) is the universal set (`Set.univ`). This means that every element in `α` is either less than or equal to `a`, or greater than or equal to `a`, which covers the entirety of `α`.

For any linearly ordered type `α` and element `a` in `α`, `Set.Iic a ∪ Set.Ici a = Set.univ`.


theorem PNat.natPred_strictMono : StrictMono PNat.natPred := by sorry

The theorem `PNat.natPred_strictMono` states that the function `PNat.natPred`, which calculates the predecessor of a positive natural number (turns it into a natural number), is strictly monotone. This means that for any two distinct positive natural numbers `a` and `b`, if `a` is less than `b`, then `PNat.natPred a` is also less than `PNat.natPred b`.

The function `PNat.natPred` strictly decreases positive natural numbers, i.e., for all distinct `a` and `b` in `PNat` with `a < b`, `PNat.natPred a < P Nat.natPred b`.


theorem smul_ite :
    ∀ {α : Type u_4} {β : Type u_5} [inst : SMul β α] (p : Prop) [inst_1 : Decidable p] (a b : α) (c : β),
      (c • if p then a else b) = if p then c • a else c • b :=
  by sorry

This theorem states that for any given types `α` and `β`, if there's a scalar multiplication function between `β` and `α`, and a decidable proposition `p`, and instances `a` and `b` of `α` and `c` of `β`, then scalar multiplication distributes over the if-then-else statement based on proposition `p`. In other words, multiplying `c` with the result of the if-then-else operation on `a` and `b` (based on `p`) is the same as applying the if-then-else operation on the scalar multiplications of `c` with `a` and `b` (based on `p`).

For any types `α` and `β` with a scalar multiplication function, and proposition `p` decidable over `α`, if `c ∈ β` and `a, b ∈ α`, then `c * (if h : p then a else b) = if h then (c * a) else (c * b)`.


/-- The second of two points lies in their affine span.  -/
theorem right_mem_affineSpan_pair :
    ∀ (k : Type u_1) {V : Type u_2} {P : Type u_3} [inst : Ring k] [inst_1 : AddCommGroup V] [inst_2 : Module k V]
      [inst_3 : AddTorsor V P] (p₁ p₂ : P), p₂ ∈ affineSpan k {p₁, p₂} :=
  by sorry

The theorem `right_mem_affineSpan_pair` states that, for any field `k`, if `P` is a space of points with an associated vector space `V` (where `V` is a module over `k` and `P` is an affine space for `V`), and if `p₁` and `p₂` are any two points in `P`, then `p₂` is contained in the affine span of the set `{p₁, p₂}`. In other words, the second of two points always lies within the smallest affine subspace containing both of these points.

For any affine space $P$ over a field $k$ and any two points $p\_1, p\_2 \in P$, $p\_2$ lies in the affine span of $\{p\_1, p\_2\}$.


/-- Entourages are neighborhoods of the diagonal.  -/
theorem nhds_le_uniformity : ∀ {α : Type ua} [inst : UniformSpace α] (x : α), nhds (x, x) ≤ uniformity α := by sorry

This theorem states that for any type `α` equipped with a uniform space structure and any element `x` of `α`, the neighborhood filter of the pair `(x, x)` is less than or equal to the uniformity of `α`. In simpler terms, this is saying that the neighborhoods of the diagonal are also a part of the uniformity structure. In the context of topology, a uniformity provides a precise notion of "closeness" between points, while neighborhoods are sets that contain an open set around a particular point. Therefore, the theorem establishes an important relationship between these two key concepts.

For any uniform space `(α, υ)`, the neighborhood filter of the diagonal `{(x, x) | x ∈ α}` is included in the uniformity `υ`.


theorem isOpen_gt' :
    ∀ {α : Type u} [inst : TopologicalSpace α] [inst_1 : Preorder α] [t : OrderTopology α] (a : α),
      IsOpen {b | b < a} :=
  by sorry

The theorem `isOpen_gt'` states that for any type `α` that has a topological space structure, a preorder (a binary relation that is reflexive and transitive), and an order topology (a topology induced by a total order), and for any element `a` of type `α`, the set of all elements `b` such that `b` is less than `a` is an open set in the given topological space. This is a statement about order topologies and clarifies their properties with respect to open sets.

For any type `α` with a topological space structure, a preorder, and an order topology, the subset of elements less than any given element `a` is an open set.


theorem aux_hasSum_of_le_geometric :
    ∀ {α : Type u_1} [inst : PseudoMetricSpace α] {r C : ℝ},
      r < 1 →
        ∀ {f : ℕ → α}, (∀ (n : ℕ), dist (f n) (f (n + 1)) ≤ C * r ^ n) → HasSum (fun n => C * r ^ n) (C / (1 - r)) :=
  by sorry

This theorem, `aux_hasSum_of_le_geometric`, states that for any type `α` in a pseudo metric space, given a real number `r` less than 1 and any real number `C`, for any function `f` from natural numbers to `α`, if the distance between `f(n)` and `f(n+1)` is less than or equal to `C * r^n` for all natural numbers `n`, then the series of `C * r^n` converges (or has a sum) and the sum is `C / (1 - r)`. This theorem essentially formalizes a particular case of the geometric series convergence condition in the context of a pseudo metric space.

In a pseudo metric space, if the distance between successive terms of a function is less than or equal to a constant times the previous term raised to the power of each index, then the sum of the series formed by those terms converges to the constant divided by (1 minus the common ratio).


theorem Submonoid.le_comap_map :
    ∀ {M : Type u_1} {N : Type u_2} [inst : MulOneClass M] [inst_1 : MulOneClass N] (S : Submonoid M) {F : Type u_4}
      [inst_2 : FunLike F M N] [mc : MonoidHomClass F M N] {f : F}, S ≤ Submonoid.comap f (Submonoid.map f S) :=
  by sorry

The theorem `Submonoid.le_comap_map` states that for any submonoid `S` in a given `MulOneClass` `M`, and any function `f` of type `F` that is a monoid homomorphism from `M` to another `MulOneClass` `N` (as ensured by `FunLike F M N` and `MonoidHomClass F M N`), the submonoid `S` is a subset (or equal to) the preimage under `f` of the image of `S` under `f`. In other words, application of the function `f` to the submonoid `S` followed by taking the preimage under `f` does not remove any elements from `S`. The theorem encapsulates a fundamental property of submonoids under homomorphic images and their preimages.

For any submonoid S of a MulOneClass M and any monoid homomorphism f from M to another MulOneClass N, the image of S under f is contained in the preimage of f(S) under f.


theorem zpow_le_of_le :
    ∀ {α : Type u_1} [inst : LinearOrderedSemifield α] {a : α} {m n : ℤ}, 1 ≤ a → m ≤ n → a ^ m ≤ a ^ n := by sorry

This theorem states that for any type `α` that forms a linear ordered semifield, and for any element `a` of that type and any integers `m` and `n`, if `a` is greater than or equal to 1 and `m` is less than or equal to `n`, then `a` raised to the power of `m` is less than or equal to `a` raised to the power of `n`. Essentially, this theorem asserts the monotonicity of the exponentiation function in a linear ordered semifield when the base is greater than or equal to 1.

For any linear ordered semifield type `α` and `a` in `α` greater than or equal to 1, if `m` is less than or equal to `n`, then `a^m ≤ a^n`.


theorem Ordinal.toPGame_lf :
    ∀ {a b : Ordinal.{u_1}}, a < b → SetTheory.PGame.LF (Ordinal.toPGame a) (Ordinal.toPGame b) := by sorry

This theorem states that for any two ordinals 'a' and 'b', if 'a' is less than 'b', then in the corresponding pre-games converted from these ordinals, the first player (Left) can always win the game where the pre-game corresponding to 'b' is played first. In other words, the less or fuzzy relation holds for the pre-games corresponding to 'a' and 'b'. This relation, denoted by `SetTheory.PGame.LF`, is defined such that `SetTheory.PGame.LF x y` is true if and only if the first player can win the pre-game 'y' when it is played before pre-game 'x'.

For any ordinals 'a' and 'b' with 'a' < 'b', the first player can win the corresponding pre-games when 'b' is played before 'a'. Equivalently, the less or fuzzy relation `SetTheory.PGame.LF` holds for pre-games corresponding to 'a' and 'b'.


theorem TensorAlgebra.algebraMap_leftInverse :
    ∀ {R : Type u_1} [inst : CommSemiring R] (M : Type u_2) [inst_1 : AddCommMonoid M] [inst_2 : Module R M],
      Function.LeftInverse ⇑TensorAlgebra.algebraMapInv ⇑(algebraMap R (TensorAlgebra R M)) :=
  by sorry

This theorem asserts that for any type `R` which is a commutative semiring, and any type `M` which is both an additive commutative monoid and a module over `R`, the function `TensorAlgebra.algebraMapInv` serves as a left inverse to the algebra map from `R` to the tensor algebra of `M` over `R`. In other words, for all `x` in `R`, when you first apply the algebra map to `x` and then apply `TensorAlgebra.algebraMapInv` to the result, you will get `x` back. This means that `TensorAlgebra.algebraMapInv` undoes the effect of the algebra map, but only when applied after the algebra map --- which is what it means to be a left inverse.

For any commutative semiring `R` and an additive commutative monoid `M` that is an `R`-module, the function `TensorAlgebra.algebraMapInv` is a left inverse to the algebra map from `R` to the tensor algebra of `M` over `R`. That is, for all `x` in `R`, `algebraMap (x) = TensorAlgebra.algebramapInv (algebraMapInv x)`.


theorem Mathlib.Algebra.Star.Basic._auxLemma.6 :
    ∀ {R : Type u} [inst : AddMonoid R] [inst_1 : StarAddMonoid R] {x : R}, (star x = 0) = (x = 0) := by sorry

This theorem, located in the `Mathlib.Algebra.Star.Basic` module under the name `_auxLemma.6`, states that for any type `R` that has an `AddMonoid` and `StarAddMonoid` structure, and for any element `x` of `R`, the star of `x` is zero if and only if `x` is zero. In other words, the `star` operation, which is part of the `StarAddMonoid` structure, preserves the zero element of the `AddMonoid`.

For any type `R` with an `AddMonoid` and `StarAddMonoid` structure, the star of any element `x` in `R` is zero if and only if `x` is zero.


/-- Applying `affineCombination` with given weights.  This is for the
case where a result involving a default base point is OK (for example,
when that base point will cancel out later); a more typical use case
for `affineCombination` would involve selecting a preferred base
point with
`affineCombination_eq_weightedVSubOfPoint_vadd_of_sum_eq_one` and
then using `weightedVSubOfPoint_apply`.  -/
theorem Finset.affineCombination_apply :
    ∀ {k : Type u_1} {V : Type u_2} {P : Type u_3} [inst : Ring k] [inst_1 : AddCommGroup V] [inst_2 : Module k V]
      [S : AddTorsor V P] {ι : Type u_4} (s : Finset ι) (w : ι → k) (p : ι → P),
      (Finset.affineCombination k s p) w =
        (Finset.weightedVSubOfPoint s p (Classical.choice ⋯)) w +ᵥ Classical.choice ⋯ :=
  by sorry

This theorem pertains to an operation called `affineCombination` on finite sets in the context of affine spaces. In essence, it states that for any ring `k`, additive commutative group `V`, `k`-module structure on `V`, and an affine torsor `S` over `V`, along with a finite set `s` of index type `ι`, a weight function `w` mapping indices to elements of `k`, and a point function `p` mapping indices to points in `P`, the result of applying the `affineCombination` operation with these weights and point function corresponds to the result of calculating the weighted difference of the points from a default base point (given by the `Classical.choice` operation), and then adding this difference vector to the default base point. The theorem can be more typically used by first selecting a preferred base point and then applying `weightedVSubOfPoint_apply`.

For any ring `k`, additive commutative group `V`, `k`-module structure on `V`, affine torsor `S` over `V`, finite set `s` of indices `ι`, weight function `w` mapping indices to `k`, and point function `p` mapping indices to points in `P`, the `affineCombination` operation on `S` with weights `w` and point function `p` is equal to the weighted difference of the points from a default base point, followed by adding this difference vector to the default base point.


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

The theorem `Matrix.mul_neg` states that for all types `m`, `n`, `o`, and `α`, where `α` is a non-unital non-associative ring, and `n` is a finite type, if `M` is a matrix with entries in `α` and rows indexed by `m` and columns indexed by `n`, and `N` is a matrix with entries in `α` and rows indexed by `n` and columns indexed by `o`, then the product of `M` and the additive inverse of `N` (`-N`) is equal to the additive inverse of the product of `M` and `N` (`-(M * N)`). This is a property of matrix multiplication over rings, similar to the distributivity of multiplication over subtraction in real numbers.

For matrices $M$ with entries in a non-unital non-associative ring $\alpha$, indexed by types $m$ and $n$, and $N$ with entries in $\alpha$ indexed by $n$ and $o$, $-(M \cdot N) = M \cdot (-N)$.


theorem NNReal.coe_prod :
    ∀ {α : Type u_1} {s : Finset α} {f : α → NNReal}, ↑(Finset.prod s fun a => f a) = Finset.prod s fun a => ↑(f a) :=
  by sorry

The theorem `NNReal.coe_prod` states that for any type `α`, any finite set `s` of type `α`, and any function `f` mapping elements of `α` to nonnegative real numbers (`NNReal`), the real number representation of the product of `f a` for each `a` in `s` is equal to the product of the real number representations of `f a` for each `a` in `s`. This is equivalent to saying that taking the product of the nonnegative real number results first and then converting to real numbers is the same as converting each nonnegative real number result to a real number first and then taking the product.

For any type `α`, finite set `s` of `α`, and function `f` mapping `α` to nonnegative real numbers, the real number representation of the product of `f a` for each `a` in `s` equals the product of the real number representations of `f a` for each `a` in `s`.


theorem mul_self_eq_one_iff :
    ∀ {R : Type x} [inst : NonAssocRing R] [inst_1 : NoZeroDivisors R] {a : R}, a * a = 1 ↔ a = 1 ∨ a = -1 := by sorry

This theorem states that for any type `R` that forms a non-associative ring without zero divisors, for any element `a` of that type, the condition of `a` multiplied by itself being equal to 1 is equivalent to `a` being either 1 or -1. This means that in such a ring, the only solutions to the equation `a * a = 1` are `a = 1` and `a = -1`.

In a non-associative ring without zero divisors `R`, an element `a` satisfies `a * a = 1` if and only if `a` is equal to `1` or `-1`.


theorem PMF.bind_bind :
    ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} (p : PMF α) (f : α → PMF β) (g : β → PMF γ),
      PMF.bind (PMF.bind p f) g = PMF.bind p fun a => PMF.bind (f a) g :=
  by sorry

The theorem `PMF.bind_bind` states that for any probability mass function `p` mapping from type `α`, and functions `f` and `g` mapping from `α` to `PMF β` and `β` to `PMF γ` respectively, the operation of binding `p` to `f` and then binding the result to `g` is the same as binding `p` to a function that takes an element of `α` and binds `f a` to `g`. In other words, this is demonstrating the associativity of the bind operation for `PMF`, which is a key feature of monadic operations.

For any probability mass functions $p : \alpha \rightarrow \mathbb{P}(\beta)$ and $f : \alpha \rightarrow \mathbb{P}(\gamma)$, $g : \beta \rightarrow \mathbb{P}(\delta)$, the law of the deep binding $\bind \circ \bind$ holds: $(p \bind f) \bind g = p \bind (\lambda x : \alpha. f(x) \bind g)$.


theorem MeasureTheory.set_integral_mono_ae_restrict :
    ∀ {X : Type u_1} [inst : MeasurableSpace X] {μ : MeasureTheory.Measure X} {f g : X → ℝ} {s : Set X},
      MeasureTheory.IntegrableOn f s μ →
        MeasureTheory.IntegrableOn g s μ →
          f ≤ᶠ[MeasureTheory.Measure.ae (μ.restrict s)] g → ∫ (x : X) in s, f x ∂μ ≤ ∫ (x : X) in s, g x ∂μ :=
  by sorry

This theorem, `MeasureTheory.set_integral_mono_ae_restrict`, states that for any given measurable space `X`, a measure `μ` on this space, two real-valued functions `f` and `g` on `X`, and a set `s` of `X`, if both `f` and `g` are integrable on the set `s` with respect to the measure `μ` and if the function `f` is almost everywhere less than or equal to `g` with respect to the measure `μ` restricted on set `s`, then the integral of `f` over the set `s` with respect to the measure `μ` is less than or equal to the integral of `g` over the set `s` with respect to the measure `μ`. In simple terms, if `f` is generally smaller or equal to `g` everywhere on `s`, then the integral of `f` over `s` is no larger than the integral of `g` over `s`.

If `f` and `g` are integrable functions on a measurable set `s` with `f(x) ≤ g(x)` almost everywhere in `s`, then `∫(f dμ) ≤ ∫(g dμ)` for the measures `μ` on the measurable space `X`.


theorem Set.inter_union_compl : ∀ {α : Type u} (s t : Set α), s ∩ t ∪ s ∩ tᶜ = s := by sorry

This theorem states that for any type `α` and any two sets `s` and `t` of type `α`, the union of the intersection of `s` and `t` with the intersection of `s` and the complement of `t` equals `s`. In mathematical notation, this can be written as $s \cap t \cup s \cap t^c = s$. This theorem essentially captures the idea that if we take a set `s` and intersect it with another set `t`, and also intersect it with the complement of `t`, and then take the union of these two intersections, we essentially recover the original set `s`.

The theorem asserts that for any set `s` of type `α`, the union of `s` intersected with `t` and `s` intersected with the complement of `t` equals `s`, i.e., `s ∩ t ∪ s ∩ t^c = s`.


theorem Hyperreal.infinitePos_add_not_infiniteNeg :
    ∀ {x y : ℝ*}, Hyperreal.InfinitePos x → ¬Hyperreal.InfiniteNeg y → Hyperreal.InfinitePos (x + y) := by sorry

This theorem states that for any two hyperreal numbers `x` and `y`, if `x` is positively infinite (meaning it is greater than all real numbers) and `y` is not negatively infinite (meaning there exists some real number `r` such that `y` is not less than `r`), then the sum of `x` and `y` is also positively infinite (it's greater than all real numbers).

If `x` is a positively infinite hyperreal number and `y` is not negatively infinite, then `x + y` is positively infinite.


theorem MeasureTheory.Integrable.comp_aemeasurable :
    ∀ {α : Type u_1} {β : Type u_2} {δ : Type u_4} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α}
      [inst : MeasurableSpace δ] [inst_1 : NormedAddCommGroup β] {f : α → δ} {g : δ → β},
      MeasureTheory.Integrable g (MeasureTheory.Measure.map f μ) →
        AEMeasurable f μ → MeasureTheory.Integrable (g ∘ f) μ :=
  by sorry

The theorem `MeasureTheory.Integrable.comp_aemeasurable` states that for any types `α`, `β`, and `δ`, a measurable space `α`, a measure `μ` on `α`, a measurable space `δ`, a normed add commutative group `β`, and functions `f : α → δ` and `g : δ → β`; if `g` is integrable with respect to the pushforward of the measure `μ` by `f`, and if `f` is almost everywhere measurable with respect to `μ`, then the composition `g ∘ f` is integrable with respect to `μ`. In terms of measure theory, this means that the integrability of a function after a measure-preserving transformation is preserved if the transformation is almost everywhere measurable.

If a measurable function `f : α → δ` and a integrable function `g : δ → β` satisfy `g` is integrable with respect to the pushforward measure of `μ` by `f` and `f` is almost everywhere measurable with respect to `μ`, then the composition `g ∘ f` is integrable with respect to `μ`.


theorem Fin.val_add_one_of_lt : ∀ {n : ℕ} {i : Fin (Nat.succ n)}, i < Fin.last n → ↑(i + 1) = ↑i + 1 := by sorry

This theorem, `Fin.val_add_one_of_lt`, states that for any natural number `n` and any element `i` of the finite set `Fin (Nat.succ n)`, if `i` is strictly less than the last element of the finite set, then adding one to `i` (using the coercion from `Fin (Nat.succ n)` to `ℕ`) results in the same value as first casting `i` to `ℕ` and then adding one. In other words, for every finite subset of natural numbers augmented by one, if a chosen element doesn't reach the greatest value, incrementing this element leads to the same result whether it's done before or after the type coercion to the natural numbers.

For any natural number `n` and `i` in the finite set `Fin (Nat.succ n)`, if `i` is strictly less than the last element of `Fin (Nat.succ n)`, then `(i : ℕ) + 1 = (i + 1 : ℕ)`.


/-- **Disintegration** of finite product measures on `α × Ω`, where `Ω` is standard Borel. Such a
measure can be written as the composition-product of the constant kernel with value `ρ.fst`
(marginal measure over `α`) and a Markov kernel from `α` to `Ω`. We call that Markov kernel
`ProbabilityTheory.condKernel ρ`.  -/
theorem ProbabilityTheory.measure_eq_compProd :
    ∀ {α : Type u_1} {mα : MeasurableSpace α} {Ω : Type u_2} [inst : MeasurableSpace Ω] [inst_1 : StandardBorelSpace Ω]
      [inst_2 : Nonempty Ω] (ρ : MeasureTheory.Measure (α × Ω)) [inst_3 : MeasureTheory.IsFiniteMeasure ρ],
      ρ = MeasureTheory.Measure.compProd (MeasureTheory.Measure.fst ρ) (MeasureTheory.Measure.condKernel ρ) :=
  by sorry

This is a theorem about the **Disintegration** of finite product measures on the product space `α × Ω`, where `Ω` is a standard Borel space. It states that any such measure `ρ` can be expressed as the composition-product of two components: the marginal measure over `α` (denoted by `ρ.fst`) and a Markov kernel from `α` to `Ω`. This Markov kernel is referred to as the conditional kernel of the measure `ρ` (denoted by `MeasureTheory.Measure.condKernel ρ`). So, in other words, any measure on the product space can be decomposed into a measure on `α` and a conditionally dependent measure on `Ω` given `α`. This is a fundamental result in probability theory which allows us to treat joint distributions as conditional distributions.

Given a finite product measure `ρ` on the product space `α × Ω` of a measurable space `(α, Σα)` and a standard Borel space `(Ω, ΣΩ)`, there exists a Markov kernel `K : α → ℙ(Ω)` such that `ρ = ρ.fst ⊤ ∘ K`, where `ℙ(Ω)` denotes the space of probability measures on `Ω` and `⊤` denotes the lift to a Markov kernel.


theorem CategoryTheory.Biprod.ofComponents_comp :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C]
      [inst_2 : CategoryTheory.Limits.HasBinaryBiproducts C] {X₁ X₂ Y₁ Y₂ Z₁ Z₂ : C} (f₁₁ : X₁ ⟶ Y₁) (f₁₂ : X₁ ⟶ Y₂)
      (f₂₁ : X₂ ⟶ Y₁) (f₂₂ : X₂ ⟶ Y₂) (g₁₁ : Y₁ ⟶ Z₁) (g₁₂ : Y₁ ⟶ Z₂) (g₂₁ : Y₂ ⟶ Z₁) (g₂₂ : Y₂ ⟶ Z₂),
      CategoryTheory.CategoryStruct.comp (CategoryTheory.Biprod.ofComponents f₁₁ f₁₂ f₂₁ f₂₂)
          (CategoryTheory.Biprod.ofComponents g₁₁ g₁₂ g₂₁ g₂₂) =
        CategoryTheory.Biprod.ofComponents
          (CategoryTheory.CategoryStruct.comp f₁₁ g₁₁ + CategoryTheory.CategoryStruct.comp f₁₂ g₂₁)
          (CategoryTheory.CategoryStruct.comp f₁₁ g₁₂ + CategoryTheory.CategoryStruct.comp f₁₂ g₂₂)
          (CategoryTheory.CategoryStruct.comp f₂₁ g₁₁ + CategoryTheory.CategoryStruct.comp f₂₂ g₂₁)
          (CategoryTheory.CategoryStruct.comp f₂₁ g₁₂ + CategoryTheory.CategoryStruct.comp f₂₂ g₂₂) :=
  by sorry

This theorem, `CategoryTheory.Biprod.ofComponents_comp`, states that for any type `C` that is a category, is preadditive, and has binary biproducts, and for any objects `X₁`, `X₂`, `Y₁`, `Y₂`, `Z₁`, `Z₂` in `C`, given eight morphisms `f₁₁ : X₁ ⟶ Y₁`, `f₁₂ : X₁ ⟶ Y₂`, `f₂₁ : X₂ ⟶ Y₁`, `f₂₂ : X₂ ⟶ Y₂`, `g₁₁ : Y₁ ⟶ Z₁`, `g₁₂ : Y₁ ⟶ Z₂`, `g₂₁ : Y₂ ⟶ Z₁`, `g₂₂ : Y₂ ⟶ Z₂`, the composition of the biproducts of the first four morphisms and the latter four morphisms equals the biproduct of the sum of compositions of the morphisms. The specific compositions that make up the components of the resulting biproduct are determined by combining the morphisms in a certain pattern: the first component is the sum of the composition of `f₁₁` and `g₁₁` and the composition of `f₁₂` and `g₂₁`, and similarly for the other components.

For any preadditive category `C` with binary biproducts, the composition of the biproducts of four morphisms and the latter four morphisms equals the biproduct of the sum of their compositions, where the first (respectively, second) component is the sum of the compositions of the first and third (respectively, second and fourth) pairs of morphisms.


theorem ENNReal.nhdsWithin_Ioi_coe_neBot : ∀ {r : NNReal}, Filter.NeBot (nhdsWithin (↑r) (Set.Ioi ↑r)) := by sorry

The theorem `ENNReal.nhdsWithin_Ioi_coe_neBot` states that for every nonnegative real number `r`, the filter, that is the intersection of the neighborhood filter around the point `r` and the filter principal of the set of real numbers greater than `r`, is not a bottom (empty) filter. In other words, there always exists a set in the neighborhood of `r` that intersects with the set of real numbers greater than `r`, and this intersection is not an empty set.

For every non-negative real number `r`, the filter of neighborhoods of `r` intersecting the set of real numbers strictly greater than `r` is non-empty.


theorem AddMonoidAlgebra.sup_support_mul_le :
    ∀ {R : Type u_1} {A : Type u_3} {B : Type u_5} [inst : SemilatticeSup B] [inst_1 : OrderBot B] [inst_2 : Semiring R]
      [inst_3 : Add A] [inst_4 : Add B] [inst_5 : CovariantClass B B (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1]
      [inst_6 : CovariantClass B B (Function.swap fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] {degb : A → B},
      (∀ {a b : A}, degb (a + b) ≤ degb a + degb b) →
        ∀ (f g : AddMonoidAlgebra R A),
          Finset.sup (f * g).support degb ≤ Finset.sup f.support degb + Finset.sup g.support degb :=
  by sorry

The theorem `AddMonoidAlgebra.sup_support_mul_le` states that for any types `R`, `A`, and `B` where `A` is an additive monoid, `B` is a semilattice with a bottom element, and `R` is a semiring, if you have a function `degb` from `A` to `B` that satisfies the property that for any two elements `a` and `b` of `A`, `degb` of their sum is less than or equal to the sum of their `degb` values, then for any two elements `f` and `g` of the monoid algebra of `A` over `R`, the supremum of the `degb` values over the support of the product of `f` and `g` is less than or equal to the sum of the suprema of the `degb` values over the supports of `f` and `g`. This theorem is a statement about the behavior of a specific type of algebraic structure (the monoid algebra) under a specific type of operation (the supremum over a function of the support of an element).

Given an additive monoid `A`, a semilattice with a bottom element `B`, and a semiring `R`, if `degb` is a function from `A` to `B` satisfying `degb(a + b) <= degb(a) + degb(b)` for all `a, b` in `A`, then for any `f, g` in the monoid algebra of `A` over `R`, `sup (degb . support f) + sup (degb . support g) >= sup (degb . support (f * g))`. (Note: The inequality in the theorem is reversed due to the different conventions in Lean and mathematical notation for supremum.)


theorem Mathlib.SetTheory.Ordinal.Arithmetic._auxLemma.44 :
    ∀ {α : Sort u_1} {p : α → Prop}, (¬∀ (x : α), p x) = ∃ x, ¬p x := by sorry

This theorem states that, for any type `α` and any property `p` applicable to `α`, the statement "it is not the case that for all `x` of type `α`, `p` applies to `x`" is equivalent to "there exists an `x` of type `α` such that `p` does not apply to `x`". In other words, the negation of universal quantification (not all `x` have property `p`) is equivalent to the existence of an object that does not have the property (there exists an `x` such that `x` does not have property `p`).

The negation of "forall x : α, p(x)" is equivalent to "exists x : α, ¬p(x)".


theorem contMDiff_const :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {H : Type u_3} [inst_3 : TopologicalSpace H] {I : ModelWithCorners 𝕜 E H}
      {M : Type u_4} [inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] {E' : Type u_5}
      [inst_6 : NormedAddCommGroup E'] [inst_7 : NormedSpace 𝕜 E'] {H' : Type u_6} [inst_8 : TopologicalSpace H']
      {I' : ModelWithCorners 𝕜 E' H'} {M' : Type u_7} [inst_9 : TopologicalSpace M'] [inst_10 : ChartedSpace H' M']
      {n : ℕ∞} {c : M'}, ContMDiff I I' n fun x => c :=
  by sorry

This theorem, `contMDiff_const`, states that for every nontrivially normed field `𝕜`, normed additive commutative group `E`, normed space `𝕜 E`, topological space `H`, model with corners `I` over `𝕜`, `E` and `H`, topological space `M`, and charted space `H M`; and similarly for `E'`, `H'`, `I'`, and `M'`; and for any `n` in the set of natural numbers extended with infinity `ℕ∞` and any constant `c` in `M'`, the function which maps every element of `M` to `c` is continuously differentiable `n` times. In mathematical terms, it says that constant functions are infinitely differentiable.

For any nontrivially normed field `𝕜`, normed additive commutative group `E`, and topological spaces `H`, `M`, the constant function from `M` to `𝕜` is infinitely differentiable.


theorem Matroid.dual_dual : ∀ {α : Type u_1} (M : Matroid α), M﹡﹡ = M := by sorry

This theorem, `Matroid.dual_dual`, states that for any Matroid `M` of any type `α`, the dual of the dual of `M` is equal to `M` itself. In other words, applying the dual operation twice on a matroid returns the original matroid. This theorem mirrors the common mathematical principle that the double dual (or double transpose) of many mathematical objects is the object itself.

The dual of a matroid is equal to its own dual.


theorem GroupCat.SurjectiveOfEpiAuxs.tau.proof_1 :
    ∀ {A B : GroupCat} (f : A ⟶ B), ∃ y, (fun x => x • ↑(MonoidHom.range f)) y = ↑(MonoidHom.range f) := by sorry

The theorem `GroupCat.SurjectiveOfEpiAuxs.tau.proof_1` states that for any two groups `A` and `B`, represented as objects in the category of groups `GroupCat`, and any morphism `f` from `A` to `B` (which is a group homomorphism), there exists an element `y` such that the action of `y` on the image of `f` (which is a subgroup of `B` as stated by `MonoidHom.range f`) equals the image of `f`. In other words, there is some `y` that leaves the image of the group homomorphism invariant under the group action.

Given any group homomorphism `f` from group `A` to group `B`, there exists an element `y` in `B` such that `y * x = f(x)` for all `x` in the image of `f`.


theorem Metric.closedBall_mem_nhds :
    ∀ {α : Type u} [inst : PseudoMetricSpace α] (x : α) {ε : ℝ}, 0 < ε → Metric.closedBall x ε ∈ nhds x := by sorry

This theorem states that for any pseudometric space `α` and any point `x` in `α`, given a real number `ε` greater than 0, the closed ball around `x` with radius `ε` is a member of the neighborhood filter of `x`. In other words, the set of all points `y` with distance to `x` less than or equal to `ε` is a neighborhood of `x`. This makes intuitive sense in metric spaces, where any sufficiently small closed ball around a point can be considered a local neighborhood of that point.

For any pseudometric space `α` and point `x` in `α`, the closed ball with center `x` and radius `ε` is an element of the neighborhood filter of `x` for any `ε` greater than 0.


theorem MeasureTheory.measure_biUnion_finset_le :
    ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] {μ : MeasureTheory.Measure α} (s : Finset β)
      (f : β → Set α), ↑↑μ (⋃ b ∈ s, f b) ≤ Finset.sum s fun p => ↑↑μ (f p) :=
  by sorry

This theorem states that for any given measurable space `α`, any type `β`, and any measure `μ` defined on `α`, if `s` is a finite set of elements from `β` and `f` is a function from `β` to a set of elements in `α`, then the measure of the union of sets `f b` for every `b` in `s` is less than or equal to the sum of the measures of each `f p` for every `p` in `s`. In mathematical notation, this theorem is asserting that for a measure `μ`, a finite set `s`, and a function `f`, we have
\[
μ\left(\bigcup_{b\in s} f(b)\right) \leq \sum_{p\in s} μ(f(p))
\]
This theorem is a statement about the subadditivity of measures in measure theory.

For any measure μ, finite set s, and function f from a measurable space to itself, the measure of the union of images of elements in s under f is less than or equal to the sum of the measures of the images of those elements. That is, μ(⋃b∈s f(b)) ≤ ∑p∈s μ(f(p)).


theorem Set.mapsTo_id : ∀ {α : Type u_1} (s : Set α), Set.MapsTo id s s := by sorry

This theorem states that for any set `s` of a certain type `α`, the identity function (`id`) maps `s` to itself. In other words, if you take an element `x` from the set `s`, applying the identity function to `x` will always result in an element that is within `s`. This can also be described as: the image of the set `s` under the identity function is contained within `s` itself.

For any set `s` and all elements `x` in `s`, `id x ∈ s`. (Here, `id` denotes the identity function.)


theorem List.mem_of_elem_eq_true :
    ∀ {α : Type u} [inst : BEq α] [inst_1 : LawfulBEq α] {a : α} {as : List α}, List.elem a as = true → a ∈ as := by
  sorry

This theorem, `List.mem_of_elem_eq_true`, states that for any type `α` that has an equality test (`BEq α`) and respects the laws of equality (`LawfulBEq α`), and for any element `a` of type `α` and list `as` of elements of type `α`, if the function `List.elem` applied to `a` and `as` yields `true`, then `a` is indeed a member of list `as`. Essentially, it formalizes the intuitive idea that if `List.elem` tells you that an element is in a list, then that element really is in that list.

For any type `α` with `BEq α` and `LawfulBEq α`, if `List.elem α a as = true`, then `a ∈ as`.


theorem Mathlib.MeasureTheory.Constructions.BorelSpace.Basic._auxLemma.54 :
    ∀ {α : Type u} {ι : Sort u_1} {f : ι → α} {x : α}, (x ∈ Set.range f) = ∃ y, f y = x := by sorry

The theorem `Mathlib.MeasureTheory.Constructions.BorelSpace.Basic._auxLemma.54` asserts that, for any type `α`, any sort `ι`, any function `f` from `ι` to `α`, and any element `x` of `α`, the condition for `x` to be in the range of `f` is equivalent to the existence of an element `y` in `ι` such that `f(y)` equals `x`. In other words, an element is in the range of a function if and only if it is the image of some input under that function.

For any function between types, an element is in the range if and only if there exists an input mapping to that element.


theorem Mathlib.MeasureTheory.Constructions.BorelSpace.Basic._auxLemma.55 :
    ∀ {α : Type u} {β : Type v} (f : α → β) (s : Set α) (y : β), (y ∈ f '' s) = ∃ x ∈ s, f x = y := by sorry

This theorem, from the `Mathlib.MeasureTheory.Constructions.BorelSpace.Basic` section of Lean's Mathematics Library, states that for any two types `α` and `β`, a function `f` from `α` to `β`, a set `s` of type `α` and an element `y` of type `β`, the proposition that `y` is in the image of `s` under `f` is equivalent to the existence of an element `x` in `s` such that `f(x)` equals `y`. In other words, an element is in the image of a set under a function if and only if there is an element in the original set that the function maps to it.

For any function between two types and any set and element, an element is in the image of the set under the function if and only if there exists an element in the set that maps to it.


theorem Mathlib.MeasureTheory.Constructions.BorelSpace.Basic._auxLemma.56 :
    ∀ {α : Sort u_3} {β : Sort u_2} {f : α → β} {p : β → Prop}, (∃ b, (∃ a, f a = b) ∧ p b) = ∃ a, p (f a) := by sorry

This theorem states that for any two types `α` and `β`, and a function `f` from `α` to `β`, and a property `p` on `β`, the proposition that there exists a `b` in `β` such that `b` equals `f a` for some `a` in `α` and `b` satisfies `p`, is equivalent to the proposition that there exists an `a` in `α` such that `f a` satisfies `p`. This is a theorem about the interchangeability of the order of quantifiers and the function application in certain conditions.

For any types `α` and `β`, function `f` from `α` to `β`, and property `p` on `β`, the existence of an `a` in `α` such that `f a` satisfies `p` is equivalent to the existence of a `b` in `β` such that `b` is of the form `f a` for some `a` in `α` and `b` satisfies `p`.


Set.Finite.offDiag

theorem Set.Finite.offDiag : ∀ {α : Type u} {s : Set α}, Set.Finite s → Set.Finite (Set.offDiag s) := by sorry

The theorem `Set.Finite.offDiag` states that for any type `α` and any set `s` of that type, if `s` is finite then the off-diagonal of `s` is also finite. The off-diagonal of a set `s` is defined as the set of all pairs `(a, b)` such that `a` and `b` are elements of `s` and `a` is not equal to `b`. This theorem essentially indicates that the set of all distinct pairs from a finite set is also finite.

If `α` is a type and `s` is a finite set of `α`, then the set of distinct pairs in `s` is finite.


theorem Hyperreal.IsSt.not_infinite : ∀ {x : ℝ*} {r : ℝ}, Hyperreal.IsSt x r → ¬Hyperreal.Infinite x := by sorry

The theorem `Hyperreal.IsSt.not_infinite` states that for any hyperreal number `x` and any real number `r`, if `x` is the standard part of `r` (denoted as `Hyperreal.IsSt x r`, meaning that `x` is within any infinitesimal distance from `r`), then `x` cannot be an infinite hyperreal number. In other words, a standard part of a real number cannot be infinitely large or infinitely small.

A real number's standard part is finite in the hyperreal numbers.


theorem MeasureTheory.JordanDecomposition.smul_negPart :
    ∀ {α : Type u_1} [inst : MeasurableSpace α] (j : MeasureTheory.JordanDecomposition α) (r : NNReal),
      (r • j).negPart = r • j.negPart :=
  by sorry

The theorem `MeasureTheory.JordanDecomposition.smul_negPart` states that for any measurable space `α`, any Jordan decomposition `j` of `α`, and any nonnegative real number `r`, the negative part of `r` scaled by `j` is equal to `r` scaled by the negative part of `j`. In other words, scaling a Jordan decomposition and then taking the negative part is the same as first taking the negative part and then scaling. This is a property of scalar multiplication and the negPart operation in the context of a Jordan decomposition in measure theory.

For any measurable space `α`, Jordan decomposition `j`, and nonnegative real number `r`, `r * j.negPart = j.negPart * r`.


theorem NNReal.rpow_nat_cast : ∀ (x : NNReal) (n : ℕ), x ^ ↑n = x ^ n := by sorry

This theorem states that for every nonnegative real number `x` and natural number `n`, the real power of `x` to the real number obtained by casting `n` (denoted as `x ^ ↑n`) is equal to the natural power of `x` to `n` (denoted as `x ^ n`). In other words, it asserts the equivalence of real exponentiation and natural exponentiation when the exponent is a natural number, within the context of nonnegative real numbers.

For all non-negative real numbers x and natural numbers n, x ^ (upward-cast n) = x ^ n.


theorem Computation.results_pure : ∀ {α : Type u} (a : α), Computation.Results (Computation.pure a) a 0 := by sorry

This theorem, `Computation.results_pure`, states that for any type 'α' and an instance 'a' of that type, the computation that immediately terminates with result 'a' (i.e., `Computation.pure a`) is characterized by the `Computation.Results` with zero steps. In other words, `Computation.pure a` will conclude after exactly 0 steps with the result 'a'.

The `Computation.pure` function returns a computation that concludes in 0 steps with the given result.


theorem left_vsub_midpoint :
    ∀ {R : Type u_1} {V : Type u_2} {P : Type u_4} [inst : Ring R] [inst_1 : Invertible 2] [inst_2 : AddCommGroup V]
      [inst_3 : Module R V] [inst_4 : AddTorsor V P] (p₁ p₂ : P), p₁ -ᵥ midpoint R p₁ p₂ = ⅟2 • (p₁ -ᵥ p₂) :=
  by sorry

This theorem, named `left_vsub_midpoint`, states that for any ring `R`, an additive commutative group `V`, an `R`-module structure on `V`, and an additive torsor `P` over `V`, and for any two points `p₁` and `p₂` in `P`, the difference between `p₁` and the midpoint of `p₁` and `p₂` is half of the difference between `p₁` and `p₂`. Here, `-ᵥ` represents the difference between two points in `P`, and `•` represents the scalar multiplication in the `R`-module `V`. The `⅟2` is the multiplicative inverse of `2` in the ring `R`, assuming `2` is invertible in `R`.

For any additive torsor `P` over an `R`-module `V` with midpoint `m`, and for any two points `p₁, p₂` in `P`, the difference `p₁ - m` equals half the difference `(p₁ - p₂)` if `R` has an invertible element `2`.


theorem Set.image_symmDiff :
    ∀ {α : Type u_1} {β : Type u_2} {f : α → β},
      Function.Injective f → ∀ (s t : Set α), f '' symmDiff s t = symmDiff (f '' s) (f '' t) :=
  by sorry

This theorem states that for any types `α` and `β` and any function `f` from `α` to `β`, if `f` is injective (which means that `f` maps distinct inputs to distinct outputs), then the image of the symmetric difference of two sets `s` and `t` under `f` is the same as the symmetric difference of the images of `s` and `t` under `f`. In mathematical terms, given an injective function `f: α → β` and two sets `s, t ⊆ α`, then `f` applied to the symmetric difference of `s` and `t` equals the symmetric difference of `f(s)` and `f(t)`. Here, symmetric difference is defined as `(A \ B) ⊔ (B \ A)` for sets `A` and `B`, which means the union of the set difference `A \ B` and the set difference `B \ A`.

For injective functions `f: α → β` and sets `s, t ⊆ α`, `f(s Δ t) = f(s) Δ f(t)`, where `Δ` denotes the symmetric difference.


theorem Function.rightInverse_of_injective_of_leftInverse :
    ∀ {α : Sort u₁} {β : Sort u₂} {f : α → β} {g : β → α},
      Function.Injective f → Function.LeftInverse f g → Function.RightInverse f g :=
  by sorry

The theorem `Function.rightInverse_of_injective_of_leftInverse` states that for all types `α` and `β`, and for all functions `f` from `α` to `β` and `g` from `β` to `α`, if `f` is injective and `f` is a left inverse to `g`, then `f` is also a right inverse to `g`. In other words, if every element in the codomain `β` is mapped by `f` from a unique element in the domain `α` (injectivity), and applying `f` after `g` gives the identity function on `β` (left inverseness), then applying `g` after `f` gives the identity function on `α` (right inverseness).

If `f: α → β` is injective and left-inverse to `g: β → α`, then `g` is right-inverse to `f`. In other words, `f ∘ g = idβ` and `g ∘ f = idα`.


/-- Given a Localization map `f : M →+ N` for a Submonoid `S ⊆ M` and a map of
`AddCommMonoid`s `g : M →+ P` such that `g(S) ⊆ AddUnits P`, `f x = f y → g x = g y`
for all `x y : M`. -/
theorem AddSubmonoid.LocalizationMap.eq_of_eq :
    ∀ {M : Type u_1} [inst : AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [inst_1 : AddCommMonoid N]
      {P : Type u_3} [inst_2 : AddCommMonoid P] (f : AddSubmonoid.LocalizationMap S N) {g : M →+ P},
      (∀ (y : ↥S), IsAddUnit (g ↑y)) →
        ∀ {x y : M}, (AddSubmonoid.LocalizationMap.toMap f) x = (AddSubmonoid.LocalizationMap.toMap f) y → g x = g y :=
  by sorry

The theorem `AddSubmonoid.LocalizationMap.eq_of_eq` states that given an additive localization map `f` from an additive commutative monoid `M` to an additive commutative monoid `N` with respect to a submonoid `S` of `M`, and another additive monoid homomorphism `g` from `M` to an additive commutative monoid `P` such that the image under `g` of `S` is a subset of the additive units of `P`, if for any two elements `x` and `y` in `M`, `f(x)` equals `f(y)`, then `g(x)` must be equal to `g(y)`.

In simpler terms, if two elements in `M` map to the same value in `N` under the localization map `f`, and if the homomorphism `g` transforms the submonoid `S` into additive units in `P`, then these two elements will also map to the same value under the homomorphism `g`.

If `f` is an additive localization map from an additive commutative monoid `M` to an additive commutative monoid `N` with respect to a submonoid `S`, and `g` is an additive monoid homomorphism from `M` to an additive commutative monoid `P` such that the image of `S` under `g` are additive units in `P`, then `x = y` in `M` implies `g(x) = g(y)` in `P`.


theorem Mathlib.Algebra.Opposites._auxLemma.6 :
    ∀ {α : Type u_1} [inst : Zero α] (a : α), (MulOpposite.op a = 0) = (a = 0) := by sorry

This theorem states that for any type `α` which has a zero element, and any element `a` of `α`, the `MulOpposite.op` operation of `a` is equal to zero if and only if `a` itself is equal to zero. In other words, the operation `MulOpposite.op` preserves the zero element in the type `α`.

For any type `α` with a zero element and operation `MulOpposite.op`, `MulOpposite.op a = 0` if and only if `a = 0`.


theorem Cardinal.beth_succ : ∀ (o : Ordinal.{u_1}), Cardinal.beth (Order.succ o) = 2 ^ Cardinal.beth o := by sorry

The theorem `Cardinal.beth_succ` states that for any ordinal `o`, the beth number of the successor of `o` (denoted by `Order.succ o`) is equal to 2 raised to the power of the beth number of `o` (indicated by `2 ^ Cardinal.beth o`). In mathematical terms, given an ordinal number `o`, if we denote `beth o` as the beth number associated with `o`, then the beth number of the successor of `o` is 2 to the power of `beth o`. This can be written as: `beth(succ(o)) = 2^{beth(o)}`.

The beth number of the successor of an ordinal `o` is equal to 2 raised to the power of the beth number of `o`. In Lean notation, `Cardinal.beth_succ _ = 2 ^ Cardinal.beth`.


theorem Flow.map_zero_apply :
    ∀ {τ : Type u_1} [inst : AddMonoid τ] [inst_1 : TopologicalSpace τ] [inst_2 : ContinuousAdd τ] {α : Type u_2}
      [inst_3 : TopologicalSpace α] (ϕ : Flow τ α) (x : α), ϕ.toFun 0 x = x :=
  by sorry

The theorem `Flow.map_zero_apply` states that for any type `τ` that is an add monoid as well as a topological space with continuous addition, and for any type `α` that is a topological space, if we have a flow `ϕ` from `τ` to `α` and an element `x` of type `α`, applying the flow function `ϕ.toFun` at time `0` to `x` will return `x` itself. This theorem essentially shows that the flow at time zero does not change the position of any point in the space `α`.

For any add monoid and topological space `τ`, and any topological space `α`, if `ϕ` is a continuous flow from `τ` to `α`, then `ϕ.toFun 0 = id` on `α`, where `id` is the identity function.


theorem sup_iSup_nat_succ : ∀ {α : Type u_1} [inst : CompleteLattice α] (u : ℕ → α), u 0 ⊔ ⨆ i, u (i + 1) = ⨆ i, u i :=
  by sorry

This theorem states that for any type `α` that is a complete lattice and a sequence `u` of elements of `α` indexed by natural numbers, the supremum (greatest lower bound) of the first element of the sequence and the supremum over the rest of the sequence is equal to the supremum over the entire sequence. In other words, the "maximum" value of the sequence doesn't change if we consider the first element separately and then take the "maximum" of the remaining sequence.

For any complete lattice `α` and sequence `u : ℕ → α`, the supremum of the first element `u 0` and the supremum of the sequence `u[1..]` equals the supremum of the entire sequence `u`.


theorem Filter.HasBasis.uniformContinuous_iff :
    ∀ {α : Type ua} {β : Type ub} {ι : Sort u_1} [inst : UniformSpace α] {ι' : Sort u_2} [inst_1 : UniformSpace β]
      {p : ι → Prop} {s : ι → Set (α × α)},
      Filter.HasBasis (uniformity α) p s →
        ∀ {q : ι' → Prop} {t : ι' → Set (β × β)},
          Filter.HasBasis (uniformity β) q t →
            ∀ {f : α → β},
              UniformContinuous f ↔ ∀ (i : ι'), q i → ∃ j, p j ∧ ∀ (x y : α), (x, y) ∈ s j → (f x, f y) ∈ t i :=
  by sorry

The theorem `Filter.HasBasis.uniformContinuous_iff` states that a function `f` from a type `α` to a type `β`, both equipped with uniform space structures, is uniformly continuous if and only if for any index `i` from the index type `ι'` such that the predicate `q` holds on `i`, there exists an index `j` from the index type `ι` satisfying the predicate `p`, and for all pairs `(x, y)` of elements in `α` that belong to the set `s j`, the image pair `(f x, f y)` belongs to the set `t i`. This statement is under the context that the uniformity on `α` has a basis determined by the predicate `p` and the sets `s` indexed by `ι`, and the uniformity on `β` also has a basis determined by the predicate `q` and the sets `t` indexed by `ι'`. The intuition is that `f` is uniformly continuous if it preserves the "closeness" of points in `α` to the "closeness" of points in `β` in a way that corresponds to the basis of their respective uniformities.

A function between uniform spaces is uniformly continuous if and only if for each basis element in the domain's uniformity, there exists a basis element in the codomain's uniformity such that the corresponding sets satisfy the preservation property.


theorem Mathlib.Topology.Bornology.Basic._auxLemma.4 :
    ∀ {α : Type u_2} {x : Bornology α}, Bornology.IsBounded ∅ = True := by sorry

This theorem is stating that for any type `α` and any bornology `x` on `α`, the set of empty elements, denoted by `∅`, is always bounded relative to the ambient bornology on `α`. In other words, it says that an empty set is always bounded in any given bornology.

For any type `α` and bornology `x` on `α`, the empty set `∅` is a bounded subset of `α` relative to `x`.