theorem Ordinal.lt_blsub :
    ∀ {o : Ordinal.{u_4}} (f : (a : Ordinal.{u_4}) → a < o → Ordinal.{max u_5 u_4}) (i : Ordinal.{u_4}) (h : i < o),
      f i h < Ordinal.blsub o f :=
  by sorry

This theorem, `Ordinal.lt_blsub`, states that for any ordinal `o`, any function `f` that maps each ordinal less than `o` to another ordinal, and any ordinal `i` that is strictly less than `o`, the value of `f` at `i` is strictly less than the least strict upper bound of the family of ordinals indexed by the set of ordinals less than `o`. In mathematical terms, for all ordinals `o` and `i` with `i < o`, and for all functions `f: {a in Ordinals | a < o} -> Ordinals`, we have `f(i) < blsub(o, f)`.

 For every ordinal `o` and `i` with `i < o`, and for any function `f` mapping ordinals less than `o` to ordinals, we have `f(i) < sup i.in (f)`.

Here, `sup` denotes the least upper bound or the supremum. The notation `i.in (f)` is used to denote the set of ordinals less than `o` as the domain of function `f`.


theorem List.getD_eq_get :
    ∀ {α : Type u} (l : List α) (d : α) {n : ℕ} (hn : n < List.length l),
      List.getD l n d = List.get l { val := n, isLt := hn } :=
  by sorry

This theorem, `List.getD_eq_get`, states that for any type `α`, any list `l` of type `α`, any default value `d` of type `α`, and any natural number `n` such that `n` is less than the length of the list `l`, the `getD` function applied to list `l`, index `n`, and default value `d` equals the `get` function applied to the list `l` with a subtype of natural numbers that are less than the length of the list `l`. This asserts that these two ways of accessing an element at a certain index in a list yield the same result when the index is within the bounds of the list.

For any type `α`, list `l` of length `n` over `α`, natural number `n`, and default value `d` of type `α`, `getD l n d = get (subtype.range 0 (pred n) l) n d`.


theorem IsUnit.mul_left_inj : ∀ {M : Type u_1} [inst : Monoid M] {a b c : M}, IsUnit a → (b * a = c * a ↔ b = c) := by
  sorry

The theorem `IsUnit.mul_left_inj` states that for any type `M` that has a `Monoid` structure, and for any elements `a`, `b`, and `c` of `M`, if `a` is a unit (i.e., it has a two-sided inverse), then the equality `b * a = c * a` implies `b = c`. In other words, left multiplication by a unit element in a monoid is injective.

If `a` is a unit in a monoid `M`, then the map left multiplication by `a` is injective: `∀ (b c : M), b * a = c * a → b = c`.


theorem MeasureTheory.Memℒp.of_le_mul :
    ∀ {α : Type u_1} {E : Type u_2} {F : Type u_3} {m0 : MeasurableSpace α} {p : ENNReal} {μ : MeasureTheory.Measure α}
      [inst : NormedAddCommGroup E] [inst_1 : NormedAddCommGroup F] {f : α → E} {g : α → F} {c : ℝ},
      MeasureTheory.Memℒp g p μ →
        MeasureTheory.AEStronglyMeasurable f μ → (∀ᵐ (x : α) ∂μ, ‖f x‖ ≤ c * ‖g x‖) → MeasureTheory.Memℒp f p μ :=
  by sorry

This theorem, `MeasureTheory.Memℒp.of_le_mul`, states that for all types `α`, `E`, `F`, a measurable space `m0`, an extended nonnegative real number `p`, and a measure `μ` on `α`, if `g` is an `α`-to-`F` function in `L^p(μ)` and `f` is an `α`-to-`E` function that is almost everywhere strongly measurable with respect to `μ`, and almost everywhere, the norm of `f(x)` is less than or equal to a constant `c` times the norm of `g(x)`, then `f` is also in `L^p(μ)`. In other words, if a function is bounded by a constant multiple of another function that is in `L^p(μ)`, then the original function is also in `L^p(μ)`. This is an important property in the theory of `L^p` spaces.

If a strongly measurable function `f` satisfies almost everywhere `||f(x)|| ≤ c ||g(x)||` for some constant `c` and a measurable function `g` in `L^p(μ)`, then `f` belongs to `L^p(μ)`.


Asymptotics.IsBigO.congr'

theorem Asymptotics.IsBigO.congr' :
    ∀ {α : Type u_1} {E : Type u_3} {F : Type u_4} [inst : Norm E] [inst_1 : Norm F] {l : Filter α} {f₁ f₂ : α → E}
      {g₁ g₂ : α → F}, f₁ =O[l] g₁ → f₁ =ᶠ[l] f₂ → g₁ =ᶠ[l] g₂ → f₂ =O[l] g₂ :=
  by sorry

The theorem `Asymptotics.IsBigO.congr'` states that for any types `α`, `E`, and `F`, given the norms on `E` and `F`, a filter `l` on `α`, and functions `f₁`, `f₂` from `α` to `E`, and `g₁`, `g₂` from `α` to `F`, if `f₁` is Big O of `g₁` at filter `l` (`f₁ =O[l] g₁`), `f₁` is eventually equal to `f₂` at filter `l` (`f₁ =ᶠ[l] f₂`), and `g₁` is eventually equal to `g₂` at filter `l` (`g₁ =ᶠ[l] g₂`), then `f₂` is Big O of `g₂` at filter `l` (`f₂ =O[l] g₂`). In simpler terms, it means that if two pairs of functions are asymptotically equivalent and the functions within each pair are eventually equal, then the resulting pairs of functions are also asymptotically equivalent.

If functions `f₁` and `g₁`, as well as `f₂` and `g₂`, are related by `f₁ =O[l] g₁`, `f₁ =ᶠ[l] f₂`, and `g₁ =ᶠ[l] g₂` for a filter `l` and types `α`, `E`, and `F`, then `f₂ =O[l] g₂`.


theorem quotientMap_quot_mk : ∀ {X : Type u} [inst : TopologicalSpace X] {r : X → X → Prop}, QuotientMap (Quot.mk r) :=
  by sorry

This theorem states that for any type 'X' equipped with a topological space structure, and for any equivalence relation 'r' on 'X', the function that sends each element of 'X' to its equivalence class under 'r' (denoted `Quot.mk r`) is a quotient map. Here, a quotient map is defined for a function between topological spaces that is surjective and for which a set in the codomain is open if and only if its preimage under the function is open in the domain.

Given a topological space 'X' and an equivalence relation 'r' on 'X', the quotient function 'Quot.mk r' is a quotient map.


ContinuousOn.neg

theorem ContinuousOn.neg :
    ∀ {G : Type w} {α : Type u} [inst : TopologicalSpace G] [inst_1 : Neg G] [inst_2 : ContinuousNeg G]
      [inst_3 : TopologicalSpace α] {f : α → G} {s : Set α}, ContinuousOn f s → ContinuousOn (fun x => -f x) s :=
  by sorry

The theorem `ContinuousOn.neg` states that for any topological space `G` and any type `α`, given a function `f` from `α` to `G` that is continuous on a set `s` of `α`, and provided `G` has a negation operation that is continuous, then the function that sends `x` to the negation of `f(x)` is also continuous on `s`. In other words, negating a continuous function on a topological space yields another continuous function on that space, assuming the negation operation itself is continuous.

If a continuous function from a set to a topological space with a continuous negation operation is defined on a subset, then the function sending each element to the negation of its image under the original function is also continuous on that subset.


theorem Mathlib.Combinatorics.SimpleGraph.Subgraph._auxLemma.42 :
    ∀ {V : Type u} {G : SimpleGraph V} {G' : SimpleGraph.Subgraph G} (s : Set (Sym2 V)) (v w : V),
      (SimpleGraph.Subgraph.deleteEdges G' s).Adj v w = (G'.Adj v w ∧ s(v, w) ∉ s) :=
  by sorry

This theorem states that for any type `V`, any simple graph `G` of type `V`, any subgraph `G'` of `G`, any set `s` of unordered pairs of vertices, and any two vertices `v` and `w`, the adjacency between `v` and `w` in the subgraph obtained from `G'` by deleting the edges corresponding to the vertex pairs in `s`, equals the statement that `v` and `w` are adjacent in `G'` and the unordered pair `(v, w)` is not in `s`. In other words, after removing specified edges from `G'`, two vertices remain adjacent if and only if they were originally adjacent and their corresponding pair was not included in the set `s` of edges being removed.

For any simple graph $G$, subgraph $G'$ with deleted edges $s$, and vertices $v$, $w$, $v$ and $w$ are adjacent in $G'$ if and only if they were adjacent in $G$ and $(v, w) \notin s$.


theorem SameRay.sameRay_comm :
    ∀ {R : Type u_1} [inst : StrictOrderedCommSemiring R] {M : Type u_2} [inst_1 : AddCommMonoid M]
      [inst_2 : Module R M] {x y : M}, SameRay R x y ↔ SameRay R y x :=
  by sorry

This theorem states that for any type `R` with a strict ordered commutative semiring structure, type `M` with both an addition commutative monoid and `R`-module structure, and any two elements `x` and `y` of `M`, the relation `SameRay` between `x` and `y` is symmetric. That is, `x` and `y` are in the same ray if and only if `y` and `x` are in the same ray. In other words, the order of `x` and `y` does not matter in the `SameRay` relation: if `x` and `y` could be related by either of them being zero or some positive multiples of them being equal, then the same applies for `y` and `x`.

For any strict ordered commutative semiring `R`, commutative monoid additive `M` over `R`, and all `x, y` in `M`, the relation `SameRay` between `x` and `y` is a symmetric equivalence relation.


theorem orderOf_one : ∀ {G : Type u_1} [inst : Monoid G], orderOf 1 = 1 := by sorry

The theorem `orderOf_one` states that for any type `G` that forms a Monoid (an algebraic structure with a single associative binary operation and an identity element), the order of the identity element, denoted as `1` in this case, is `1`. In other words, if you raise the identity element to the power of `1`, you get the identity element back, as per the definition of a monoid, and no smaller positive integer will satisfy this condition. Hence, the order of the identity is `1`.

For any monoid `G`, the order of its identity element is 1.


theorem Monotone.le_leftLim :
    ∀ {α : Type u_1} {β : Type u_2} [inst : LinearOrder α] [inst_1 : ConditionallyCompleteLinearOrder β]
      [inst_2 : TopologicalSpace β] [inst_3 : OrderTopology β] {f : α → β},
      Monotone f → ∀ {x y : α}, x < y → f x ≤ Function.leftLim f y :=
  by sorry

The theorem `Monotone.le_leftLim` states that for any types `α` and `β`, given `α` is a linear order, `β` is a conditionally complete linear order and a topological space with an order topology, and a function `f` from `α` to `β` that is monotone, for any elements `x` and `y` of type `α` such that `x` is less than `y`, the value of `f` at `x` is less than or equal to the left limit of `f` at `y`. In mathematical terms, if `f` is a monotone function, then for all `x` and `y` such that `x < y`, we have `f(x) ≤ lim₋ₓ₌y f(x)`.

For any monotone function `f` from a linearly ordered type `α` to a conditionally complete linear order and topological space `β` with order topology, if `x` and `y` are in `α` with `x < y`, then `f(x) ≤ lim₋ₓ₌y f(x)`.


theorem Cardinal.infinite_iff : ∀ {α : Type u}, Infinite α ↔ Cardinal.aleph0 ≤ Cardinal.mk α := by sorry

The theorem `Cardinal.infinite_iff` states that for any type `α`, `α` is infinite if and only if the cardinality of `α` is greater than or equal to `ℵ₀`, the smallest infinite cardinal number. The cardinality of `α` is denoted as `Cardinal.mk α`, while `ℵ₀` is represented as `Cardinal.aleph0`. Essentially, this theorem provides a condition for a type to be infinite, namely, that its cardinality must be at least as large as that of the set of natural numbers.

A type `α` is infinite if and only if `Cardinal.mk α ≥ Cardinal.aleph0`.


theorem Mathlib.Algebra.Function.Indicator._auxLemma.9 :
    ∀ {α : Type u_1} {M : Type u_4} [inst : Zero M] {s : Set α} {f : α → M} {a : α},
      (Set.indicator s f a = 0) = (a ∈ s → f a = 0) :=
  by sorry

This theorem states that for any set `s` of elements of type `α`, any function `f` from `α` to `M`, and any element `a` of type `α`, the indicator function of `s` applied to `f` and `a` is equal to `0` if and only if the element `a` is in the set `s` and the function `f` applied to `a` equals `0`. In mathematical terms, we have $\text{Set.indicator } s f a = 0$ if and only if $a \in s \rightarrow f(a) = 0$ for any types `α` and `M` with `M` having a zero element.

For any set `s` of type `α`, function `f` from `α` to a type `M` with zero element, and element `a` of type `α`, the indicator function of `s` applied to `f` and `a` equals `0` if and only if `a` is in `s` and `f(a)` equals `0`.


theorem LinearIsometryEquiv.norm_map :
    ∀ {R : Type u_1} {R₂ : Type u_2} {E : Type u_5} {E₂ : Type u_6} [inst : Semiring R] [inst_1 : Semiring R₂]
      {σ₁₂ : R →+* R₂} {σ₂₁ : R₂ →+* R} [inst_2 : RingHomInvPair σ₁₂ σ₂₁] [inst_3 : RingHomInvPair σ₂₁ σ₁₂]
      [inst_4 : SeminormedAddCommGroup E] [inst_5 : SeminormedAddCommGroup E₂] [inst_6 : Module R E]
      [inst_7 : Module R₂ E₂] (e : E ≃ₛₗᵢ[σ₁₂] E₂) (x : E), ‖e x‖ = ‖x‖ :=
  by sorry

This theorem states that for any types `R`, `R₂`, `E`, and `E₂`, given two semirings `R` and `R₂`, two ring homomorphisms `σ₁₂` and `σ₂₁` that form a pair of inverse homomorphisms, two seminormed additive commutative groups `E` and `E₂`, `R` and `R₂` modules over `E` and `E₂`, and a linear isometry equivalence `e` between `E` and `E₂`, the norm of the image of any element `x` under `e` is equal to the norm of `x`. In other words, the linear isometry equivalence preserves norms.

Given semirings R and R₂, ring homomorphisms σ₁₂ and σ₂₁ that form a pair of inverse homomorphisms, seminormed additive commutative groups E and E₂ with linear isometry equivalence e between them, and modules M over E and M₂ over E₂: For all x in E, ||ex|| = ||x||, where ||.|| denotes the norm.


theorem CategoryTheory.Functor.comp_map :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂}
      [inst_1 : CategoryTheory.Category.{v₂, u₂} D] {E : Type u₃} [inst_2 : CategoryTheory.Category.{v₃, u₃} E]
      (F : CategoryTheory.Functor C D) (G : CategoryTheory.Functor D E) {X Y : C} (f : X ⟶ Y),
      (CategoryTheory.Functor.comp F G).map f = G.map (F.map f) :=
  by sorry

This theorem states that, in category theory, given two categories `C` and `D` and a third category `E`, together with functors `F` from `C` to `D` and `G` from `D` to `E`, the composition of the functors `F` and `G` applied to a morphism `f` from `C` is equal to the functor `G` applied to the result of the functor `F` applied to `f`. This embodies the concept of functor composition, which is a central concept in category theory, and is analogous to the composition of functions in set theory.

Given functors F from category C to D and G from category D to E, the composition Functor(G ∘ F) equals Functor(G) ∘ Morphism(F), where Morphism(F) denotes the image of morphisms under F.


theorem MvPolynomial.eval_C :
    ∀ {R : Type u} {σ : Type u_1} [inst : CommSemiring R] {f : σ → R} (a : R),
      (MvPolynomial.eval f) (MvPolynomial.C a) = a :=
  by sorry

The theorem `MvPolynomial.eval_C` states that for any type `R` representing a commutative semiring, a type `σ`, a function `f` from `σ` to `R`, and an element `a` of `R`, the evaluation of the constant multivariate polynomial with value `a` under the function `f` is equal to `a`. This means that the evaluation function applied to a constant polynomial simply returns the constant value itself, without any consideration of the function `f` or the variables in the polynomial.

For any commutative semiring R, constant multivariate polynomial p over R, and function f : σ -> R, the evaluation of p under f is equal to the constant value p.


theorem MulAction.exists_smul_eq :
    ∀ (M : Type u_1) {α : Type u_6} [inst : SMul M α] [inst_1 : MulAction.IsPretransitive M α] (x y : α),
      ∃ m, m • x = y :=
  by sorry

This theorem states that for any two elements `x` and `y` of a certain type `α`, in the context where `α` is a set on which a type `M` acts via scalar multiplication (`SMul`) and this action is pretransitive (`MulAction.IsPretransitive`), there exists an element `m` of type `M` such that the scalar multiplication of `m` and `x` equals `y`. In mathematical terms, given any `x` and `y` in `α`, there exists `m` in `M` such that `m * x = y`.

For any `x` and `y` in a set `α` with respect to an pretransitive `M`-module structure on `α`, there exists an element `m` in `M` such that `m * x = y`.


theorem RingHom.map_prod :
    ∀ {α : Type u_3} {β : Type u_4} {γ : Type u_5} [inst : CommSemiring β] [inst_1 : CommSemiring γ] (g : β →+* γ)
      (f : α → β) (s : Finset α), g (Finset.prod s fun x => f x) = Finset.prod s fun x => g (f x) :=
  by sorry

The theorem `RingHom.map_prod` states that for all types `α`, `β`, and `γ`, given two commutative semirings `β` and `γ`, a ring homomorphism `g` from `β` to `γ`, a function `f` from `α` to `β`, and a finite set `s` of type `α`, the application of `g` to the product of `f x` for each `x` in `s` is the same as the product of `g(f x)` for each `x` in `s`. In mathematical terms, this can be expressed as: for a ring homomorphism `g: β → γ` and a function `f: α → β`, we have `g(∏ x in s, f(x)) = ∏ x in s, g(f(x))`, where `∏ x in s, f(x)` denotes the product of `f(x)` as `x` ranges over `s`.

For any commutative semirings β and γ, a ring homomorphism g from β to γ, and a function f from α to β, the product g(∏ x in s, f(x)) equals the product ∏ x in s, g(f(x)), where s is a finite set of type α.


theorem contDiffAt_id :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type uE} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {n : ℕ∞} {x : E}, ContDiffAt 𝕜 n id x :=
  by sorry

This theorem states that the identity function is continuously differentiable at every point in its domain. Specifically, for any nontrivially normed field `𝕜`, normed additive commutative group `E` (which is also a normed space over `𝕜`), and any `x` in `E`, the identity function is `n`-times continuously differentiable at `x`. In mathematical terms, if `id` denotes the identity function, then it holds that `id ∈ C^n(𝕜)`, where `C^n(𝕜)` is the class of functions that are `n`-times continuously differentiable on `𝕜`.

For any nontrivially normed field `𝕜` and normed additive commutative group `E` over `𝕜`, the identity function `id` is `n`-times continuously differentiable on `E`.


/-- The range of a surjective monoid homomorphism is the whole of the codomain.  -/
theorem MonoidHom.range_top_of_surjective :
    ∀ {G : Type u_1} [inst : Group G] {N : Type u_7} [inst_1 : Group N] (f : G →* N),
      Function.Surjective ⇑f → MonoidHom.range f = ⊤ :=
  by sorry

The theorem `MonoidHom.range_top_of_surjective` states that for any given groups `G` and `N`, if a monoid homomorphism `f` exists from `G` to `N` that is surjective (i.e., every element of `N` is the image of some element in `G` under `f`), then the range of `f` equals the entire group `N`. In other words, a surjective monoid homomorphism maps its domain onto the entirety of its codomain.

If `f` is a surjective monoid homomorphism from group `G` to group `N`, then the range of `f` equals `N`.


theorem Finset.min'_le :
    ∀ {α : Type u_2} [inst : LinearOrder α] (s : Finset α) (x : α) (H2 : x ∈ s), Finset.min' s ⋯ ≤ x := by sorry

The theorem `Finset.min'_le` states that for any type `α` that has a linear order structure, for any finite set `s` of elements of `α`, and for any element `x` of `α` that belongs to `s`, the minimum element of `s` (obtained by the function `Finset.min'`) is less than or equal to `x`. This means, in the context of an ordered set, the minimum element is either equal to or smaller than all other elements in the set.

For any type `α` with a linear order structure, and for any finite set `s ⊆ α` and `x ∈ s`, the minimum element `m` of `s` satisfies `m ≤ x`.


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

This theorem states that for any type `X` endowed with a topology (i.e., `X` has a topological space structure), the closure of the universal set is the universal set itself. In mathematical terms, given any topological space `X`, the smallest closed set that contains all elements of `X` (the closure of the universal set) is just the set of all elements of `X` (the universal set). This result is expected because the universal set, containing all elements, is inherently closed, so its closure doesn't have to include any additional elements.

In a topological space, the closure of the universal set is equivalent to the universal set itself.


theorem Multiset.card_cons : ∀ {α : Type u_1} (a : α) (s : Multiset α), Multiset.card (a ::ₘ s) = Multiset.card s + 1 :=
  by sorry

The theorem `Multiset.card_cons` states that for any type `α`, any element `a` of type `α`, and any multiset `s` of type `α`, the cardinality (or size) of the multiset resulting from consing `a` onto `s` (`a ::ₘ s`) equals the cardinality of `s` plus one. This mirrors the behavior of adding an element to a list where the length of the list increases by one.

For any type α and multiset s of α, the cardinality of the multiset obtained by adding an element a to s is one greater than the cardinality of s.


theorem CharP.char_is_prime_or_zero :
    ∀ (R : Type u_1) [inst : NonAssocSemiring R] [inst_1 : NoZeroDivisors R] [inst_2 : Nontrivial R] (p : ℕ)
      [hc : CharP R p], Nat.Prime p ∨ p = 0 :=
  by sorry

The theorem `CharP.char_is_prime_or_zero` states that for any type `R` that has the structure of a non-associative semiring (i.e., a mathematical structure that behaves like numbers under addition and multiplication, but multiplication doesn't necessarily associate) and additionally has no zero divisors and is nontrivial (i.e., `R` contains at least two distinct elements), and for any natural number `p` such that `R` has characteristic `p` (i.e., `p` is the least positive integer such that `p` times any element of `R` is zero), then `p` is either a prime number or zero. Here, a prime number is defined as a natural number greater than or equal to 2 whose only divisors are itself and 1.

In a non-associative semiring without zero divisors and of nontrivial size, the characteristic is either 0 or a prime number.


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

This theorem states that for any commutative semiring `R`, any semiring `A`, and any algebra structure over `R` and `A`, if `S` is a subalgebra of `A` over `R` and if `x` and `y` are elements of `S`, then the sum of `x` and `y` is also an element of `S`. In other words, the sum of any two elements in a subalgebra of an algebra is also in the subalgebra, showing that the subalgebra is closed under addition.

Given a commutative semiring `R`, an algebra `A` over `R`, a subalgebra `S` of `A` over `R`, and elements `x`, `y` in `S`, the sum `x + y` is also in `S`.


theorem mul_le_mul_of_nonpos_left :
    ∀ {α : Type u} [inst : OrderedSemiring α] {a b c : α} [inst_1 : ExistsAddOfLE α]
      [inst_2 : ContravariantClass α α (Function.swap fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1],
      b ≤ a → c ≤ 0 → c * a ≤ c * b :=
  by sorry

The theorem `mul_le_mul_of_nonpos_left` states that for any ordered semiring `α`, if `b` is less than or equal to `a` and `c` is less than or equal to `0`, then the product `c * a` is less than or equal to the product `c * b`. It is important to have the property `ExistsAddOfLE α`, which ensures the existence of addition operation satisfying certain properties. Also, the contravariant property is required which states that if `x + y` is less than `x + z` for all `y` and `z`, then `y` is less than `z` in `α`.

For any ordered semiring `α` with `ExistsAddOfLE` and the contravariant property, if `c ≤ 0`, `b ≤ a`, then `c * a ≤ c * b`.


theorem Real.sinh_zero : Real.sinh 0 = 0 := by sorry

This theorem states that the real hyperbolic sine of zero is zero. In mathematical terms, this can be written as $\sinh(0) = 0$. This is a property of the real hyperbolic sine function, which is defined as the real part of the complex hyperbolic sine.

The real hyperbolic sine function evaluates to zero at zero: $\sinh(0) = 0$.


theorem gc_coinduced_induced :
    ∀ {α : Type u_1} {β : Type u_2} (f : α → β),
      GaloisConnection (TopologicalSpace.coinduced f) (TopologicalSpace.induced f) :=
  by sorry

This theorem states that for all types `α` and `β` and a function `f` from `α` to `β`, there exists a Galois connection between the coinduced topology on `β` (which is the finest topology that makes `f` continuous) and the induced topology on `α` (which is the coarsest topology that makes `f` continuous). In other words, a subset `s` of `β` is open in the coinduced topology if and only if its preimage under `f` is open in the induced topology on `α`. This Galois connection provides a relation between the two topologies induced by the function `f`.

For every function `f` from type `α` to type `β`, the coinduced topology on `β` and the induced topology on `α` form a Galois connection, where a subset `s` of `β` is open in the coinduced topology if and only if `f⁁¹(s)` is open in the induced topology on `α`.


theorem MeasureTheory.Measure.comap_apply :
    ∀ {α : Type u_1} {s : Set α} {β : Type u_8} [inst : MeasurableSpace α] {_mβ : MeasurableSpace β} (f : α → β),
      Function.Injective f →
        (∀ (s : Set α), MeasurableSet s → MeasurableSet (f '' s)) →
          ∀ (μ : MeasureTheory.Measure β), MeasurableSet s → ↑↑(MeasureTheory.Measure.comap f μ) s = ↑↑μ (f '' s) :=
  by sorry

The theorem `MeasureTheory.Measure.comap_apply` states that for any types `α` and `β`, a set `s` of type `α`, and a function `f` from `α` to `β` which is injective, if every measurable set in `α` is mapped to a measurable set in `β` by `f`, then for any measure `μ` on `β`, the measure of the set `s` under the comap of `f` and `μ` is equal to the measure of the image of `s` under `f` in the measure `μ`, provided `s` is a measurable set. In other words, the measure of a set under the comap of a measure corresponds to the measure of its image under the original measure, when considering injective functions that map measurable sets to measurable sets.

If `f: α → β` is injective and maps measurable sets to measurable sets, then for any measurable set `s ∈ α` and measure `μ` on `β`, `MeasureTheory.Measure.comap_apply μ f s` equals the measure of `f''s` under `μ`.


List.IsPrefix.sublist

theorem List.IsPrefix.sublist : ∀ {α : Type u_1} {l₁ l₂ : List α}, l₁ <+: l₂ → List.Sublist l₁ l₂ := by sorry

This theorem states that for any type `α` and any two lists `l₁` and `l₂` of this type, if `l₁` is a prefix of `l₂` (denoted as `l₁ <+: l₂`), then `l₁` is also a sublist of `l₂`. In other words, if all the elements of `l₁` appear at the start of `l₂` in the same order, then `l₁` is considered a sublist of `l₂`, where the elements of `l₁` need not be consecutive in `l₂` but must maintain their order.

If `α` is a type and `l₁` is a prefix of `l₂` (`l₁ <+: l₂`), then `l₁` is a sublist of `l₂`.


theorem Submodule.fg_def :
    ∀ {R : Type u_1} {M : Type u_2} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
      {N : Submodule R M}, Submodule.FG N ↔ ∃ S, Set.Finite S ∧ Submodule.span R S = N :=
  by sorry

The theorem `Submodule.fg_def` states that for any semiring `R`, any additive commutative monoid `M`, and any submodule `N` of `M` over `R`, `N` is finitely generated (i.e., it is the span of a finite subset of `M`) if and only if there exists a set `S` such that `S` is finite and the span of `S` is `N`. The span of a set is defined as the smallest submodule that contains that set. Therefore, a submodule is finitely generated if it can be expressed as the span of a finite set.

A submodule of an additive commutative monoid over a semiring is finitely generated if and only if it is the span of a finite set.


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

This theorem states that for any types `α` and `β`, and any function `f` from `α` to `β` where `β` has decidable equality, the image of the empty set under this function `f` is also the empty set. In other words, if you apply a function to each element of an empty set, the resulting set is still empty, regardless of the function. This is because there are no elements in the empty set to which the function can be applied.

For any types `α` and `β` and decidably equal function `f : α → β`, the image of the empty set under `f` is empty.


theorem Nat.Coprime.dvd_of_dvd_mul_left : ∀ {k m n : ℕ}, Nat.Coprime k m → k ∣ m * n → k ∣ n := by sorry

The theorem `Nat.Coprime.dvd_of_dvd_mul_left` states that for any three natural numbers `k`, `m`, and `n`, if `k` and `m` are coprime (that is, their greatest common divisor is 1), and if `k` divides the product `m * n`, then `k` must also divide `n`. This is a property related to the concept of coprimality and divisibility in number theory.

If `k` is coprime to `m` and `k` divides `m * n`, then `k` divides `n`.


theorem Fin.predAbove_of_le_castSucc :
    ∀ {n : ℕ} (p : Fin n) (i : Fin (n + 1)) (h : i ≤ Fin.castSucc p) (hi : optParam (i ≠ Fin.last n) ⋯),
      Fin.predAbove p i = Fin.castPred i hi :=
  by sorry

The theorem `Fin.predAbove_of_le_castSucc` states that for any natural number `n`, and any numbers `p` of type `Fin n` and `i` of type `Fin (n + 1)`, if `i` is less than or equal to the embedding of `p` in `Fin (n+1)` (`Fin.castSucc p`), then the operation `Fin.predAbove p i` is equivalent to subtracting one from `i` (`Fin.castPred i`) given that `i` is not the maximum value in `Fin (n+1)`. We can optionally specify `i` not equal to `Fin.last n` as an additional parameter (`hi`), which triggers the Lean 4 theorem prover to attempt to use this fact if it is not explicitly provided.

For any natural numbers $n$, $p$ in $Fin(n)$, and $i$ in $Fin(n+1)$, if $i \leq \text{cast}_+(p)$ and $i \neq \text{last}(n+1)$, then $\text{predAbove}_p i = \text{castPred}\ i$.


PSet.Equiv.trans

theorem PSet.Equiv.trans : ∀ {x : PSet} {y : PSet} {z : PSet}, PSet.Equiv x y → PSet.Equiv y z → PSet.Equiv x z := by
  sorry

This theorem establishes the transitivity property for the equivalence of pre-sets. In more detail, given any three pre-sets, `x`, `y`, and `z`, if `x` is equivalent to `y` and `y` is equivalent to `z`, then `x` is also equivalent to `z`. Here, the equivalence of two pre-sets is defined as each element of the first pre-set being extensionally equivalent to some element of the second pre-set and vice versa.

If pre-sets `x` and `y` are equivalent, and `y` and `z` are equivalent, then `x` and `z` are equivalent. (Extensional equality preserves transitivity)


theorem Fintype.card_sum :
    ∀ {α : Type u_1} {β : Type u_2} [inst : Fintype α] [inst_1 : Fintype β],
      Fintype.card (α ⊕ β) = Fintype.card α + Fintype.card β :=
  by sorry

The `Fintype.card_sum` theorem states that for any two types `α` and `β` that are finite (`Fintype`), the cardinality (or the number of elements) of the sum type `α ⊕ β` is equal to the sum of the cardinalities of `α` and `β`. In mathematical terms, if `α` and `β` are finite sets, then the size of the disjoint union of `α` and `β` is equal to the sum of the sizes of `α` and `β`.

The cardinality of the sum type `α ⊕ β` in Lean's `Fintype` theory equals the sum of the cardinalities of `α` and `β` for finite types `α` and `β`.


theorem Matrix.empty_val' : ∀ {α : Type u} {n' : Type u_4} (j : n'), (fun i => ![]) = ![] := by sorry

This theorem states that for any given type `α` and `n'`, and for any value `j` of type `n'`, the function which maps any index `i` to an empty list is itself an empty list. Essentially, it's saying that an empty matrix (represented as a function from indices to lists) is equivalent to an empty list, no matter what type the indices or elements of the matrix are.

For any type `α` and natural number `n`, the function from indices `i` to empty lists `[] : List α` is equal to the empty list `[] : List (List α)`.


theorem Mathlib.Algebra.Order.Group.Defs._auxLemma.44 :
    ∀ {α : Type u} [inst : AddGroup α] [inst_1 : LE α]
      [inst_2 : CovariantClass α α (Function.swap fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] {a b : α},
      (0 ≤ a - b) = (b ≤ a) :=
  by sorry

This theorem, `Mathlib.Algebra.Order.Group.Defs._auxLemma.44`, states that for any type `α` which forms an additive group and has a partial order, if `α` also satisfies the covariance property under the operation of swapping arguments of addition (i.e., Function.swap applied to the addition function) and the less than or equal to ordering, then for any two elements `a` and `b` of type `α`, the statement "zero is less than or equal to the difference of `a` and `b`" is equivalent to the statement "`b` is less than or equal to `a`". In other words, `b ≤ a` if and only if `0 ≤ a - b`.

For an additive group `α` with a partial order, if swapping arguments preserves both the group operation and the ordering, then `b ≤ a` if and only if `0 ≤ a - b`.


theorem bne_self_eq_false : ∀ {α : Type u_1} [inst : BEq α] [inst_1 : LawfulBEq α] (a : α), (a != a) = false := by sorry

This theorem, `bne_self_eq_false`, states that for all types `α` equipped with a binary equality (`BEq`) operation that satisfies the laws of a `LawfulBEq`, the binary non-equality (`!=`) of any element `a` from `α` with itself is always `false`. In more plain terms, it means that an element is never not equal to itself, across all types that permit lawful binary equality operations.

For all types `α` with a lawful binary equality operation `BEq`, `a BEq a` holds for all `a : α`. Therefore, `a != a` is false for all `a : α`.


theorem Mathlib.Algebra.Order.Group.Defs._auxLemma.12 :
    ∀ {α : 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 : α}, (-a < 0) = (0 < a) :=
  by sorry

This theorem from Mathlib's Algebraic Order Group Definitions, denoted as `_auxLemma.12`, states that for any type `α` that is an additive group and has an order relation `<` compatible with addition, the inequality `-a < 0` is equivalent to `0 < a` for any element `a` of `α`. In other words, a negative quantity is less than zero if and only if zero is less than the corresponding positive quantity.

For any additive group type `α` with a compatible order relation `<`, the inequality `-a < 0` is equivalent to `0 < a`.


Measurable.indicator

theorem Measurable.indicator :
    ∀ {α : Type u_1} {β : Type u_2} {s : Set α} {f : α → β} {m : MeasurableSpace α} {mβ : MeasurableSpace β}
      [inst : Zero β], Measurable f → MeasurableSet s → Measurable (Set.indicator s f) :=
  by sorry

The theorem `Measurable.indicator` states that for any types `α` and `β`, a set `s` of type `α`, a function `f` mapping from `α` to `β`, and measurable spaces `m` over `α` and `mβ` over `β`, if the type `β` has a zero element (`inst : Zero β`), then if the function `f` is measurable and the set `s` is a measurable set, the function `Set.indicator s f` is also measurable. Here, `Set.indicator s f` is a function that takes an element of `α` and returns `f` of that element if the element is in set `s`, and returns `0` otherwise.

If `α` is a type, `s` is a measurable set of `α`, `f : α -> β` is a measurable function with `β` having a zero element, then `Set.indicator s f : α -> β` is a measurable function.


theorem Finset.sum_dite_eq :
    ∀ {α : Type u_3} {β : Type u_4} [inst : AddCommMonoid β] [inst_1 : DecidableEq α] (s : Finset α) (a : α)
      (b : (x : α) → a = x → β), (Finset.sum s fun x => if h : a = x then b x h else 0) = if a ∈ s then b a ⋯ else 0 :=
  by sorry

This theorem, `Finset.sum_dite_eq`, states that for any types `α` and `β` (with `β` being an additive commutative monoid), given a decidable equality on `α`, a finite set `s` of type `α`, an element `a` of type `α`, and a function `b` from `α` (and a proof that `a` equals that element of `α`) to `β`, the sum over `s` of the function that equals `b x` if `a` equals `x` and `0` otherwise, equals `b a` if `a` is in `s` and `0` otherwise. Essentially, it's stating that in a summation over a set, if we're adding up a function that is zero except at one particular point, the sum just equals the function's value at that point (if the point is in the set) or zero (if the point isn't in the set).

For any additive commutative monoid type `β`, given a decidable equality on type `α`, a finite set `s` of type `α`, an element `a` of type `α`, and a function `b` from `α` to `β` with `b a` defined when `a` is in `s`, the sum of `b x` over `s` equals `b a` if `a` is in `s`, and zero otherwise.


theorem add_lt_add_of_lt_of_lt :
    ∀ {α : Type u_1} [inst : Add α] [inst_1 : Preorder α]
      [inst_2 : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x < x_1]
      [inst_3 : CovariantClass α α (Function.swap fun x x_1 => x + x_1) fun x x_1 => x < x_1] {a b c d : α},
      a < b → c < d → a + c < b + d :=
  by sorry

The theorem `add_lt_add_of_lt_of_lt` is a statement about an ordered, additive structure. It states that for any type `α` which has an addition operation and a preorder (a binary relation that is reflexive and transitive), and satisfies the covariance property with respect to addition and the less-than relation, if `a` is less than `b` and `c` is less than `d` (where `a`, `b`, `c`, and `d` are elements of `α`), then `a + c` is less than `b + d`. This is a version of the property that addition preserves order, which holds in many familiar ordered additive structures, like the natural numbers, integers, rationals, reals, etc.

Given an additive preorder structure α with covariance property, if a < b and c < d, then a + c < b + d.


theorem ModelWithCorners.left_inv :
    ∀ {𝕜 : 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) (x : H),
      ↑(ModelWithCorners.symm I) (↑I x) = x :=
  by sorry

The theorem `ModelWithCorners.left_inv` states that for any nontrivially normed field `𝕜`, any normed add commutative group `E` over `𝕜`, and any topological space `H`, if `I` is a model with corners from `E` to `H` and `x` is an element of `H`, then applying the inverse operation `ModelWithCorners.symm` to the result of applying `I` to `x` gives us back `x`. In essence, this is a theorem about the left-inverse property of the model with corners, which asserts that applying the model and then its inverse leaves any space element unchanged.

For any nontrivially normed field `𝕜`, normed add commutative group `E` over `𝕜`, topological space `H`, and a model with corners `I` from `E` to `H`, `ModelWithCorners.symm ∘ I = id_H`, where `id_H` is the identity function on `H`.


IsCoprime.symm

theorem IsCoprime.symm : ∀ {R : Type u} [inst : CommSemiring R] {x y : R}, IsCoprime x y → IsCoprime y x := by sorry

The theorem `IsCoprime.symm` states that the property of being coprime is symmetric. In other words, for any type `R` that has a commutative semiring structure, and any elements `x` and `y` of `R`, if `x` and `y` are coprime, then `y` and `x` are also coprime. Here, being coprime is defined as the existence of a pair of elements `a` and `b` in `R` such that `a * x + b * y = 1`.

If `x` and `y` are coprime elements in a commutative semiring `R`, then `y` and `x` are also coprime. Equivalently, the existence of `a` and `b` in `R` such that `a * x + b * y = 1` implies the existence of `c` and `d` in `R` such that `c * y + d * x = 1`.


theorem Real.one_rpow : ∀ (x : ℝ), 1 ^ x = 1 := by sorry

This theorem states that for every real number `x`, the real number `1` raised to the power of `x` always equals `1`. This is a mathematical property of the number `1` in real number space where any power of `1` results in `1`.


theorem WellFounded.fix_eq :
    ∀ {α : Sort u} {C : α → Sort v} {r : α → α → Prop} (hwf : WellFounded r)
      (F : (x : α) → ((y : α) → r y x → C y) → C x) (x : α),
      WellFounded.fix hwf F x = F x fun y x => WellFounded.fix hwf F y :=
  by sorry

This theorem states that for any well-founded relation `r` on a type `α`, and for any function `F` that takes an element of this type and a function (which itself takes an element `y` of type `α` and a proof that `y` is related to the original element by `r`, returning a type `C y`), and an element `x` of `α`, the well-founded fixpoint of `F` at `x` is equal to `F` applied to `x` and a function that takes `y` and a proof of `r y x`, and returns the well-funded fixpoint of `F` at `y`. In other words, it shows how the computation of `WellFounded.fix` unfolds, allowing to recursively apply `F` to smaller arguments according to the well-founded relation `r`.

For any well-founded relation `r` on type `α` and function `F`: The well-founded fixpoint of `F` at an element `x` equals `F` applied to `x` and the well-founded fixpoint of `F` at a related `y`.


theorem sq_eq_sq :
    ∀ {R : Type u_3} [inst : LinearOrderedSemiring R] {a b : R}, 0 ≤ a → 0 ≤ b → (a ^ 2 = b ^ 2 ↔ a = b) := by sorry

This theorem, `sq_eq_sq`, states that for any type `R` that has the structure of a linear ordered semiring, given any two non-negative elements `a` and `b` from `R`, `a` squared is equal to `b` squared if and only if `a` is equal to `b`. It essentially states that in a linear ordered semiring, squaring is an injective operation for non-negative numbers.

In a linear ordered semiring, for all non-negative elements `a` and `b`, `a^2 = b^2` if and only if `a = b`.


theorem nhdsWithin_inter_of_mem :
    ∀ {α : Type u_1} [inst : TopologicalSpace α] {a : α} {s t : Set α},
      s ∈ nhdsWithin a t → nhdsWithin a (s ∩ t) = nhdsWithin a t :=
  by sorry

This theorem states that for any type 'α' equipped with a topology, and any element 'a' of this type, along with two sets 's' and 't' of this type, if 's' is in the neighborhood within 't' of 'a', then the neighborhood within the intersection of 's' and 't' of 'a' is equal to the neighborhood within 't' of 'a'. In other words, within a topological space, if a set 's' is found within a certain neighborhood of 'a' confined to another set 't', then the neighborhood of 'a' within the intersection of 's' and 't' doesn't change the original neighborhood within 't' of 'a'.

Given a topological space 'α' and an element 'a' in it, if 's' is a neighborhood of 'a' contained in 't', then the neighborhood of 'a' in the intersection of 's' and 't' equals the neighborhood of 'a' in 't'.


theorem List.Sublist.cons_cons :
    ∀ {α : Type u} {l₁ l₂ : List α} (a : α), List.Sublist l₁ l₂ → List.Sublist (a :: l₁) (a :: l₂) := by sorry

This theorem states that for any type `α`, any two lists `l₁` and `l₂` of type `α`, and any element `a` of type `α`, if `l₁` is a sublist of `l₂`, then the list obtained by consing `a` onto `l₁` is a sublist of the list obtained by consing `a` onto `l₂`. In other words, prepending the same element to both the sublist and the larger list preserves the sublist relationship.

If `l₁` is a sublist of `l₂` in type `α`, then consing `a` to `l₁` results in a sublist of consing `a` to `l₂`. In mathematical notation, `l₁ ⊆ l₂` implies `a :: l₁ ⊆ a :: l₂`.


theorem inv_neg : ∀ {K : Type u_3} [inst : DivisionMonoid K] [inst_1 : HasDistribNeg K] {a : K}, (-a)⁻¹ = -a⁻¹ := by
  sorry

This theorem, `inv_neg`, states that for any type `K` that is a division monoid and supports distributed negation, the inverse of the negation of any element `a` from `K` is equal to the negative of the inverse of `a`. In mathematical terms, it asserts that `(-a)⁻¹ = -a⁻¹` for all `a` in `K`.

For any type `K` being a division monoid with distributed negation, the inverse of the negation of an element `a` equals the negation of the inverse of `a`: `(-a)⁻¹ = -a⁻¹`.


theorem div_eq_one : ∀ {G : Type u_3} [inst : Group G] {a b : G}, a / b = 1 ↔ a = b := by sorry

This theorem, named `div_eq_one`, states that for any type `G` which forms a group (i.e., a set that has an associated operation satisfying certain properties), for any two elements `a` and `b` of this group, the quotient of `a` divided by `b` is equal to the identity element `1` if and only if `a` is equal to `b`. In other words, in a group, an element divided by another results in the identity only when those two elements are the same.

In a group, for all elements `a` and `b`, `a / b = 1` if and only if `a = b`.


Set.Countable.union

theorem Set.Countable.union : ∀ {α : Type u} {s t : Set α}, Set.Countable s → Set.Countable t → Set.Countable (s ∪ t) :=
  by sorry

The theorem `Set.Countable.union` states that for any type `α` and for any two sets `s` and `t` of type `α`, if both `s` and `t` are countable sets then their union `s ∪ t` is also a countable set. This essentially means that the union of two countable sets is itself a countable set.

If `s` and `t` are countable sets, then their union `s ∪ t` is also a countable set.


theorem neg_eq_of_add_eq_zero_left : ∀ {G : Type u_1} [inst : SubtractionMonoid G] {a b : G}, a + b = 0 → -b = a := by
  sorry

This theorem states that for any type `G` which is an instance of a `SubtractionMonoid`, given two elements `a` and `b` of `G`, if the sum of `a` and `b` equals zero, then the additive inverse of `b` is equal to `a`. This is an algebraic property closely related to the definition of subtraction in a subtraction monoid. Essentially, it's saying that if adding `b` to `a` results in zero, then `a` must be the value that negates `b`, i.e., `-b = a`.

If `G` is a subtraction monoid and `a`, `b` are its elements with `a + b = 0`, then `b` is the additive inverse of `a`, i.e., `a = -b`.


ContinuousOn.continuousWithinAt

theorem ContinuousOn.continuousWithinAt :
    ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] {f : α → β} {s : Set α}
      {x : α}, ContinuousOn f s → x ∈ s → ContinuousWithinAt f s x :=
  by sorry

This theorem states that for any given types `α` and `β` with topological structures, a function `f` from `α` to `β`, a set `s` of `α`, and an element `x` of `α`, if the function `f` is continuous on the set `s`, and the element `x` is a member of the set `s`, then the function `f` is continuous at the point `x` within the set `s`. In mathematical terms, this means that the function `f` tends to the limit `f(x)` as `x` approaches `x₀` within the set `s`.

If `f` is a continuous function from topological spaces `α` to `β`, `x` is an element of the domain `α`, and `s` is a subset of `α` where `f` is continuous at `x`, then `f` is continuous at `x` with respect to the subspace topology of `s`.


theorem Set.mul_mem_mul : ∀ {α : Type u_2} [inst : Mul α] {s t : Set α} {a b : α}, a ∈ s → b ∈ t → a * b ∈ s * t := by
  sorry

The theorem `Set.mul_mem_mul` states that for any type `α` that has a multiplication operation, given two sets `s` and `t` of type `α`, and two elements `a` and `b` from `α`, if `a` is an element of set `s` and `b` is an element of set `t`, then the product `a * b` is an element of the set formed by the multiplication of sets `s` and `t`.

For any types `α` with multiplication and sets `s` and `t` of `α`, if `a ∈ s` and `b ∈ t`, then `a * b ∈ s × t`. (Assuming `×` denotes the set product.)


theorem ENNReal.coe_toReal : ∀ (r : NNReal), (↑r).toReal = ↑r := by sorry

This theorem, `ENNReal.coe_toReal`, states that for every nonnegative real number `r`, the real part obtained from the natural number (integer) coercion of `r` is equal to the integer coercion of `r` itself. In other words, applying the `toReal` function to the natural number created by coercing `r` will not affect the value, it will still remain as the original `r`. This ensures that we can safely convert a nonnegative real number to an integer and back without loss of information.

For all non-negative real numbers r, the real part of the coercion of r to a natural number is equal to the coercion of r itself. In Lean, this is expressed as `ENNReal.coe_toReal r = r`.


theorem ContDiff.of_le :
    ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {E : Type uE} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {F : Type uF} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {f : E → F}
      {m n : ℕ∞}, ContDiff 𝕜 n f → m ≤ n → ContDiff 𝕜 m f :=
  by sorry

This theorem states that for any non-trivially normed field `𝕜`, normed additive commutative group `E` and `F`, and the normed spaces `𝕜 E` and `𝕜 F`, if a function `f` from `E` to `F` is continuous and differentiable up to order `n`, and if `m` is less than or equal to `n`, then `f` is also continuous and differentiable up to order `m`. This is essentially saying that if a function is differentiable up to a certain order, it is also differentiable up to any lesser order.

If `f` is a continuously differentiable up to order `n` function from the normed additive commutative group `E` to the normed space `𝕜F` over the non-trivially normed field `𝕜`, then `f` is also continuously differentiable up to order `m` for any `m` less than or equal to `n`.


theorem Fintype.card_pos : ∀ {α : Type u_1} [inst : Fintype α] [h : Nonempty α], 0 < Fintype.card α := by sorry

The theorem `Fintype.card_pos` states that for any type `α` which has a finite number of elements (i.e., is a `fintype`), if `α` is nonempty, then the cardinality of `α` (the number of elements in `α`, denoted as `Fintype.card α`) is strictly greater than zero. In other words, if a type has a finite number of elements and is not empty, then it must have at least one element.

If `α` is a nonempty finite type, then `Fintype.card α` is strictly positive.


theorem CategoryTheory.Subobject.underlyingIso_hom_comp_eq_mk :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X Y : C} (f : X ⟶ Y) [inst_1 : CategoryTheory.Mono f],
      CategoryTheory.CategoryStruct.comp (CategoryTheory.Subobject.underlyingIso f).hom f =
        CategoryTheory.Subobject.arrow (CategoryTheory.Subobject.mk f) :=
  by sorry

This theorem states that for any category 'C', and any two objects 'X' and 'Y' in 'C', given a monomorphism 'f' from 'X' to 'Y', the composition of the underlying isomorphism of 'f' and 'f' itself is equal to `CategoryTheory.Subobject.arrow` applied to the subobject created by 'f' (denoted by `CategoryTheory.Subobject.mk f`). In simpler terms, it establishes a relationship between the composition of a morphism with its underlying isomorphism and the arrow of the subobject created by the morphism itself in the context of category theory.

For any category 'C' and monomorphism 'f' from object 'X' to object 'Y', the composition of 'f' and its underlying isomorphism equals `CategoryTheory.Subobject.arrow` of the subobject of 'Y' generated by 'f'.


theorem Localization.mk_eq_mk' :
    ∀ {R : Type u_1} [inst : CommSemiring R] {M : Submonoid R}, Localization.mk = IsLocalization.mk' (Localization M) :=
  by sorry

This theorem states that for any commutative semiring `R` and any submonoid `M` of `R`, the function `Localization.mk` is equivalent to `IsLocalization.mk'` when the latter is applied to the localization of `R` at `M`. In other words, both functions, which construct elements of the localization, are the same in this context. The `Localization.mk` function constructs an element of the localization by sending a pair `(x, y)` to its equivalence class under the localization relation, while `IsLocalization.mk'` does it by mapping `(x, y)` to the element `f(x) * (f(y))⁻¹` in the localization. Here, `f` is a function that maps elements of `R` to elements of the localization.

For any commutative semiring `R` and submonoid `M`, the `Localization.mk` and `IsLocalization.mk'` functions constructing elements in the localization of `R` at `M` are equal.


theorem Not.imp_symm : ∀ {a b : Prop}, (¬a → b) → ¬b → a := by sorry

This theorem states that for any two propositions `a` and `b`, if `b` is true whenever `a` is not true (expressed as `(¬a → b)`), then if `b` is not true (expressed as `¬b`), `a` must be true. In simpler terms, if the truth of `b` relies on the falsehood of `a`, then the falsehood of `b` guarantees the truth of `a`.

If `(¬a → b)`, then `(¬b → a)`. In other words, the implication `a → b` is logically equivalent to the implication `¬b → a`.


theorem Nat.shiftLeft_eq : ∀ (a b : ℕ), a <<< b = a * 2 ^ b := by sorry

This theorem states that for all natural numbers 'a' and 'b', the operation of shifting 'a' to the left by 'b' places is equivalent to multiplying 'a' by 2 to the power of 'b'. In other words, in the domain of natural numbers, the left shift operation is the same as multiplication by a power of 2.

For all natural numbers a and b, shifting a left by b places is equivalent to multiplying a by 2 raised to the power of b.


theorem div_eq_iff : ∀ {G₀ : Type u_3} [inst : GroupWithZero G₀] {a b c : G₀}, b ≠ 0 → (a / b = c ↔ a = c * b) := by
  sorry

This theorem states that for any group with zero of a certain type `G₀`, if `b` is not zero, then `a` divided by `b` equals `c` if and only if `a` equals `c` times `b`. This essentially captures the relationship between division and multiplication in the context of a group with zero.

For any group `G` with zero `G₀`, and elements `a`, `b` (with `b ≠ G₀`), `a / b = c` if and only if `a = c * b`.


theorem Pi.neg_apply :
    ∀ {I : Type u} {f : I → Type v₁} (x : (i : I) → f i) (i : I) [inst : (i : I) → Neg (f i)], (-x) i = -x i := by sorry

This theorem, `Pi.neg_apply`, states that for any type `I` and any function `f : I → Type v₁`, given a dependent function `x : (i : I) → f i` and an index `i : I`, if every `f i` has a negation operation, then applying the negation to the function `x` at index `i` is the same as the negation of the value of the function `x` at index `i`. In other words, negating the function before applying it gives the same result as applying it first and then negating the outcome.

For any type `I` and function `f : I → Type v₁`, if `i : I` is an index such that each `f i` has a negation operation, then `neg (x i) = neg (f i x i)`.


theorem List.length_zipWith :
    ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} (f : α → β → γ) (l₁ : List α) (l₂ : List β),
      List.length (List.zipWith f l₁ l₂) = min (List.length l₁) (List.length l₂) :=
  by sorry

The theorem `List.length_zipWith` states that for any types `α`, `β`, and `γ`, and any function `f` from `α` and `β` to `γ`, the length of the list obtained by applying `f` element-wise to two lists `l₁` and `l₂` (using `List.zipWith`) is equal to the minimum of the lengths of `l₁` and `l₂`. In other words, if you have two lists and you combine them element-wise using some function, the length of the resulting list will be as long as the shorter of the two input lists.

For any types `α`, `β`, and `γ`, and functions `f : α -> β -> γ` and lists `l₁ : List α` and `l₂ : List β` of equal lengths, the length of `List.zipWith f l₁ l₂` is min(length l₁, length l₂).


theorem Polynomial.ne_zero_of_degree_gt :
    ∀ {R : Type u} [inst : Semiring R] {p : Polynomial R} {n : WithBot ℕ}, n < Polynomial.degree p → p ≠ 0 := by sorry

This theorem states that for any type `R` with a semiring structure and any polynomial `p` of type `R`, if there is a value `n` of type "WithBot ℕ" which is less than the degree of the polynomial `p`, then the polynomial `p` cannot be zero. In simpler terms, if a polynomial has a degree greater than a certain number `n`, then that polynomial cannot be the zero polynomial. Here, "WithBot ℕ" is a type that adds a 'bottom' element, typically denoted as `⊥`, to the natural numbers, and the degree of the zero polynomial is defined as this `⊥` value.

For any semiring `R` and polynomial `p` of degree greater than the smallest natural number `n` in `R`, `p` is not the zero polynomial.


theorem ZMod.val_lt : ∀ {n : ℕ} [inst : NeZero n] (a : ZMod n), ZMod.val a < n := by sorry

This theorem, `ZMod.val_lt`, states that for every natural number `n` that is not zero, and for any integer `a` modulo `n` (`a : ZMod n`), the value of `a` (`ZMod.val a`) is strictly less than `n`. The value of `a` is defined as the least natural number in its equivalence class in modulo `n` arithmetic. In other words, if you have a non-zero natural number `n` and take any integer modulo `n`, the natural number value of that integer will always be less than `n`.

For all natural numbers $n \neq 0$ and integers $a$ modulo $n$, the value of $a$ in modulo $n$ arithmetic is strictly less than $n$. Or, in Lean notation, `(∀ (n : ℕ) (a : ZMod n) (h : 0 < n), n < ZMod.val a)`.


theorem Nat.descFactorial_zero : ∀ (n : ℕ), Nat.descFactorial n 0 = 1 := by sorry

The theorem `Nat.descFactorial_zero` asserts that for any natural number `n`, the descending factorial `Nat.descFactorial n 0` is equal to `1`. This is equivalent to the mathematical statement that $n^{\underline{0}}=1$, where $n^{\underline{0}}$ denotes the descending factorial. This is consistent with the general pattern in factorials that anything to the power of zero is one.

For any natural number $n$, the descending factorial $n^{\underline{0}}$ equals 1.


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

This theorem, `lt_of_le_not_le`, states that for any type `α` with a preorder structure, given any two elements `a` and `b` of type `α`, if `a` is less than or equal to `b` and it is not the case that `b` is less than or equal to `a`, then `a` is strictly less than `b`. In other words, if `a` is not greater than or equal to `b` but is still not greater than `b`, then `a` must be less than `b`. This theorem provides a way of concluding strict inequality in a preordered set given partial order information.

If `a` is related to `b` by a preorder and not reversely related, then `a` is strictly smaller than `b`.


theorem DirectSum.toAddMonoid_of :
    ∀ {ι : Type v} [dec_ι : DecidableEq ι] {β : ι → Type w} [inst : (i : ι) → AddCommMonoid (β i)] {γ : Type u₁}
      [inst_1 : AddCommMonoid γ] (φ : (i : ι) → β i →+ γ) (i : ι) (x : β i),
      (DirectSum.toAddMonoid φ) ((DirectSum.of β i) x) = (φ i) x :=
  by sorry

The theorem `DirectSum.toAddMonoid_of` states that for any type `ι` with decidable equality, a family of types `β` indexed by `ι` each equipped with an additive commutative monoid structure, another type `γ` with an additive commutative monoid structure, a family `φ` of homomorphisms from `β i` to `γ` for each `i` in `ι`, and any element `x` of type `β i` for some `i`, applying the natural homomorphism from the direct sum over `ι` of `β i` to `γ` (given by `DirectSum.toAddMonoid φ`) to the result of including `x` in the direct sum (given by `DirectSum.of β i x`) is the same as directly applying the homomorphism `φ i` to `x`.

In other words, when we include an element into a direct sum and then map it with the homomorphism built from the direct sum, it is the same as if we directly map the element with the corresponding homomorphism.

For any type with decidable equality, a family of additive commutative monoids indexed by the type, another additive commutative monoid, a family of homomorphisms between each pair, and an element from one monoid, the homomorphism built from the direct sum applied to the element is equivalent to directly applying the homomorphism to the element.


theorem geom_sum_mul :
    ∀ {α : Type u} [inst : Ring α] (x : α) (n : ℕ),
      (Finset.sum (Finset.range n) fun i => x ^ i) * (x - 1) = x ^ n - 1 :=
  by sorry

The theorem `geom_sum_mul` states that for any ring `α` and element `x` of `α` and any natural number `n`, the sum of the `nth` powers of `x`, as `n` ranges over the natural numbers less than `n`, multiplied by `(x - 1)`, is equal to `x` raised to the power `n` minus `1`. In mathematical terms, it's expressing the formula for the sum of a geometric series: \(\sum_{i=0}^{n-1} x^i \cdot (x - 1) = x^n - 1\).

For any ring `α` and element `x` in `α`, the sum of the `n-1` powers of `x` multiplied by `(x-1)` is equal to `x^n - 1`, where `n` is a natural number.


theorem Set.union_subset_union_right : ∀ {α : Type u} (s : Set α) {t₁ t₂ : Set α}, t₁ ⊆ t₂ → s ∪ t₁ ⊆ s ∪ t₂ := by sorry

The theorem `Set.union_subset_union_right` states that for any type `α` and any set `s` of type `α`, if set `t₁` is a subset of set `t₂`, then the union of `s` and `t₁` is also a subset of the union of `s` and `t₂`. In other words, if we have a third set `t₁` that is a subset of another set `t₂`, increasing the set `s` by adding `t₁` won't make it larger than what we would get if we added `t₂` instead. This is a formalization of a basic principle of set theory.

For any sets `s` and `t₁` such that `t₁` is a subset of `t₂`, we have `s ∪ t₁ ⊆ s ∪ t₂`.


theorem Finset.prod_eq_zero :
    ∀ {α : Type u_3} {β : Type u_4} {s : Finset α} {a : α} {f : α → β} [inst : CommMonoidWithZero β],
      a ∈ s → f a = 0 → (Finset.prod s fun x => f x) = 0 :=
  by sorry

The theorem `Finset.prod_eq_zero` states that for any types `α` and `β`, a finite set `s` of type `α`, an element `a` of type `α`, and a function `f` mapping elements from `α` to `β`, given the condition that `β` is a commutative monoid with zero, if `a` is an element of `s` and `f(a)` equals zero, then the product of `f(x)` for all `x` in the set `s`, denoted as `∏ x in s, f x`, is zero. This theorem captures the idea that if you multiply a set of numbers and one of those numbers is zero, then the whole product becomes zero.

If `β` is a commutative monoid with zero, then for any finite set `s` of type `α`, element `a` of type `α`, and function `f` from `α` to `β` with `a` in `s` and `f(a)` equal to zero, it follows that `∏ x in s, f x` equals zero.


theorem Nat.choose_pos : ∀ {n k : ℕ}, k ≤ n → 0 < Nat.choose n k := by sorry

This theorem, `Nat.choose_pos`, states that for all natural numbers `n` and `k`, if `k` is less than or equal to `n`, then the value of the binomial coefficient `Nat.choose n k` (the number of ways to choose `k` elements from a set of `n` elements) is greater than zero. In other words, if we have a set of `n` elements and we want to choose `k` elements from it, there is at least one way to do this as long as `k` is less than or equal to `n`.

For all natural numbers n and k with k ≤ n, Nat.choose n k is a positive natural number.


theorem Submodule.top_smul :
    ∀ {R : Type u} {M : Type v} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
      (N : Submodule R M), ⊤ • N = N :=
  by sorry

This theorem, `Submodule.top_smul`, states that for any type `R` and `M` where `R` is a commutative semiring, `M` is an additive commutative monoid, and `M` is a module over `R`, the scalar multiplication (denoted by `•`) of a submodule `N` of `M` by the top element (denoted by `⊤`) of `R` is equal to the submodule `N` itself. In simpler terms, it says that multiplying any submodule by the top element of the semiring does not change the submodule.

For any commutative semiring `R`, additive commutative monoid `M` making `M` an `R`-module, and submodule `N` of `M`, `N • ⊤ = N`.


theorem TensorProduct.add_tmul :
    ∀ {R : Type u_1} [inst : CommSemiring R] {M : Type u_4} {N : Type u_5} [inst_1 : AddCommMonoid M]
      [inst_2 : AddCommMonoid N] [inst_3 : Module R M] [inst_4 : Module R N] (m₁ m₂ : M) (n : N),
      (m₁ + m₂) ⊗ₜ[R] n = m₁ ⊗ₜ[R] n + m₂ ⊗ₜ[R] n :=
  by sorry

This theorem states that for any commutative semiring `R`, and any types `M` and `N` that are both commutative monoids and `R`-modules, the tensor product of the sum of two elements `m₁` and `m₂` from `M` and an element `n` from `N` is equal to the sum of the tensor product of `m₁` and `n` and the tensor product of `m₂` and `n`. In mathematical terms, this can be written as $(m₁ + m₂) \otimes n = m₁ \otimes n + m₂ \otimes n$. This theorem shows that the tensor product operation respects the addition operation from the module structure.

For any commutative semiring `R`, and `R`-modules `M` and `N` as commutative monoids, $(m\_1 + m\_2) \otimes n = m\_1 \otimes n + m\_2 \otimes n$ holds for all `m_1, m_2 ∈ M` and `n ∈ N`.


LinearIndependent.injective

theorem LinearIndependent.injective :
    ∀ {ι : Type u'} {R : Type u_2} {M : Type u_4} {v : ι → M} [inst : Ring R] [inst_1 : AddCommGroup M]
      [inst_2 : Module R M] [inst_3 : Nontrivial R], LinearIndependent R v → Function.Injective v :=
  by sorry

The theorem `LinearIndependent.injective` states that for any type 'ι', ring 'R', and additive commutative group 'M', if the function 'v : ι → M' is linearly independent over 'R', then 'v' is injective. Here, a function is said to be injective if for any two elements 'a₁' and 'a₂' from the domain, if 'v(a₁) = v(a₂)' then 'a₁ = a₂'. Similarly, a family of vectors is said to be linearly independent if no vector can be represented as a linear combination of the others. The theorem assumes that 'R' is nontrivial, meaning it has at least two distinct elements.

If 'v' is a function from a type 'ι' to an additive commutative group 'M' over a nontrivial ring 'R', and 'v' is linearly independent over 'R', then 'v' is injective.


theorem Equiv.forall_congr :
    ∀ {α : Sort u} {β : Sort v} {p : α → Prop} {q : β → Prop} (f : α ≃ β),
      (∀ {x : α}, p x ↔ q (f x)) → ((∀ (x : α), p x) ↔ ∀ (y : β), q y) :=
  by sorry

This theorem, `Equiv.forall_congr`, states that for any types `α` and `β`, and any propositions `p` applicable to elements of `α` and `q` applicable to elements of `β`, given a bijective mapping `f` from `α` to `β`, if for all elements `x` of `α`, `p` holds for `x` if and only if `q` holds for `f(x)`, then the proposition `p` holds for all elements of `α` if and only if the proposition `q` holds for all elements of `β`. In other words, we can transport a universal condition across a bijective (equivalent) mapping between sets.

Given a bijective function `f` between types `α` and `β`, if `p(x) ↔ q(f x)` for all `x` in `α`, then `∀x ∈ α, p x ↔ ∀x ∈ β, q x`.


theorem Algebra.mem_top :
    ∀ {R : Type u} {A : Type v} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A] {x : A}, x ∈ ⊤ :=
  by sorry

This theorem states that, for any given types `R` and `A`, with `R` being a commutative semiring, `A` being a semiring, and `A` being an algebra over `R`, any element `x` of type `A` is an element of the top element (denoted by `⊤`). This indicates that every element `x` in `A` is included in the biggest possible subset of `A` given the algebraic structure.

For any commutative semiring R and semiring A being an algebra over R, every element x in A is contained in the top element ⊤ of A.


ContDiff.continuous

theorem ContDiff.continuous :
    ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {E : Type uE} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {F : Type uF} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {f : E → F}
      {n : ℕ∞}, ContDiff 𝕜 n f → Continuous f :=
  by sorry

This theorem states that for any nontrivially normed field 𝕜 and normed additive commutative groups E and F that are also normed spaces over 𝕜, if a function `f` from E to F is continuously differentiable up to any order `n`, then `f` is also a continuous function.

A continuously differentiable up to any order function between two normed spaces over a nontrivially normed field is continuous.


theorem Polynomial.splits_id_iff_splits :
    ∀ {K : Type v} {L : Type w} [inst : CommRing K] [inst_1 : Field L] (i : K →+* L) {f : Polynomial K},
      Polynomial.Splits (RingHom.id L) (Polynomial.map i f) ↔ Polynomial.Splits i f :=
  by sorry

This theorem states that for all types `K` and `L`, where `K` is a commutative ring and `L` is a field, and for every ring homomorphism `i` from `K` to `L`, and for any polynomial `f` in `K`, the polynomial `f` splits over `L` when mapped by `i` and then considered under the identity ring homomorphism on `L` if and only if the polynomial `f` splits over `L` under the ring homomorphism `i`. In other words, the splitting of the polynomial as it is mapped to `L` is independent of whether we then consider it under the identity map on `L`.

In mathematical terms, a polynomial `f` "splits" if it is either the zero polynomial, or all of its irreducible factors have degree 1. This theorem is about the equivalence of split conditions between the original polynomial and its version after ring homomorphism.

For any commutative ring `K`, field `L`, ring homomorphism `i` from `K` to `L`, and polynomial `f` in `K`, the polynomial `f` splits over `L` under `i` if and only if it splits over `L` after applying `i` and the identity homomorphism on `L`.


/-- An isometry preserves the diameter in pseudometric spaces.  -/
theorem Isometry.diam_image :
    ∀ {α : Type u} {β : Type v} [inst : PseudoMetricSpace α] [inst_1 : PseudoMetricSpace β] {f : α → β},
      Isometry f → ∀ (s : Set α), Metric.diam (f '' s) = Metric.diam s :=
  by sorry

This theorem states that an isometry preserves the diameter in pseudometric spaces. More precisely, for any two types `α` and `β` that are pseudometric spaces, for any function `f` from `α` to `β` that is an isometry, and for any set `s` of type `α`, the diameter of the image set under the function `f` is equal to the diameter of the original set `s`. In mathematical terms, if `diam` denotes the diameter of a set in a pseudometric space, `f` is an isometry, and `s` is a set in the space, then `diam(f(s)) = diam(s)`.

In pseudometric spaces, an isometry preserves the diameter of sets, i.e., the diameter of the image of a set under an isometry equals the diameter of the original set.


theorem GaloisCoinsertion.u_inf_l :
    ∀ {α : Type u} {β : Type v} {l : α → β} {u : β → α} [inst : SemilatticeInf α] [inst_1 : SemilatticeInf β],
      GaloisCoinsertion l u → ∀ (a b : α), u (l a ⊓ l b) = a ⊓ b :=
  by sorry

This theorem, `GaloisCoinsertion.u_inf_l`, states that for any two types `α` and `β`, a function `l` from `α` to `β`, a function `u` from `β` to `α`, and given that `α` and `β` are both semilattice inf (i.e., they have an infimum operation), if `l` and `u` form a Galois coinsertion, then for any two elements `a` and `b` of type `α`, the infimum of `l a` and `l b` after applying `u` is equal to the infimum of `a` and `b`. In mathematical terms, this says that for all `a, b` in `α`, `u(l(a) ⊓ l(b)) = a ⊓ b` where `⊓` is the infimum operation.

For any semilattices α and β, and Galois coinsertion functions l: α -> β and u: β -> α, the infimum of l(a) and l(b) under u is equal to the infimum of a and b in α. (That is, u(l(a) ∧ l(b)) = a ∧ b.)


theorem iSup_bool_eq : ∀ {α : Type u_1} [inst : CompleteLattice α] {f : Bool → α}, ⨆ b, f b = f true ⊔ f false := by
  sorry

This theorem states that for any type `α` which forms a complete lattice, and for a function `f` from booleans to `α`, the supremum (or least upper bound) of `f` over all booleans equals the join (or supremum) of `f(true)` and `f(false)`. In simpler terms, when `f` is applied to all possible boolean values, the greatest value it produces is the same as the greater of the values it produces when applied to `true` and `false`.

For any complete lattice `α` and boolean-valued function `f` on `α`, the supremum of `f` over all booleans equals the join of `f(true)` and `f(false)`.


/-- A collection of equivalent definitions of `x ⤳ y`. The public API is given by `iff` lemmas
below.  -/
theorem specializes_TFAE :
    ∀ {X : Type u_1} [inst : TopologicalSpace X] (x y : X),
      List.TFAE
        [x ⤳ y, pure x ≤ nhds y, ∀ (s : Set X), IsOpen s → y ∈ s → x ∈ s, ∀ (s : Set X), IsClosed s → x ∈ s → y ∈ s,
          y ∈ closure {x}, closure {y} ⊆ closure {x}, ClusterPt y (pure x)] :=
  by sorry

This theorem provides a collection of equivalent definitions for the relation "x specializes to y" (denoted `x ⤳ y`) in a topological space `X`. Specifically, the following properties are equivalent:

1. `x` specializes to `y` (`x ⤳ y`).
2. The filter generated by the single point set `{x}` is less than or equal to the neighborhood filter at `y` (`pure x ≤ nhds y`).
3. For any open set `s` that contains `y`, `x` is also in `s` (`∀ (s : Set X), IsOpen s → y ∈ s → x ∈ s`).
4. For any closed set `s` that contains `x`, `y` is also in `s` (`∀ (s : Set X), IsClosed s → x ∈ s → y ∈ s`).
5. `y` is in the closure of the set `{x}` (`y ∈ closure {x}`).
6. The closure of the set `{y}` is a subset of the closure of the set `{x}` (`closure {y} ⊆ closure {x}`).
7. `y` is a cluster point of the filter generated by the single point `{x}` (`ClusterPt y (pure x)`).

In other words, these seven conditions are equivalent ways of saying that `x` specializes to `y`.

In a topological space, the following seven conditions are equivalent: `x ⤳ y` if and only if (i) `pure x ≤ nhds y`, (ii) `x ∈ s` for all open sets `s` containing `y`, (iii) `y ∈ s` for all closed sets `s` containing `x`, (iv) `y ∈ closure {x}`, (v) `closure {y} ⊆ closure {x}`, (vi) `ClusterPt y (pure x)`, where `x ⤳ y` denotes the relation "`x` specializes to `y`".


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

This theorem states that for any type `X` equipped with a topology (i.e., `X` is a topological space), the empty set is a closed set. In mathematical terms, this is the assertion that in any topological space, the empty set is always considered closed, which is a fundamental property in topology.

In any topological space, the empty set is a closed set.


theorem IsGLB.lowerBounds_eq :
    ∀ {α : Type u} [inst : Preorder α] {s : Set α} {a : α}, IsGLB s a → lowerBounds s = Set.Iic a := by sorry

The theorem `IsGLB.lowerBounds_eq` states that for any set `s` of a certain type `α`, under a preorder relation, and any element `a` of type `α`, if `a` is the greatest lower bound of `s`, then the set of lower bounds of `s` is equal to the left-infinite right-closed interval up to `a`. In other words, all elements that are less than or equal to `a` form the set of lower bounds of `s` when `a` is the greatest lower bound of `s`.

If `a` is the greatest lower bound of a set `s`, then the set of lower bounds of `s` equals the set of all elements less than or equal to `a`.


theorem Submodule.fg_top :
    ∀ {R : Type u_1} {M : Type u_2} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
      (N : Submodule R M), Submodule.FG ⊤ ↔ Submodule.FG N :=
  by sorry

This theorem states that for any semiring `R`, any additive commutative monoid `M`, and any `R`-module structure on `M`, if `N` is a submodule of `M`, then the top submodule `⊤` is finitely generated if and only if `N` is finitely generated. Here, a submodule is said to be finitely generated if it can be expressed as the span of a finite subset of `M`. The span of a set of vectors is the smallest submodule that contains the set.

For any semiring `R`, additive commutative monoid `M` with an `R`-module structure, and submodule `N` of `M`, `⊤` is finitely generated if and only if `N` is.


theorem GaloisCoinsertion.strictMono_l :
    ∀ {α : Type u} {β : Type v} {l : α → β} {u : β → α} [inst : Preorder α] [inst_1 : Preorder β],
      GaloisCoinsertion l u → StrictMono l :=
  by sorry

The theorem `GaloisCoinsertion.strictMono_l` states that for any two types `α` and `β`, given two functions `l : α → β` and `u : β → α`, and provided that both `α` and `β` have a preorder relation, if there exists a Galois coinsertion between `l` and `u`, then the function `l` is strictly monotone. In other words, if `a < b` for any `a, b ∈ α`, then `l(a) < l(b)`.

If types `α` and `β` have preorders, and there exists a Galois coinsertion between functions `l : α → β` and `u : β → α`, then `l` is a strictly increasing function.


theorem Finset.sup_empty :
    ∀ {α : Type u_2} {β : Type u_3} [inst : SemilatticeSup α] [inst_1 : OrderBot α] {f : β → α}, Finset.sup ∅ f = ⊥ :=
  by sorry

This theorem, `Finset.sup_empty`, states that for any types `α` and `β`, given a semilattice (a partially ordered set with a supremum operation) and a least element (`OrderBot`) on `α`, and any function `f` from `β` to `α`, then the supremum of `f` over an empty set is the least element of `α`. In more mathematical terms, this is saying that the supremum of an empty set under any function is the bottom element of the semilattice.

For any semilattice with least element and function from a type to it, the supremum of the empty set under that function equals the least element.


theorem ENNReal.ofReal_add :
    ∀ {p q : ℝ}, 0 ≤ p → 0 ≤ q → ENNReal.ofReal (p + q) = ENNReal.ofReal p + ENNReal.ofReal q := by sorry

This theorem states that for any two real numbers `p` and `q` that are nonnegative (i.e., greater than or equal to 0), the function `ENNReal.ofReal` applied to the sum of `p` and `q` is equal to the sum of the function `ENNReal.ofReal` applied to `p` and `q` separately. In other words, for nonnegative real numbers, the `ENNReal.ofReal` function distributes over addition.

For all non-negative real numbers `p` and `q`, `ENNReal.ofReal (p + q) = ENNReal.ofReal p + ENNReal.ofReal q`.


theorem mul_max_of_nonneg :
    ∀ {α : Type u} [inst : LinearOrderedSemiring α] {a : α} (b c : α), 0 ≤ a → a * max b c = max (a * b) (a * c) := by
  sorry

This theorem, named `mul_max_of_nonneg`, states that for any type `α` that has a structure of `LinearOrderedSemiring`, and for any nonnegative element `a` of this type, the product of `a` and the maximum of two elements `b` and `c` is equal to the maximum of the product of `a` and `b` and the product of `a` and `c`. In other words, if `a` is nonnegative, multiplication by `a` preserves the maximum operation. This is expressed in the language of the Lean 4 theorem prover.

For any non-negative element `a` in a LinearOrderedSemiring `α`, and elements `b`, `c` in `α`, we have `a * (max b c) = max (a * b) (a * c)`.


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

This theorem, `div_le_one`, states that for any type `α` that is a Linear Ordered Semifield, and for any two elements `a` and `b` of that type, if `b` is greater than 0, then the condition of `a` divided by `b` being less than or equal to 1 is equivalent to `a` being less than or equal to `b`. In mathematical notation, this can be written as: if $0 < b$, then $\frac{a}{b} \leq 1$ if and only if $a \leq b$.

For any Linear Ordered Semifield type `α` and elements `a`, `b` of type `α` with `0 < b`, the condition `a / b <= 1` is equivalent to `a <= b`.


theorem CategoryTheory.SimplicialObject.hom_ext :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : CategoryTheory.SimplicialObject C} (f g : X ⟶ Y),
      (∀ (n : SimplexCategoryᵒᵖ), f.app n = g.app n) → f = g :=
  by sorry

This theorem states that for any category `C` and for any two simplicial objects `X` and `Y` in category `C`, if two morphisms `f` and `g` from `X` to `Y` are such that their respective applications to any object `n` in the opposite of the SimplexCategory (denoted `SimplexCategoryᵒᵖ`) are equal, then the two morphisms `f` and `g` themselves are equal. In other words, it establishes the principle of extensionality for morphisms in the category of simplicial objects.

If two morphisms between simplicial objects in a category have equal applications to all simplices in the opposite SimplexCategory, then they are equal.


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

The theorem `CategoryTheory.Limits.limit.conePointUniqueUpToIso_inv_comp` states that in category theory, for any category `J`, another category `C`, a functor `F` from `J` to `C`, given `F` has a limit and `c` is a limit cone of `F`, the composition of the inverse of the isomorphism between the limit cone and `c` and the projection from the limit object of `F` to a value `j` of `J` is equal to the morphism from `c` to `j`. This essentially captures the uniqueness property of limit cones in a category up to isomorphism.

In category theory, given a limit cone `c` of a functor `F` from a category `J` to `C` with limit, the composition of the inverse of the limit cone's isomorphism with the projection from the limit object to an object `j` in `J` is equal to the morphism from `c` to `j`.


theorem summable_geometric_of_lt_one : ∀ {r : ℝ}, 0 ≤ r → r < 1 → Summable fun n => r ^ n := by sorry

The theorem `summable_geometric_of_lt_one` states that for any real number `r` that is non-negative (`0 ≤ r`) and less than one (`r < 1`), the function mapping any natural number `n` to `r` raised to the power of `n` (`r ^ n`) is summable. In other words, the infinite geometric series $\sum_{n=0}^{\infty} r^n$ converges to a finite sum when the common ratio `r` is a real number in the interval [0, 1).

For any non-negative real number `r` with `r < 1`, the infinite geometric series $\sum_{n=0}^{\infty} r^n$ converges to a finite sum.


theorem Primrec.nat_iff : ∀ {f : ℕ → ℕ}, Primrec f ↔ Nat.Primrec f := by sorry

The theorem `Primrec.nat_iff` states that for any function `f` from natural numbers to natural numbers, `f` is primitive recursive (i.e., `Primrec f`) if and only if `f` is primitive recursive as per the native definition in Lean (`Nat.Primrec f`). In other words, if `f` is primitive recursive, then it remains so when we consider its input and output as encoded natural numbers. And if `f` is primitive recursive on natural numbers, then it is also primitive recursive when we consider the encoding scheme.

The theorem `Primrec.nat_iff` asserts that a function from natural numbers to natural numbers is primitive recursive in Lean if and only if it is primitive recursive according to the standard definition.


Continuous.fst

/-- Postcomposing `f` with `Prod.fst` is continuous  -/
theorem Continuous.fst :
    ∀ {X : Type u} {Y : Type v} {Z : Type u_1} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y]
      [inst_2 : TopologicalSpace Z] {f : X → Y × Z}, Continuous f → Continuous fun x => (f x).1 :=
  by sorry

This theorem states that for any three types `X`, `Y`, `Z` that are equipped with topological structures, if we have a continuous function `f` from `X` to the cartesian product of `Y` and `Z` (`Y × Z`), then the function obtained by composing `f` with the `Prod.fst` function (which extracts the first component of a pair) is also continuous. In mathematical terms, the theorem says that if `f : X → Y × Z` is a continuous function, then the function `x ↦ (f(x)).1` is continuous.

If `f : X → Y × Z` is a continuous function, then the function `x ↦ (f(x)).1` extracting the first component from the product is also continuous.


/-- Note that the `IsScalarTower M α α` and `SMulCommClass M α α` typeclass arguments are
usually satisfied by `Algebra M α`.  -/
theorem smul_mul_smul :
    ∀ {M : Type u_1} {α : Type u_6} [inst : Monoid M] [inst_1 : MulAction M α] [inst_2 : Mul α] (r s : M) (x y : α)
      [inst_3 : IsScalarTower M α α] [inst_4 : SMulCommClass M α α], r • x * s • y = (r * s) • (x * y) :=
  by sorry

This theorem, `smul_mul_smul`, states that for any types `M` and `α`, where `M` is a monoid and `α` has both a multiplication action by `M` and a multiplication operation, and for any elements `r` and `s` in `M` and `x` and `y` in `α`, the scalar multiplication of `r` and `x` times the scalar multiplication of `s` and `y` equals the scalar multiplication of `r * s` and `x * y`. This holds when the scalar multiplication is compatible with the multiplication in `α` (i.e., `α` is a scalar tower over `M`) and the scalar multiplication by `M` commutes with the multiplication in `α`. Note that these conditions are usually satisfied when `M` is an algebra over `α`.

For any monoid `M` acting on a type `α` with compatible scalar multiplications and commuting multiplications, the scalar multiplication of an element `r` in `M` with an element `x` in `α`, and the scalar multiplication of an element `s` in `M` with an element `y` in `α`, are equal to the scalar multiplication of their product `r * s` in `M` with the product of `x` and `y` in `α`.


/-- Two linearly equivalent vector spaces have the same dimension, a version with different
universes.  -/
theorem LinearEquiv.lift_rank_eq :
    ∀ {R : Type u} {M : Type v} {M' : Type v'} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : AddCommGroup M']
      [inst_3 : Module R M] [inst_4 : Module R M'],
      (M ≃ₗ[R] M') → Cardinal.lift.{v', v} (Module.rank R M) = Cardinal.lift.{v, v'} (Module.rank R M') :=
  by sorry

This theorem states that if you have two vector spaces, `M` and `M'`, over a ring `R`, that are linearly equivalent (denoted by `M ≃ₗ[R] M'`), then their dimensions are the same, even when the vector spaces exist in different universes. In particular, the dimensions are represented using the cardinality function `Module.rank`, and the universes' dimensions, possibly different, are equalized through the use of the `Cardinal.lift` function.

If two vector spaces over a ring are linearly equivalent, then they have equal dimensions.


theorem CategoryTheory.Limits.zero_of_epi_comp :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
      {X Y Z : C} (f : X ⟶ Y) {g : Y ⟶ Z} [inst_2 : CategoryTheory.Epi f],
      CategoryTheory.CategoryStruct.comp f g = 0 → g = 0 :=
  by sorry

This theorem, `CategoryTheory.Limits.zero_of_epi_comp`, states that for any category `C` with zero morphisms and any objects `X`, `Y`, and `Z` in `C`, if `f` is an epimorphism (surjective morphism) from `X` to `Y` and the composition of `f` and `g` (`f ≫ g`, where `g` is a morphism from `Y` to `Z`) equals the zero morphism, then `g` must be the zero morphism. This essentially means that in a category with zero morphisms, the composition of an epimorphism and another morphism results in the zero morphism if and only if the second morphism is the zero morphism.

In a category with zero morphisms, if an epimorphism's composition with another morphism equals the zero morphism, then the second morphism is the zero morphism.


theorem mul_right_eq_self : ∀ {M : Type u} [inst : LeftCancelMonoid M] {a b : M}, a * b = a ↔ b = 1 := by sorry

The theorem `mul_right_eq_self` states that for any type `M` that is a Left Cancelable Monoid, and for any elements `a` and `b` of that type, the condition `a * b = a` is equivalent to `b = 1`. In the language of algebra, this theorem says that if the multiplication of `a` and `b` equals `a`, then `b` must be the identity element of the monoid, which is `1` in this context.

For any left cancelable monoid M and its elements a and b, a * b = a if and only if b is the identity element 1.


theorem Filter.map_comap_of_surjective :
    ∀ {α : Type u} {β : Type v} {f : α → β},
      Function.Surjective f → ∀ (l : Filter β), Filter.map f (Filter.comap f l) = l :=
  by sorry

The theorem `Filter.map_comap_of_surjective` states that for any types α and β, and any function `f` from α to β, if `f` is a surjective function (i.e., for every element `b` in β, there is some element `a` in α such that `f(a) = b`), then for any filter `l` on β, mapping `l` under `f` after applying the co-domain filter of `f` to `l` is equal to the original filter `l`. In simpler terms, this theorem implies that for a surjective function, the process of mapping the filter after applying the comap operation to the filter results in the original filter.

For any surjective function `f` between types α and β, `filter.map (f)` equals `filter.coe_filter (filter.map (subtype.val f)) (filter.map (subtype.coe) l)` for any filter `l` on β.


theorem Finmap.induction_on₂ :
    ∀ {α : Type u} {β : α → Type v} {C : Finmap β → Finmap β → Prop} (s₁ s₂ : Finmap β),
      (∀ (a₁ a₂ : AList β), C (AList.toFinmap a₁) (AList.toFinmap a₂)) → C s₁ s₂ :=
  by sorry

This theorem states that, for any two finite maps `s₁` and `s₂` of type `Finmap β` indexed by an arbitrary type `α`, if a property `C` holds for any two associative lists `a₁` and `a₂` (of type `AList β`) when converted to `Finmap` using the function `AList.toFinmap`, then the same property `C` also holds for the finite maps `s₁` and `s₂`. Thus, the theorem provides an induction principle for establishing the equality of two finite maps based on their corresponding associative lists.

If property `C` holds for any two associative lists when converted to finite maps, then property `C` holds for any two finite maps `s₁` and `s₂` of type `Finmap β` with corresponding associative lists `a₁` and `a₂`.


theorem CategoryTheory.eqToHom_trans_assoc :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X Y Z : C} (p : X = Y) (q : Y = Z) {Z_1 : C}
      (h : Z ⟶ Z_1),
      CategoryTheory.CategoryStruct.comp (CategoryTheory.eqToHom p)
          (CategoryTheory.CategoryStruct.comp (CategoryTheory.eqToHom q) h) =
        CategoryTheory.CategoryStruct.comp (CategoryTheory.eqToHom ⋯) h :=
  by sorry

This theorem, `CategoryTheory.eqToHom_trans_assoc`, asserts that in any category `C`, given objects `X`, `Y`, `Z` and `Z_1`, and equalities `p : X = Y` and `q : Y = Z`, the composition of the morphism induced by `p` and the composition of the morphism induced by `q` and a morphism `h : Z ⟶ Z_1` is equal to a composition of a morphism and `h`, where the morphism is induced by chaining equalities `p` and `q`. In other words, this theorem demonstrates the associative property of morphism composition with regards to equality-induced morphisms in category theory.

In any category, given equalities `p : X = Y` and `q : Y = Z` between objects, the induced morphisms satisfy `h . (p ∘ q) = (h ∘ p) ∘ q`.


theorem Complex.ofReal_zero : ↑0 = 0 := by sorry

This theorem states that the complex number representation of a real zero is equal to zero. In other words, when you convert the real number zero to a complex number, the result is still zero.

The theorem asserts that the conversion of the real number 0 to a complex number results in the complex number 0.


theorem Mathlib.Order.CompleteLattice._auxLemma.10 :
    ∀ {α : Type u_1} {ι : Sort u_5} [inst : CompleteLattice α] {s : ι → α}, (iInf s = ⊤) = ∀ (i : ι), s i = ⊤ := by
  sorry

The theorem `Mathlib.Order.CompleteLattice._auxLemma.10` states that for any type `α` that has a structure of a complete lattice, and any indexed set `s` with indices from `ι`, the indexed infimum (`iInf`) of `s` is equal to `⊤` (the top element of the lattice) if and only if every element of `s` is equal to `⊤`. In other words, the least upper bound (supremum) of all elements in the set is the top element of the lattice, exactly when all elements in the set are the top element of the lattice.

For any complete lattice (α, ∧, ⊧), the indexed infimum of a set s with indices from ι equals the top element ⊤ if and only if all elements in s are equal to ⊤.


theorem CategoryTheory.Equivalence.functor_unit_comp :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂}
      [inst_1 : CategoryTheory.Category.{v₂, u₂} D] (e : C ≌ D) (X : C),
      CategoryTheory.CategoryStruct.comp (e.functor.map (e.unit.app X)) (e.counit.app (e.functor.obj X)) =
        CategoryTheory.CategoryStruct.id (e.functor.obj X) :=
  by sorry

The theorem `CategoryTheory.Equivalence.functor_unit_comp` states that for any two categories `C` and `D` and an equivalence `e` between them, the composition of the functor's map applied to the unit at `X` and the counit at the functor's object `X` is the identity on the functor's object `X`. In other words, it formalizes one of the triangle identities that are conditions for a functor to be an equivalence of categories: the composition of the unit transformation and the counit transformation is the identity transformation.

Given an equivalence of categories `e : C ≈ D` between categories `C` and `D`, for any object `X` in `C`, the composition of `e.map X (e.unit X)` and `e.counit X` equals the identity on `e.obj X` in `D`.


theorem Mathlib.Algebra.Divisibility.Basic._auxLemma.1 :
    ∀ {α : Type u_1} [inst : Semigroup α] (a b : α), (a ∣ a * b) = True := by sorry

This theorem, titled `Mathlib.Algebra.Divisibility.Basic._auxLemma.1`, states that for any semigroup `α`, and any elements `a` and `b` of this semigroup, `a` always divides the product `a * b`. In the context of semigroups, "divides" means that there is another element in the semigroup such that `a` times this element equals `a * b`. In this case, the theorem is trivially true as the other element can be `b`.

In any semigroup, every element divides the product of itself and any other element.


/-- **Alias** of `lt_of_le_of_ne'`. -/
theorem LE.le.lt_of_ne' : ∀ {α : Type u} [inst : PartialOrder α] {a b : α}, a ≤ b → b ≠ a → a < b := by sorry

This theorem, known as an alias of `lt_of_le_of_ne'`, states that for any type `α` that has a partial order, if `a` and `b` are elements of `α` such that `a` is less than or equal to `b` and `b` is not equal to `a`, then `a` is less than `b`. It's a fundamental result in order theory that helps express the relationship between less-than and less-than-or-equal-to under the condition of non-equality.

If `α` is a partially ordered type and `a` and `b` are elements of `α` with `a ≤ b` and `a ≠ b`, then `a < b`.


theorem Finset.sdiff_singleton_eq_erase :
    ∀ {α : Type u_1} [inst : DecidableEq α] (a : α) (s : Finset α), s \ {a} = Finset.erase s a := by sorry

The theorem `Finset.sdiff_singleton_eq_erase` states that for any given type `α` that has decidable equality (`DecidableEq α`) and for any element `a` of type `α` and set `s` of type `Finset α` (which is a finite set in Lean), the operation of set difference `s \ {a}` (which produces a set containing all elements of `s` except `a`) is the same as the operation `Finset.erase s a` (which also removes the element `a` from the set `s`). In mathematical terms, it asserts that for all `s` and `a`, `s \ {a} = Finset.erase s a`.

For any type `α` with decidable equality and for any `α` element `a` and finite set `s` of type `Finset α`, set difference `s \ {a}` equals `Finset.erase s a`.


theorem Algebra.mem_bot :
    ∀ {R : Type u} {A : Type v} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A] {x : A},
      x ∈ ⊥ ↔ x ∈ Set.range ⇑(algebraMap R A) :=
  by sorry

The theorem `Algebra.mem_bot` states that for any given types `R` and `A`, where `R` is a commutative semiring, `A` is a semiring, and `A` is an `R`-algebra, any element `x` of type `A` is in the zero ideal (denoted by `⊥`) if and only if `x` is in the range of the algebra map from `R` to `A`. In other words, `x` can be expressed as the image of some element from `R` under the algebra map. The algebra map (`algebraMap`) is the ring homomorphism associated with the `Algebra` structure from `R` to `A`. The set range of a function `f` (denoted by `Set.range`) consists of all possible output values `x` for which there exists an input `y` such that `f(y) = x`.

For any commutative semiring R, semiring A, and R-algebra A, an element x of A belongs to the zero ideal if and only if it is the image of some element in R under the algebra map.


theorem Polynomial.monic_X : ∀ {R : Type u} [inst : Semiring R], Polynomial.Monic Polynomial.X := by sorry

This theorem states that the polynomial variable, often referred to as the indeterminate and denoted by `X`, is `Monic` in any semiring `R`. In other words, the leading coefficient of the polynomial `X` is 1. A `Monic` polynomial is defined as a polynomial whose leading coefficient is 1. A semiring is a mathematical structure which is an algebraic structure similar to a ring, but without the requirement that each element must have an additive inverse.

In any semiring, the polynomial in the indeterminate `X` is monic, meaning its leading coefficient equals 1.


IsClosed.union

theorem IsClosed.union :
    ∀ {X : Type u} {s₁ s₂ : Set X} [inst : TopologicalSpace X], IsClosed s₁ → IsClosed s₂ → IsClosed (s₁ ∪ s₂) := by
  sorry

This theorem asserts that for any type `X` with a topology (`TopologicalSpace X`), if `s₁` and `s₂` are closed sets (`IsClosed s₁` and `IsClosed s₂`), then their union `s₁ ∪ s₂` is also a closed set (`IsClosed (s₁ ∪ s₂)`). In mathematical terms, this theorem is stating the common property of topological spaces where the union of two closed sets is again a closed set.

In a topological space, the union of two closed sets is closed.


/-- Evaluation of a continuous map `f` at a point `x` is continuous in `f`.

Porting note: merged `continuous_eval_const` with `continuous_eval_const'` removing unneeded
assumptions.  -/
theorem ContinuousMap.continuous_eval_const :
    ∀ {X : Type u_2} {Y : Type u_3} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] (a : X),
      Continuous fun f => f a :=
  by sorry

The theorem `ContinuousMap.continuous_eval_const` states that for given topological spaces `X` and `Y`, and a point `a` of type `X`, the evaluation of any continuous map `f` from `X` to `Y` at the point `a` is itself a continuous function. In other words, if `f` varies over all continuous functions from `X` to `Y`, then the function which to `f` assigns `f(a)` is continuous. This is a fundamental property used in the study of topological spaces and continuous functions.

For any topological spaces X and Y and continuous map f : X -> Y, the evaluation function x => f x of f at a point a in X is a continuous function.


theorem Finset.filter_mem_eq_inter :
    ∀ {α : Type u_1} [inst : DecidableEq α] {s t : Finset α} [inst_1 : (i : α) → Decidable (i ∈ t)],
      Finset.filter (fun i => i ∈ t) s = s ∩ t :=
  by sorry

This theorem states that for any type `α` with decidable equality, and for any two finite sets `s` and `t` of type `α`, the operation of filtering `s` by the membership predicate for `t` (i.e., selecting all elements of `s` that are also in `t`) is equivalent to the intersection of `s` and `t`. More succinctly, given decidable predicates for equality and set membership in `α`, filtering a finite set `s` to find the elements in another set `t` is the same as finding the intersection of `s` and `t`.

For any type `α` with decidable equality and finite sets `s` and `t` of type `α`, the set of elements in `s` that are also in `t` (obtained by filtering `s` with the membership predicate for `t`) equals the intersection of `s` and `t`.


theorem wbtw_comm :
    ∀ {R : Type u_1} {V : Type u_2} {P : Type u_4} [inst : OrderedRing R] [inst_1 : AddCommGroup V]
      [inst_2 : Module R V] [inst_3 : AddTorsor V P] {x y z : P}, Wbtw R x y z ↔ Wbtw R z y x :=
  by sorry

The theorem `wbtw_comm` states that for any ordered ring `R`, any additive commutative group `V`, any module `V` over `R`, any `V`-torsor `P`, and any three points `x`, `y`, and `z` in `P`, the property that `y` is weakly between `x` and `z` is equivalent to the property that `y` is weakly between `z` and `x`. In other words, the "weakly between" relation is symmetric: if `y` is on the line segment from `x` to `z` (inclusive), then `y` is also on the line segment from `z` to `x`.

For any ordered ring `R`, additive commutative group `V` with a `R`-module structure, and `V`-torsor `P`, the relation "`y` is weakly between `x` and `z` in `P`" is equivalent to "`y` is weakly between `z` and `x` in `P`".