theorem TopCat.epi_iff_surjective : ∀ {X Y : TopCat} (f : X ⟶ Y), CategoryTheory.Epi f ↔ Function.Surjective ⇑f := by
  sorry

This theorem establishes a correspondence between two concepts in different areas of mathematics: category theory and set theory. For any two objects `X` and `Y` in the category of topological spaces `TopCat` and any morphism `f` from `X` to `Y`, the theorem states that `f` is an epimorphism in the categorical sense if and only if the underlying function of `f` is surjective. In other words, a continuous map between topological spaces is categorically "onto" (epimorphic) if and only if every point in the target space is the image of some point in the source space under the map (surjective).

In the category of topological spaces, a continuous map is an epimorphism if and only if its underlying function is surjective.


/-- If a `Finset` is a subset of the image of two `Set`s under a binary operation,
then it is a subset of the `Finset.image₂` of two `Finset` subsets of these `Set`s.  -/
theorem Finset.subset_image₂ :
    ∀ {α : Type u_1} {β : Type u_3} {γ : Type u_5} [inst : DecidableEq γ] {f : α → β → γ} {u : Finset γ} {s : Set α}
      {t : Set β}, ↑u ⊆ Set.image2 f s t → ∃ s' t', ↑s' ⊆ s ∧ ↑t' ⊆ t ∧ u ⊆ Finset.image₂ f s' t' :=
  by sorry

This theorem states that for any types `α`, `β`, and `γ` with a decidable equality relation on `γ`, given a binary function `f` from `α` and `β` to `γ`, a `Finset` of `γ` named `u`, and two sets `s` and `t` of types `α` and `β` respectively, if `u` is a subset of the image of `s` and `t` under the function `f`, then there exist `Finset` subsets `s'` and `t'` of `s` and `t` respectively such that `u` is a subset of the image of `s'` and `t'` under the function `f`. In mathematical terms, if $u \subseteq f(s, t)$, then there must exist $s' \subseteq s$ and $t' \subseteq t$ such that $u \subseteq f(s', t')$.

Given types `α`, `β`, and `γ` with decidable equality on `γ`, if `Finset` `u` is a subset of the image of sets `s` of type `α` and `t` of type `β` under a binary function `f` from `α` and `β` to `γ`, then there exist subsets `s'` of `s` and `t'` of `t` such that `u` is a subset of the image of `s'` and `t'` under `f`.


Homeomorph.ext

theorem Homeomorph.ext :
    ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {h h' : X ≃ₜ Y},
      (∀ (x : X), h x = h' x) → h = h' :=
  by sorry

This theorem states that for any two types `X` and `Y`, each with an instance of a topological space, and given two homeomorphisms `h` and `h'` between `X` and `Y`, if for all `x` in `X`, the application of `h` and `h'` to `x` results in the same outcome, then `h` and `h'` are the same homeomorphism. In other words, two homeomorphisms between two topological spaces are identical if they map every point in the source space to the same point in the target space.

Two homeomorphisms between topological spaces are equal if they map each point in the source space to the same point in the target space.


/-- **Alias** of the reverse direction of `Set.infinite_coe_iff`. -/
theorem Set.Infinite.to_subtype : ∀ {α : Type u} {s : Set α}, Set.Infinite s → Infinite ↑s := by sorry

This theorem, referred to as `Set.Infinite.to_subtype`, asserts that for any type `α` and any set `s` of type `α`, if the set `s` is infinite (according to the definition provided in the Lean 4 code), then its corresponding subtype (denoted by `↑s`) is also infinite. Here, `Infinite ↑s` refers to the standard mathematical notion of an infinite set. Essentially, the theorem argues that if a set is not finite in the context of the defined mathematical structure, then its subtype will also be not finite.

If `s` is an infinite set, then the subtype `↑s` is also infinite.


ZeroHom.ext

theorem ZeroHom.ext :
    ∀ {M : Type u_4} {N : Type u_5} [inst : Zero M] [inst_1 : Zero N] ⦃f g : ZeroHom M N⦄,
      (∀ (x : M), f x = g x) → f = g :=
  by sorry

This theorem states that for any two zero homomorphisms `f` and `g` from a type `M` with a zero element to a type `N` also with a zero element, if `f` and `g` have the same value for every `x` in `M`, then `f` is equal to `g`. A zero homomorphism is a function that preserves the zero element, i.e., it maps the zero of `M` to the zero of `N`.

If two zero homomorphisms from a type with a zero element to another type with a zero element agree on all elements, then they are equal.


Function.Antiperiodic.periodic

/-- If a function is `antiperiodic` with antiperiod `c`, then it is also `periodic` with period
`2 • c`.  -/
theorem Function.Antiperiodic.periodic :
    ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {c : α} [inst : AddMonoid α] [inst_1 : InvolutiveNeg β],
      Function.Antiperiodic f c → Function.Periodic f (2 • c) :=
  by sorry

This theorem states that if a function is antiperiodic with an antiperiod `c`, it is also periodic with a period of `2 • c`. In other words, if a function `f` has the property that `f(x + c) = -f(x)` for all `x` (antiperiodic), then it also has the property that `f(x + 2c) = f(x)` for all `x` (periodic). This holds for any function `f` from a type `α` to a type `β`, where `α` is an additive monoid and `β` supports negation operation.

If a function `f` from an additive monoid `α` to a type `β` supporting negation is antiperiodic with antiperiod `c`, then it is periodic with period `2 • c`.


MeasureTheory.SimpleFunc.measurable

/-- A simple function is measurable  -/
theorem MeasureTheory.SimpleFunc.measurable :
    ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] [inst_1 : MeasurableSpace β]
      (f : MeasureTheory.SimpleFunc α β), Measurable ↑f :=
  by sorry

This theorem states that any simple function is measurable. Here, a simple function `f` is a function from a measurable space `α` to another measurable space `β`. A function is considered measurable if the preimage of any measurable set is also a measurable set. In this context, a measurable set is a set for which a measure can be assigned in a meaningful way. Consequently, the theorem confirms that for every simple function `f`, the function `f` is measurable.

Every simple function between two measurable spaces is measurable.


theorem PrimeSpectrum.zeroLocus_vanishingIdeal_eq_closure :
    ∀ {R : Type u} [inst : CommSemiring R] (t : Set (PrimeSpectrum R)),
      PrimeSpectrum.zeroLocus ↑(PrimeSpectrum.vanishingIdeal t) = closure t :=
  by sorry

This theorem states that for any commutative semiring `R` and any set `t` of its prime spectrum, the zero locus of the vanishing ideal of `t` is equal to the closure of `t`. In other words, the set of all points where the functions given by the vanishing ideal of `t` vanish is exactly the closure of `t` itself. Here, the closure of a set is defined as the smallest closed set containing it, and the vanishing ideal of a set in the prime spectrum is the set of all ring elements that vanish on that set.

The zero locus of a set of points in the prime spectrum of a commutative semiring equals the closure of that set, where the zero locus is the set of points where the vanishing ideal vanishes.


Function.Semiconj.eq

theorem Function.Semiconj.eq :
    ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {ga : α → α} {gb : β → β},
      Function.Semiconj f ga gb → ∀ (x : α), f (ga x) = gb (f x) :=
  by sorry

The theorem `Function.Semiconj.eq` states that for all types `α` and `β`, and for all functions `f` from `α` to `β`, `ga` from `α` to `α`, and `gb` from `β` to `β`, if `f` semiconjugates `ga` to `gb` (that is, if the composition `f` after `ga` is equivalent to the composition `gb` after `f`), then for every element `x` of type `α`, the application of `f` to `ga` of `x` is equal to `gb` of `f` of `x`. In mathematical terms, if $f \circ ga = gb \circ f$, then for all $x$ in $\alpha$, $f(ga(x)) = gb(f(x))$.

If functions $f: \alpha \to \beta$, $ga: \alpha \to \alpha$, and $gb: \beta \to \beta$ satisfy $f \circ ga = gb \circ f$, then for all $x \in \alpha$, $f(ga(x)) = gb(f(x))$.


/-- `s.subtype p` converts back to `s.filter p` with
`Embedding.subtype`.  -/
theorem Finset.subtype_map :
    ∀ {α : Type u_1} (p : α → Prop) [inst : DecidablePred p] {s : Finset α},
      Finset.map (Function.Embedding.subtype p) (Finset.subtype p s) = Finset.filter p s :=
  by sorry

The theorem `Finset.subtype_map` states that for any type `α`, a predicate `p` on `α` (where `p` is a decidable predicate), and a `Finset` `s` of `α`, if we first convert `s` into a finset of subtypes that satisfy predicate `p` using `s.subtype p`, and then map it back to type `α` using the subtype embedding `Function.Embedding.subtype p`, we get the same finset as if we had directly filtered `s` with predicate `p` using `Finset.filter p s`. In other words, filtering a finset `s` by a predicate `p` is equivalent to first taking the subtype according to `p`, and then embedding it back to the original type.

For any type `α`, decidable predicate `p` on `α`, and `Finset` `s` of `α`, the map of the subtype `s.subtype p` to `α` through the subtype embedding is equal to the filtering of `s` with the predicate `p`.


theorem Real.log_nonneg : ∀ {x : ℝ}, 1 ≤ x → 0 ≤ Real.log x := by sorry

This is a theorem about the real logarithm function. It states that for all real numbers `x`, if `x` is greater than or equal to 1, then the logarithm of `x` is nonnegative. In other words, the logarithm of any real number that is 1 or more will always be a number that is 0 or greater.

For all real numbers `x` with `x >= 1`, the logarithm of `x` is non-negative. In mathematical notation: `∀x : ℝ, x ≥ 1 → 0 ≤ log x`.


OpenAddSubgroup.isOpen

theorem OpenAddSubgroup.isOpen :
    ∀ {G : Type u_1} [inst : AddGroup G] [inst_1 : TopologicalSpace G] (U : OpenAddSubgroup G), IsOpen ↑U := by sorry

The theorem named `OpenAddSubgroup.isOpen` asserts that for any given additively grouped type `G` (which is also topologically structured), every open additive subgroup `U` of `G` is an open set in the ambient topological space on `G`. Here, open set is defined in the topological sense, which means it is a set where around every point in the set, there exists an open ball that is completely contained in the set. This theorem is an important attribute of open additive subgroups in the context of topological groups.

Every open additive subgroup of a topologically structured additive group is an open set.


theorem Nat.lt_iff_add_one_le : ∀ {m n : ℕ}, m < n ↔ m + 1 ≤ n := by sorry

This theorem, named `Nat.lt_iff_add_one_le`, establishes an equivalence relation for natural numbers `m` and `n`. It states that `m` is less than `n` if and only if `m + 1` is less than or equal to `n`. In other words, the number `m` is considered to be smaller than the number `n` precisely when the successor of `m` (i.e., `m` incremented by 1) is not larger than `n`.

For all natural numbers m and n, m < n if and only if m + 1 <= n.


theorem pow_mod_orderOf : ∀ {G : Type u_1} [inst : Monoid G] (x : G) (n : ℕ), x ^ (n % orderOf x) = x ^ n := by sorry

The theorem `pow_mod_orderOf` states that for any type `G` that has a monoid structure and for any element `x` of `G` and any natural number `n`, the result of raising `x` to the power of `n` modulo the order of `x` is equal to the result of `x` raised to the power of `n`. In mathematical terms, for a given element `x` in a monoid `G` and a natural number `n`, we have \(x^{(n \bmod \text{orderOf}(x))} = x^n\). This implies that the power operation on `x` is periodic with period equal to the order of `x`.

For any element `x` in a monoid `G` with order `n`, raising `x` to the power of `n` modulo the order of `x` equals raising `x` to the power of any integer `k` congruent to `n` modulo the order of `x`.


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

The theorem `isClosed_of_closure_subset` states that for any type `X` and any set `s` of `X`, given a topology on `X`, if the closure of `s` is a subset of `s`, then `s` is a closed set. The closure of a set `s` is the smallest closed set that contains `s`. So, if this closure still fits within `s` itself, it implies that `s` is closed in the given topological space.

If the closure of a set is a subset of the set in a topology, then the set is closed.


theorem Module.finite_def :
    ∀ {R : Type u_6} {M : Type u_7} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M],
      Module.Finite R M ↔ Submodule.FG ⊤ :=
  by sorry

The theorem `Module.finite_def` states that for any semiring `R` and any additive commutative monoid `M` that is also a module over `R`, the module `M` is finite if and only if the top submodule (which includes all elements of `M`) is finitely generated. Here, a module is finite if it's generated by a finite set, and a submodule is finitely generated if it's the span of a finite subset of `M`. In other words, `M` can be expressed as a linear combination of a finite set of elements.

A module over a semiring is finite if and only if its top submodule is finitely generated.


/-- The `nonsing_inv` of `A` is a left inverse.  -/
theorem Matrix.nonsing_inv_mul :
    ∀ {n : Type u'} {α : Type v} [inst : Fintype n] [inst_1 : DecidableEq n] [inst_2 : CommRing α] (A : Matrix n n α),
      IsUnit (Matrix.det A) → A⁻¹ * A = 1 :=
  by sorry

The theorem `Matrix.nonsing_inv_mul` states that for any square matrix `A` of type `Matrix n n α`, where `n` is a finite type with decidable equality, and `α` is a commutative ring, if the determinant of `A` is a unit (i.e., it has a multiplicative inverse), then the non-singular inverse of `A` is its left inverse. In other words, when multiplied from the left by its inverse, `A` yields the identity matrix. This is written mathematically as `A⁻¹ * A = 1`.

If a square matrix `A` of type `Matrix n n α` over a commutative ring `α` with decidable equality and non-zero determinant has an inverse, then `A` and its inverse are multiplicative inverses, i.e., `A * A⁻¹ = 1`.


theorem Set.countable_coe_iff : ∀ {α : Type u} {s : Set α}, Countable ↑s ↔ Set.Countable s := by sorry

The theorem `Set.countable_coe_iff` states that for any type `α` and any set `s` of type `α`, the set `s` is countable (i.e., there exists an injective function from `s` to the natural numbers) if and only if the corresponding subtype of `s` is countable. In other words, countability of a set and its corresponding subtype are equivalent.

For any type `α` and set `s` of type `α`, `s` is countable if and only if its subtype is countable.


/-- A set `s` is not bounded above if and only if for each `x` there exists `y ∈ s` that is greater
than `x`. A version for preorders is called `not_bddAbove_iff'`.  -/
theorem not_bddAbove_iff :
    ∀ {α : Type u_1} [inst : LinearOrder α] {s : Set α}, ¬BddAbove s ↔ ∀ (x : α), ∃ y ∈ s, x < y := by sorry

The theorem `not_bddAbove_iff` states that for any set `s` of a certain type `α` which is equipped with a linear order, `s` is not bounded above if and only if, for every element `x` of type `α`, there exists an element `y` in `s` such that `y` is strictly greater than `x`. In other words, no matter how high you choose `x`, you can always find an element in the set `s` that surpasses it, hence `s` is not bounded above. This version of the theorem is specifically for structures with a linear order.

A set equipped with a linear order is unbounded if and only if for every element x in the set, there exists a y in the set strictly greater than x.


theorem Multiset.count_pos :
    ∀ {α : Type u_1} [inst : DecidableEq α] {a : α} {s : Multiset α}, 0 < Multiset.count a s ↔ a ∈ s := by sorry

The theorem `Multiset.count_pos` states that for any type `α` with decidable equality and for any element `a` of type `α` and multiset `s` of type `α`, the count of `a` in `s` is greater than zero if and only if `a` is an element of `s`. It essentially establishes a connection between the multiplicity of an element in a multiset and its membership in that multiset.

For any type `α` with decidable equality, element `a` of type `α`, and multiset `s` of type `α`, `Multiset.count a s > 0 if and only if a ∈ s`.


theorem nonzero_of_invertible :
    ∀ {α : Type u} [inst : MulZeroOneClass α] (a : α) [inst_1 : Nontrivial α] [inst_2 : Invertible a], a ≠ 0 := by sorry

This theorem states that for any type `α` that has multiplication, zero, and one (i.e., it is a `MulZeroOneClass`), and for any element `a` of that type, if `a` is invertible and `α` is nontrivial (i.e., it contains at least two distinct elements), then `a` cannot be zero. This is a generalization from the field of mathematics where an invertible element in a ring or field is always non-zero.

For any `MulZeroOneClass` type `α` with at least two elements, every invertible element `a` is non-zero.


theorem MeasureTheory.integral_add :
    ∀ {α : Type u_1} {G : Type u_5} [inst : NormedAddCommGroup G] [inst_1 : NormedSpace ℝ G] {m : MeasurableSpace α}
      {μ : MeasureTheory.Measure α} {f g : α → G},
      MeasureTheory.Integrable f μ →
        MeasureTheory.Integrable g μ → ∫ (a : α), f a + g a ∂μ = ∫ (a : α), f a ∂μ + ∫ (a : α), g a ∂μ :=
  by sorry

The theorem `MeasureTheory.integral_add` states that for any measure space `α` and any normed add commutative group `G` together with its normed space over the reals, given a measure `μ` on the space `α` and two functions `f` and `g` from `α` to `G`, if both `f` and `g` are integrable with respect to the measure `μ`, then the integral of the sum of `f` and `g` with respect to `μ` is equal to the sum of the integrals of `f` and `g` with respect to `μ`. In mathematical terms, this can be written as $\int (f(a) + g(a)) d\mu = \int f(a) d\mu + \int g(a) d\mu$ for all `a` in `α` when `f` and `g` are integrable. This is a statement of linearity of the integral in the space of integrable functions.

For any measure space and normed add commutative group, if two integrable functions from the space to the group are given, then their integrals with respect to the measure are equal to the sum of their individual integrals.


theorem Nat.dvd_lcm_left : ∀ (m n : ℕ), m ∣ Nat.lcm m n := by sorry

This theorem states that for all natural numbers `m` and `n`, `m` divides the least common multiple of `m` and `n`. In mathematical terms, for every pair of natural numbers $m, n$, $m$ is a divisor of their least common multiple (LCM).

For all natural numbers m and n, m | LCM(m, n). (Here, "|" represents the divisibility relation.)


theorem iSup_sup_eq :
    ∀ {α : Type u_1} {ι : Sort u_5} [inst : CompleteLattice α] {f g : ι → α}, ⨆ x, f x ⊔ g x = (⨆ x, f x) ⊔ ⨆ x, g x :=
  by sorry

This theorem states that for any type `α` that is a complete lattice, and any two functions `f` and `g` from type `ι` to `α`, the supremum (least upper bound) of the union of the images of `f` and `g` is equal to the union of the suprema of the images of `f` and `g`. In mathematical terms, it is expressing the property: `sup (f(x) ∪ g(x)) = sup (f(x)) ∪ sup (g(x))`.

For any complete lattice `α` and functions `f` and `g` from a type `ι` to `α`, the supremum of the union of their images equals the union of their suprema: `sup (f x ∪ g x) = sup (f x) ∪ sup (g x)`.


List.Sublist.map

theorem List.Sublist.map :
    ∀ {α : Type u} {β : Type v} (f : α → β) {l₁ l₂ : List α},
      List.Sublist l₁ l₂ → List.Sublist (List.map f l₁) (List.map f l₂) :=
  by sorry

The theorem `List.Sublist.map` states that for any two lists `l₁` and `l₂` of type `α` and a function `f` from `α` to `β`, if `l₁` is a sublist of `l₂`, then the list obtained by mapping `f` over `l₁` is a sublist of the list obtained by mapping `f` over `l₂`. In other words, if `l₁` is a sublist of `l₂`, then applying the same function to each element of both lists preserves the sublist relationship.

If `l₁` is a sublist of `l₂`, then `map f l₁` is a sublist of `map f l₂` for any function `f` from `α` to `β`.


theorem EMetric.mem_ball :
    ∀ {α : Type u} [inst : PseudoEMetricSpace α] {x y : α} {ε : ENNReal}, y ∈ EMetric.ball x ε ↔ edist y x < ε := by
  sorry

This theorem states that for any pseudo extended metric space `α`, given any two points `x` and `y` in that space `α` and an extended nonnegative real number `ε`, the point `y` belongs to the `ε`-ball centered at `x` if and only if the extended distance from `y` to `x` is less than `ε`. It is essentially defining what it means for a point to be within a certain "distance" (in this case, an extended distance) from another point in a pseudo extended metric space: it is in the `ε`-ball around that point.

In a pseudo extended metric space, a point belongs to the extended ε-ball around another point if and only if the extended distance between them is less than ε.


theorem Units.ext_iff : ∀ {α : Type u} [inst : Monoid α] {a b : αˣ}, a = b ↔ ↑a = ↑b := by sorry

This theorem, `Units.ext_iff`, states that for any type `α` equipped with a monoid structure, two elements `a` and `b` of the units of `α` (denoted `αˣ`) are equal if and only if their underlying elements in `α` are equal. The units of `α` are elements that have multiplicative inverses, and `↑a` and `↑b` represent the underlying elements of `a` and `b` in `α`, respectively. The theorem shows the equivalence between the equality of the unit elements and the equality of their respective underlying elements.

For any type `α` with a monoid structure and equipped with inverses, two units `a` and `b` are equal if and only if their underlying elements in `α` are equal.


theorem Filter.hasBasis_self :
    ∀ {α : Type u_1} {l : Filter α} {P : Set α → Prop},
      Filter.HasBasis l (fun s => s ∈ l ∧ P s) id ↔ ∀ t ∈ l, ∃ r ∈ l, P r ∧ r ⊆ t :=
  by sorry

This theorem, `Filter.hasBasis_self`, states that for any type `α`, any filter `l` on `α`, and any property `P` of subsets of `α`, the filter `l` has a basis given by the subsets `s` of `α` that are in `l` and satisfy `P`, using the identity function as the index function, if and only if for all subsets `t` in `l`, there exists a subset `r` in `l` that satisfies `P` and is a subset of `t`. In other words, it provides a characterization of a filter having a basis in terms of the existence of certain subsets satisfying a given property within the filter.

A filter on a type has a basis consisting of sets satisfying a given property if and only if every element in the filter contains some other element in the filter that also satisfies the property.


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

This theorem, named `Mathlib.Data.Finset.LocallyFinite.Basic._auxLemma.21`, states that for any type `α` and any two finite sets `s₁` and `s₂` of this type, `s₁` and `s₂` are equal if and only if their coercions to sets (denoted by `↑s₁` and `↑s₂`) are equal. In other words, two finite sets are identical if their underlying sets (ignoring the finiteness property) are identical.

Two finite sets of type `α` are equal if and only if their underlying sets (without the finiteness property) are equal.


theorem AddSubgroup.gc_map_comap :
    ∀ {G : Type u_1} [inst : AddGroup G] {N : Type u_5} [inst_1 : AddGroup N] (f : G →+ N),
      GaloisConnection (AddSubgroup.map f) (AddSubgroup.comap f) :=
  by sorry

The theorem `AddSubgroup.gc_map_comap` establishes a Galois connection between the functions `AddSubgroup.map f` and `AddSubgroup.comap f` for any additively homomorphic function `f` from an additive group `G` to another additive group `N`. In other words, for any additive subgroup `H` of `G` and `K` of `N`, the image of `H` under the function `f` is a subgroup of `K` if and only if `H` is a subgroup of the preimage of `K` under `f`.

For any additively homomorphic function `f` between additive groups `G` and `N`, the functions `AddSubgroup.map f` and `AddSubgroup.comap f` define a Galois connection between the subgroups of `G` and `N`.


/-- Extract the equation from a 2-morphism in a locally discrete 2-category.  -/
theorem CategoryTheory.LocallyDiscrete.eq_of_hom :
    ∀ {C : Type u} [inst : CategoryTheory.CategoryStruct.{v, u} C] {X Y : CategoryTheory.LocallyDiscrete C}
      {f g : X ⟶ Y}, (f ⟶ g) → f = g :=
  by sorry

The theorem `CategoryTheory.LocallyDiscrete.eq_of_hom` states that for any locally discrete category `C` with two objects `X` and `Y`, if there exist two morphisms `f` and `g` from `X` to `Y`, any 2-morphism from `f` to `g` implies that `f` is equal to `g`. In other words, in a locally discrete 2-category, any 2-morphism can be extracted as an equality of the morphisms it connects.

In a locally discrete 2-category, any 2-isomorphism between morphisms is an equality.


theorem Set.centralizer_subset :
    ∀ {M : Type u_1} {S T : Set M} [inst : Mul M], S ⊆ T → Set.centralizer T ⊆ Set.centralizer S := by sorry

This theorem states that for any type `M` with a multiplication operation and any two sets `S` and `T` of this type, if `S` is a subset of `T`, then the centralizer of `T` is a subset of the centralizer of `S`. Here, the centralizer of a set in a magma (a set with a single binary operation) is defined as the set of all elements in the magma such that each element when multiplied with any element from the set, the order of multiplication does not matter (i.e., `m * c = c * m` for all `m` in the set).

If `S` is a subset of `T` in a magma `M` with multiplication operation, then the centralizer of `T` is contained in the centralizer of `S`.


/-- **Tychonoff's theorem** formulated using `Set.pi`: product of compact sets is compact.  -/
theorem isCompact_univ_pi :
    ∀ {ι : Type u_1} {X : ι → Type u_2} [inst : (i : ι) → TopologicalSpace (X i)] {s : (i : ι) → Set (X i)},
      (∀ (i : ι), IsCompact (s i)) → IsCompact (Set.pi Set.univ s) :=
  by sorry

**Tychonoff's theorem**: Given an index set `ι` and a family of types `X` indexed by `ι`, where each type `X i` has a topology, if for each `i` in `ι`, the set `s i` in `X i` is compact, then the product set, which consists of all possible functions `f` such that `f i` belongs to `s i` for all `i` in `ι`, is also compact. Here, a set is said to be compact if for any nontrivial filter on it, there exists an element in the set such that every set in the filter meets every neighborhood of the element.

Given a family of compact sets `{Si : i ∈ I}` in topological spaces indexed by a set `I`, the product space carries the product topology and is compact.


theorem Mathlib.Logic.IsEmpty._auxLemma.2 : ∀ {α : Sort u_1} [inst : IsEmpty α] {p : α → Prop}, (∃ a, p a) = False := by
  sorry

This theorem states that for any sort `α` that is empty (as specified by the `IsEmpty` typeclass), and for any proposition `p` that depends on elements of `α`, the proposition "there exists an element in `α` such that `p` holds for that element" is always false. Essentially, this is because there can't be any elements in `α` for `p` to hold for, as `α` is empty.

For any empty sort `α` and proposition `p` depending on elements of `α`, ∀ (a : α), ¬ p(a) holds.


theorem CategoryTheory.shiftFunctorAdd'_eq_shiftFunctorAdd :
    ∀ (C : Type u) {A : Type u_1} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : AddMonoid A]
      [inst_2 : CategoryTheory.HasShift C A] (i j : A),
      CategoryTheory.shiftFunctorAdd' C i j (i + j) ⋯ = CategoryTheory.shiftFunctorAdd C i j :=
  by sorry

This theorem, `CategoryTheory.shiftFunctorAdd'_eq_shiftFunctorAdd`, states that for any type `C`, an additive monoid `A` and elements `i` and `j` from `A`, the operation of shifting functors with the sum `(i + j)` in category theory using the `shiftFunctorAdd'` function is equivalent to the operation of shifting functors with `i` and `j` separately using the `shiftFunctorAdd` function. Here, `C` is a type that has a predefined category structure, and `A` is a type with a predefined addition operation and an element called zero. The `HasShift` instance implies that the `C` category has a shift operation parameterized by the additive monoid `A`.

For any type `C` with a category structure, additive monoid `A`, and shift functor `shiftFunctorAdd` in category theory, the composition of `shiftFunctorAdd` with the addition operation in `A` is equivalent to the repeated application of `shiftFunctorAdd` with the additive monoid elements.


theorem Finset.image₂_union_right :
    ∀ {α : Type u_1} {β : Type u_3} {γ : Type u_5} [inst : DecidableEq γ] {f : α → β → γ} {s : Finset α}
      {t t' : Finset β} [inst_1 : DecidableEq β],
      Finset.image₂ f s (t ∪ t') = Finset.image₂ f s t ∪ Finset.image₂ f s t' :=
  by sorry

This theorem, `Finset.image₂_union_right`, states that for any types `α`, `β`, and `γ`, where `γ` has decidable equality, given a binary function `f : α → β → γ`, a finite set `s` of type `α`, and two finite sets `t` and `t'` of type `β` with decidable equality, the image of the function `f` over the cartesian product of `s` and the union of `t` and `t'` (denoted as `Finset.image₂ f s (t ∪ t')`) is equal to the union of the image of `f` over `s` and `t` and the image of `f` over `s` and `t'` (denoted as `Finset.image₂ f s t ∪ Finset.image₂ f s t'`).

In mathematical terms, if $f : \alpha \rightarrow \beta \rightarrow \gamma$ is a binary function, $s$ is a finite set of elements of type $\alpha$, and $t$ and $t'$ are finite sets of elements of type $\beta$, then the image of $f$ over the cartesian product of $s$ and the union of $t$ and $t'$ is equal to the union of the image of $f$ over the cartesian products of $s$ and $t$ and of $s$ and $t'$.

For any binary function `f` from type `α × β` to type `γ` with decidable equality, finite sets `s` of type `α`, and finite sets `t` and `t'` of type `β`, `Finset.image₂ f (s × (t ∪ t')) = Finset.image₂ f (s × t) ∪ Finset.image₂ f (s × t')`.


theorem Asymptotics.IsBigO.comp_tendsto :
    ∀ {α : Type u_1} {β : Type u_2} {E : Type u_3} {F : Type u_4} [inst : Norm E] [inst_1 : Norm F] {f : α → E}
      {g : α → F} {l : Filter α},
      f =O[l] g → ∀ {k : β → α} {l' : Filter β}, Filter.Tendsto k l' l → (f ∘ k) =O[l'] (g ∘ k) :=
  by sorry

The theorem `Asymptotics.IsBigO.comp_tendsto` states that for any types `α`, `β`, `E`, and `F`, given the normed spaces `E` and `F`, and two functions `f : α → E` and `g : α → F` with a filter `l` on `α`; if `f` is Big O of `g` at `l` (denoted as `f =O[l] g`), then for any function `k : β → α` and any filter `l'` on `β`, if `k` tends towards `l` under filter `l'` (denoted as `Filter.Tendsto k l' l`), then the composition of `f` and `k` is Big O of the composition of `g` and `k` at `l'` (denoted as `(f ∘ k) =O[l'] (g ∘ k)`).

In other words, if `f` is asymptotically bounded by `g` as `α` tends to `l`, then this asymptotic dominance is preserved under composition with a function `k` that tends towards `l` as `β` tends towards `l'`.

If `f =O[l] g` and `Filter.Tendsto k l' l`, then `(f ∘ k) =O[l'] (g ∘ k)` for functions `f : α → E`, `g : α → F`, and `k : β → α` in the context of normed spaces `E` and `F` and filters `l` on `α` and `l'` on `β`.


theorem Set.image2_congr :
    ∀ {α : Type u_1} {β : Type u_3} {γ : Type u_5} {f f' : α → β → γ} {s : Set α} {t : Set β},
      (∀ a ∈ s, ∀ b ∈ t, f a b = f' a b) → Set.image2 f s t = Set.image2 f' s t :=
  by sorry

This theorem, `Set.image2_congr`, states that for any given types `α`, `β`, and `γ`, and any two binary functions `f` and `f'` from `α` and `β` to `γ`, along with sets `s` of type `α` and `t` of type `β`, if for every element `a` of set `s` and every element `b` of set `t`, `f a b` is equal to `f' a b`, then the image of function `f` over sets `s` and `t` is equal to the image of function `f'` over the same sets. In mathematical terms, if two binary functions produce the same results for all possible combinations of elements of two sets, then their images over these sets are equal.

If two binary functions from sets `α` and `β` to set `γ` agree on all elements of sets `s` and `t`, then the images of these functions over sets `s` and `t` are equal.


theorem Filter.map₂_neBot_iff :
    ∀ {α : Type u_1} {β : Type u_3} {γ : Type u_5} {m : α → β → γ} {f : Filter α} {g : Filter β},
      Filter.NeBot (Filter.map₂ m f g) ↔ Filter.NeBot f ∧ Filter.NeBot g :=
  by sorry

The theorem `Filter.map₂_neBot_iff` states that for any types `α`, `β`, and `γ`, and any binary function `m : α → β → γ`, and any filters `f : Filter α` and `g : Filter β`, the filter `Filter.map₂ m f g` is non-bottom if and only if both `f` and `g` are non-bottom. Here, a filter being non-bottom means that it is not the trivial filter, which contains only the empty set.

For filters `f` on type `α` and `g` on type `β`, and binary function `m : α → β → γ`, `Filter.map₂ m f g` is non-empty if and only if both `f` and `g` are non-empty. (Note: In Lean, a non-bottom filter is the same as a non-empty filter.)


theorem Polynomial.natDegree_mul :
    ∀ {R : Type u} [inst : Semiring R] [inst_1 : NoZeroDivisors R] {p q : Polynomial R},
      p ≠ 0 → q ≠ 0 → Polynomial.natDegree (p * q) = Polynomial.natDegree p + Polynomial.natDegree q :=
  by sorry

This theorem states that for any semiring `R` with no zero divisors, and for any two non-zero polynomials `p` and `q` from `R`, the natural degree of the product of `p` and `q` is equal to the sum of the natural degrees of `p` and `q`. In other words, the degree of a product of two non-zero polynomials is the sum of the degrees of the polynomials. This mirrors the familiar property from algebra where the degree of the product of two non-zero polynomials is the sum of their degrees.

Given a semiring `R` without zero divisors, the degree of the product of two non-zero polynomials `p` and `q` from `R` equals the sum of the degrees of `p` and `q`.


IsLUB.unique

theorem IsLUB.unique : ∀ {α : Type u} [inst : PartialOrder α] {s : Set α} {a b : α}, IsLUB s a → IsLUB s b → a = b := by
  sorry

This theorem states that for any type `α` equipped with a partial order and for any set `s` of elements of type `α`, if both `a` and `b` are least upper bounds of the set `s`, then `a` and `b` must be equal. In mathematical terms, in a partially ordered set, the least upper bound of a given set, if it exists, is unique.

In a partially ordered set, if two elements are the least upper bounds of a set, then they are equal.


theorem Mathlib.Data.Polynomial.Eval._auxLemma.13 :
    ∀ {R : Type u} {a : R} [inst : Semiring R] {p : Polynomial R}, Polynomial.IsRoot p a = (Polynomial.eval a p = 0) :=
  by sorry

This theorem states that for any type 'R', any element 'a' of type 'R', any semiring structure on 'R', and any polynomial 'p' with coefficients from 'R', the element 'a' is a root of polynomial 'p' if and only if the evaluation of the polynomial 'p' at 'a' is equal to zero. In other words, the polynomial evaluated at 'a' being zero is equivalent to 'a' being a root of the polynomial, as per the definition of Polynomial.IsRoot. This provides a direct connection between the concept of a polynomial's root and the operation of polynomial evaluation in the context of semirings.

For any semiring 'R', element 'a' in 'R', semiring polynomial 'p' over 'R' with coefficients in 'R', the element 'a' is a root of polynomial 'p' if and only if evaluating 'p' at 'a' equals zero.


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

This theorem states that for any two natural numbers `n` and `m`, if `n` is less than or equal to `m`, then either `n` is equal to `m` or `n` is less than `m`. In other words, if `n` is not greater than `m`, it must be either equal or strictly less. This is a basic property of the ordering of natural numbers and is similar to the trichotomy property.

For all natural numbers `n` and `m`, if `n ≤ m`, then `n = m` or `n < m`.


theorem CategoryTheory.Limits.coprod.inr_map :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {W X Y Z : C}
      [inst_1 : CategoryTheory.Limits.HasBinaryCoproduct W X] [inst_2 : CategoryTheory.Limits.HasBinaryCoproduct Y Z]
      (f : W ⟶ Y) (g : X ⟶ Z),
      CategoryTheory.CategoryStruct.comp CategoryTheory.Limits.coprod.inr (CategoryTheory.Limits.coprod.map f g) =
        CategoryTheory.CategoryStruct.comp g CategoryTheory.Limits.coprod.inr :=
  by sorry

The theorem `CategoryTheory.Limits.coprod.inr_map` states that for any category `C` and any four objects `W`, `X`, `Y`, and `Z` in `C`, given that `W` and `X` form a binary coproduct, and `Y` and `Z` also form a binary coproduct, then for any morphisms `f` from `W` to `Y` and `g` from `X` to `Z`, the composition of the inclusion map from the second component of the coproduct (`coprod.inr`) and the coproduct map derived from `f` and `g` (`coprod.map f g`) is equal to the composition of `g` and `coprod.inr`. This principle reflects the commutativity of the diagram in the categorical sense.

For any objects `W`, `X`, `Y`, and `Z` in a category `C` forming binary coproducts, and morphisms `f: W → Y` and `g: X → Z`, the diagram commutes: `coprod.inr ∘ coprod.map f g = g ∘ coprod.inr`.


theorem Mathlib.Data.ENNReal.Basic._auxLemma.10 : ∀ {r : ℝ}, (ENNReal.ofReal r < ⊤) = True := by sorry

The theorem `Mathlib.Data.ENNReal.Basic._auxLemma.10` states that the function `ENNReal.ofReal`, when applied to any real number `r`, always yields a value that is less than positive infinity. This holds true for every real number `r`. Here, `ENNReal.ofReal` is a function that takes as input a real number and returns a nonnegative extended real number, or zero if the input is negative. The result less than positive infinity means the output of the function is always a finite number.

For all real numbers `r`, the function `ENNReal.ofReal r` returns a finite extended real number.


theorem Polynomial.natDegree_X :
    ∀ {R : Type u} [inst : Semiring R] [inst_1 : Nontrivial R], Polynomial.natDegree Polynomial.X = 1 := by sorry

This theorem states that for any type `R` that is equipped with a semiring structure and the property of non-triviality (meaning that there is at least one element in `R` that is not the additive identity), the natural degree of the monomial polynomial `X` (which is the polynomial variable or indeterminate) is `1`. In mathematical terms, it is saying that the degree of the polynomial `X` is `1` in any nontrivial semiring.

In any semiring endowed with non-triviality, the degree of the monomial polynomial X is 1.


theorem Primrec₂.to_comp :
    ∀ {α : Type u_1} {β : Type u_2} {σ : Type u_3} [inst : Primcodable α] [inst_1 : Primcodable β]
      [inst_2 : Primcodable σ] {f : α → β → σ}, Primrec₂ f → Computable₂ f :=
  by sorry

The theorem `Primrec₂.to_comp` states that for all types `α`, `β`, and `σ` that are primcodable (i.e., have a primitive recursive coding), and for any function `f` that takes arguments of type `α` and `β` and returns a value of type `σ`, if `f` is a binary primitive recursive function (as defined by `Primrec₂`), then `f` is also a computable function (as defined by `Computable₂`). Essentially, this theorem establishes a connection between the concepts of primitive recursiveness and computability for binary functions, asserting that primitive recursiveness implies computability.

If `α`, `β`, and `σ` are primcodable types and `f : α → β → σ` is a binary primitive recursive function, then `f` is computable.


theorem CategoryTheory.isSheaf_iff_isSheaf_of_type :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] (J : CategoryTheory.GrothendieckTopology C)
      (P : CategoryTheory.Functor Cᵒᵖ (Type w)),
      CategoryTheory.Presheaf.IsSheaf J P ↔ CategoryTheory.Presieve.IsSheaf J P :=
  by sorry

The theorem `CategoryTheory.isSheaf_iff_isSheaf_of_type` states that for any type `C` with a category structure, a Grothendieck topology `J` on `C`, and a presheaf `P` from the opposite category of `C` to the category of types, the presheaf `P` is a sheaf with respect to the topology `J` if and only if it satisfies the sheaf condition for every sieve in the topology `J`. In more mathematical terms, a presheaf is a sheaf if it is a sheaf for every sieve in the Grothendieck topology.

A presheaf on a type with a category structure and a Grothendieck topology is a sheaf if and only if it satisfies the sheaf condition for every sieve in the topology.


theorem Real.sqrt_pos : ∀ {x : ℝ}, 0 < Real.sqrt x ↔ 0 < x := by sorry

The theorem `Real.sqrt_pos` states that for every real number `x`, the square root of `x` is positive if and only if `x` is positive. In other words, taking the square root of a positive real number results in a positive real number, and if the square root of a real number is positive, then the original number must have been positive.

The square root of a positive real number is positive, and only positive real numbers have a positive square root.


theorem Finset.image₂_empty_left :
    ∀ {α : Type u_1} {β : Type u_3} {γ : Type u_5} [inst : DecidableEq γ] {f : α → β → γ} {t : Finset β},
      Finset.image₂ f ∅ t = ∅ :=
  by sorry

This theorem states that for any types `α`, `β`, and `γ` with `γ` having a decidable equality relation, any binary function `f` from `α` and `β` to `γ`, and any finite set `t` of type `β`, the image of the function `f` when applied to an empty set of type `α` and the set `t` is always an empty set of type `γ`. In mathematical terms, if we consider the function `f : α × β → γ`, the image of the empty set in `α` under this function is always the empty set in `γ`.

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


theorem CategoryTheory.Limits.HasZeroObject.from_zero_ext :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroObject C] {X : C}
      (f g : 0 ⟶ X), f = g :=
  by sorry

This theorem states that in the context of category theory, given a category `C` with a zero object, and for any object `X` in `C`, any two morphisms `f` and `g` from the zero object to `X` are equal. This is an expression of the uniqueness property of morphisms from the zero object in a category with a zero object.

In a category with a zero object, any two morphisms from the zero object to an object X are equal.


theorem MeasureTheory.measure_iUnion :
    ∀ {ι : Type u_1} {α : Type u_2} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} [inst : Countable ι]
      {f : ι → Set α},
      Pairwise (Disjoint on f) → (∀ (i : ι), MeasurableSet (f i)) → ↑↑μ (⋃ i, f i) = ∑' (i : ι), ↑↑μ (f i) :=
  by sorry

The theorem `MeasureTheory.measure_iUnion` states that for any countable type `ι`, any type `α`, any `MeasurableSpace α` named `m0`, any `MeasureTheory.Measure α` named `μ`, and a function `f` from `ι` to `Set α`, if the sets produced by `f` are pairwise disjoint and each of these sets is measurable, then the measure of the union of these sets (⋃ i, f i) is equal to the sum of the measures of each individual set (∑' (i : ι), ↑↑μ (f i)). In other words, in a countable collection of pairwise disjoint measurable sets, the measure of the union of the sets is the sum of their individual measures.

For any countable family of pairwise disjoint measurable sets in a Measurable Space, the measure of their union equals the sum of the measures of each individual set.


theorem Set.Icc_eq_empty : ∀ {α : Type u_1} [inst : Preorder α] {a b : α}, ¬a ≤ b → Set.Icc a b = ∅ := by sorry

This theorem states that for any type `α` that has a preorder (a reflexive and transitive binary relation) and for any two elements `a` and `b` of this type, if `a` is not less than or equal to `b`, then the set of all elements `x` such that `a ≤ x ≤ b` (denoted as `Set.Icc a b` and otherwise known as a closed interval) is empty. In other words, if the lower bound `a` is greater than the upper bound `b`, there are no elements `x` that can satisfy the conditions for being in the interval, hence the interval is empty.

For any preorder type `α` and elements `a` and `b` of `α` with `a > b`, the interval `Set.Icc a b` is empty.


theorem lt_of_add_lt_add_right :
    ∀ {α : Type u_1} [inst : Add α] [inst_1 : LT α]
      [i : ContravariantClass α α (Function.swap fun x x_1 => x + x_1) fun x x_1 => x < x_1] {a b c : α},
      b + a < c + a → b < c :=
  by sorry

This theorem, `lt_of_add_lt_add_right`, states that for any type `α` that has addition (`Add`), less than operation (`LT`), and for which the addition operation (`x + x_1`) is contravariant (i.e., if `x + a` decreases when `x` increases, given the condition `x < x_1`), then if `b + a` is less than `c + a`, it follows that `b` is less than `c`. In other words, if adding the same value `a` to two quantities `b` and `c` results in a smaller sum for `b + a` compared to `c + a`, then `b` is less than `c`. This is a property related to the cancellation law in ordered additive groups.

If `α` is an additive type with contravariant addition and `x < x_1`, then `b LT c` implies `b + a LT c + a`.


theorem Mathlib.Data.Nat.Parity._auxLemma.4 : ∀ {n : ℕ}, Odd n = ¬Even n := by sorry

This theorem states that for all natural numbers `n`, `n` is odd if and only if it is not even. In the context of a semiring, a number `n` is odd if there exists another number `k` such that `n` equals `2*k + 1`. On the other hand, a number `n` is even if there exists a number `r` such that `n` equals `r + r`. Therefore, this theorem establishes the mutually exclusive and exhaustive nature of odd and even numbers in the set of natural numbers.

A natural number `n` is odd if and only if it cannot be expressed as the sum of two equal natural numbers. Equivalently, it is odd if and only if it is of the form `2*k + 1` for some natural number `k`.


theorem Mathlib.Order.Filter.Basic._auxLemma.5 : ∀ {α : Type u} {f : Filter α}, (Set.univ ∈ f) = True := by sorry

This theorem states that for any type `α` and any filter `f` on `α`, the universal set of `α` (i.e., the set containing all elements of `α`) is in the filter `f`. This is always true, regardless of the specific type or filter. In set-theoretic terms, this means that the filter `f` always includes the entire universe of discourse for the type `α`.

For any type `α` and filter `f` on `α`, the universal set of `α` belongs to `f`.


theorem EuclideanDomain.div_add_mod : ∀ {R : Type u} [inst : EuclideanDomain R] (a b : R), b * (a / b) + a % b = a := by
  sorry

This theorem is stating a property of Euclidean Domains. For any Euclidean Domain `R` and any two elements `a` and `b` of `R`, the equation `b * (a / b) + a % b = a` holds. This is very much like the division algorithm in integers where the remainder when `a` is divided by `b` added to the product of `b` and the quotient of `a` divided by `b`, gives back `a`.

In a Euclidean domain, the quotient and remainder of any two elements satisfy the equation `b * (a / b) + a % b = a`.


theorem Real.sqrt_one : Real.sqrt 1 = 1 := by sorry

This theorem states that the square root of 1 in the real numbers is equal to 1. In other words, when the `Real.sqrt` function is applied to the real number 1, the result is the real number 1. This corresponds to the well-known mathematical fact that $\sqrt{1} = 1$.

The square root of 1 in the real numbers equals 1. (i.e., Real.sqrt 1 = 1)


Function.Periodic.eq

theorem Function.Periodic.eq :
    ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {c : α} [inst : AddZeroClass α], Function.Periodic f c → f c = f 0 := by
  sorry

The theorem `Function.Periodic.eq` states that for any types `α` and `β`, any function `f` from `α` to `β`, and any `c` of type `α`, given an instance of `AddZeroClass` for `α`, if the function `f` is periodic with period `c`, then the value of the function `f` at `c` is equal to the value of the function `f` at `0`. In mathematical terms, if `f` is a function such that `f(x + c) = f(x)` for all `x` in `α`, then `f(c) = f(0)`.

If `f` is a periodic function of period `c` from type `α` to type `β`, then `f(c) = f(0)`.


theorem ConvexCone.smul_mem :
    ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : OrderedSemiring 𝕜] [inst_1 : AddCommMonoid E] [inst_2 : SMul 𝕜 E]
      (S : ConvexCone 𝕜 E) {c : 𝕜} {x : E}, 0 < c → x ∈ S → c • x ∈ S :=
  by sorry

This theorem states that for any semi-ring 𝕜, an additive commutative monoid E and a scalar multiplication operation between 𝕜 and E, if we have a convex cone S in the vector space spanned by 𝕜 and E, then for any scalar c from 𝕜 and any vector x from E, if c is positive and x belongs to the convex cone S, then the scalar multiple c • x also belongs to the convex cone S. This essentially captures one of the key properties of a convex cone - it is closed under positive scalar multiplication.

For any semi-ring 𝕜, additive commutative monoid E, and scalar multiplication between 𝕜 and E, if S is a convex cone in the vector space spanned by 𝕜 and E, then for all positive scalars c in 𝕜 and vectors x in E, c • x is also in S.


theorem inv_le_one : ∀ {α : Type u_2} [inst : LinearOrderedSemifield α] {a : α}, 1 ≤ a → a⁻¹ ≤ 1 := by sorry

This theorem, named `inv_le_one`, states that for any type `α` which forms a Linear Ordered Semifield, if a given element `a` of this type `α` is greater than or equal to 1, then the multiplicative inverse of `a` (denoted by `a⁻¹`) is less than or equal to 1. This is a general property in the field of order theory and algebra, particularly applicable to number systems like the real or complex numbers.

For any Linear Ordered Semifield type `α` and element `a` of `α` greater than or equal to 1, `a⁻¹ ≤ 1`.


/-- Taking the sum under `h` is an additive homomorphism of finsupps,if `h` is an additive
homomorphism. This is a more specific version of `finsupp.sum_add_index` with simpler
hypotheses. -/
theorem Finsupp.sum_add_index' :
    ∀ {α : Type u_1} {M : Type u_8} {N : Type u_10} [inst : AddZeroClass M] [inst_1 : AddCommMonoid N] {f g : α →₀ M}
      {h : α → M → N},
      (∀ (a : α), h a 0 = 0) →
        (∀ (a : α) (b₁ b₂ : M), h a (b₁ + b₂) = h a b₁ + h a b₂) →
          Finsupp.sum (f + g) h = Finsupp.sum f h + Finsupp.sum g h :=
  by sorry

The theorem `Finsupp.sum_add_index'` states that given two types `α` and `M`, and an additive commutative monoid `N`, if `h` is a function from `α` and `M` to `N` such that `h` of `a` and `0` is `0` for all `a` in `α`, and `h` of `a` and the sum of `b₁` and `b₂` is the sum of `h` of `a` and `b₁` and `h` of `a` and `b₂` for all `a` in `α` and `b₁`, `b₂` in `M`, then the sum of `h a (f a)` and `h a (g a)` over the support of `f + g` is the sum of `h a (f a)` over the support of `f` and `h a (g a)` over the support of `g`. Here, `f` and `g` are two finitely supported functions from `α` to `M`. This theorem is a more specific version of `finsupp.sum_add_index` with simpler hypotheses, and it shows that taking the sum under `h` is an additive homomorphism of finitely supported functions, if `h` itself is an additive homomorphism.

Given two additive commutative monoids `N`, two types `α` and `M`, and a function `h` from `α` x `M` to `N` such that `h(a, 0) = 0` for all `a` in `α` and `h` is additive on `α` x `M`, the sum of `h a (f a)` over the support of `f` is equal to the sum of `h a (g a)` over the support of `g` for any two finitely supported functions `f` and `g` from `α` to `M`.


theorem List.rotate_nil : ∀ {α : Type u} (n : ℕ), List.rotate [] n = [] := by sorry

This theorem, `List.rotate_nil`, states that for any type `α` and any natural number `n`, rotating an empty list `[]` by `n` places results in the empty list `[]`. In other words, no matter how many positions you try to shift the elements of an empty list, the result will always be an empty list.

For any type `α` and natural number `n`, the rotation of the empty list `[]` by `n` places is the empty list `[]`.


theorem imp_congr_right : ∀ {a b c : Prop}, (a → (b ↔ c)) → (a → b ↔ a → c) := by sorry

This theorem states that, for any three propositions `a`, `b`, and `c`, if we assume that whenever `a` holds, `b` is equivalent to `c`, then we can conclude that `a` implies `b` is equivalent to `a` implying `c`. In other words, if whether `a` implies `b` depends solely on whether `a` also implies `c`, then the two implications are equivalent under the assumption of `a`. This theorem is a statement about the transitivity of logical implications in propositional logic.

If `a` implies `b` is equivalent to `c` whenever `a` holds, then `a` implies `b` is equivalent to `a` implies `c`.


theorem Set.subset_singleton_iff_eq : ∀ {α : Type u} {s : Set α} {x : α}, s ⊆ {x} ↔ s = ∅ ∨ s = {x} := by sorry

This theorem, named `Set.subset_singleton_iff_eq`, states that for any type `α`, any set `s` of type `α`, and any element `x` of type `α`, the subset relation `s ⊆ {x}` is true if and only if either `s` is the empty set `∅` or `s` is the singleton set `{x}`. In other words, a set `s` is a subset of a singleton set `{x}` if and only if `s` is either empty or it is a singleton set containing the same element as `{x}`.

A set `s` is a subset of the singleton set `{x}` if and only if `s` is empty or `s = {x}`.


theorem Ideal.primeCompl_le_nonZeroDivisors :
    ∀ {R : Type u_1} [inst : CommSemiring R] (P : Ideal R) [hp : Ideal.IsPrime P] [inst_1 : NoZeroDivisors R],
      Ideal.primeCompl P ≤ nonZeroDivisors R :=
  by sorry

This theorem states that for any commutative semiring `R`, if `P` is a prime ideal within `R` and `R` does not contain any zero divisors (i.e., `R` is an integral domain), then the complement of the prime ideal `P` is a subset of the set of non-zero divisors of `R`. In simple terms, if we remove the elements of the prime ideal `P` from the semiring `R`, all remaining elements will not be zero divisors.

If `R` is a commutative semiring with no zero divisors and `P` is a prime ideal in `R`, then the complement of `P` in `R` is contained in the set of non-zero divisors of `R`.


theorem Computation.get_eq_of_mem :
    ∀ {α : Type u} (s : Computation α) [h : Computation.Terminates s] {a : α}, a ∈ s → Computation.get s = a := by sorry

The theorem `Computation.get_eq_of_mem` states that for any type `α`, given a terminating computation `s` of type `α`, and an element `a` of type `α`, if `a` is an element of the computation `s`, then the result of the computation `s` (obtained using `Computation.get`) is equal to `a`. This means that, if a computation produces a certain result, and that result is an element of the computation, then when we get the result of the computation, it's guaranteed to be that element.

If `s` is a terminating computation of type `α` and `a` is an element of `s`, then `Computation.get s = a`.


theorem tsub_eq_iff_eq_add_of_le :
    ∀ {α : Type u_1} [inst : AddCommSemigroup α] [inst_1 : PartialOrder α] [inst_2 : ExistsAddOfLE α]
      [inst_3 : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] [inst_4 : Sub α] [inst_5 : OrderedSub α]
      {a b c : α} [inst_6 : ContravariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1],
      b ≤ a → (a - b = c ↔ a = c + b) :=
  by sorry

This theorem states that for any type `α` which forms an additive commutative semigroup, has a partial order, has an addition operation that obeys the order, has a subtraction operation, and the subtraction is ordered, given three elements `a`, `b`, and `c` of type `α`, if `b` is less than or equal to `a`, then `a - b` equals `c` if and only if `a` is equal to `c + b`. This essentially expresses how subtraction can be seen as the addition of the negation.

For any additive commutative semigroup `α` with a partial order and ordered subtraction, if `b ≤ a` then `a = c + b` if and only if `a = c + b` and `b = a - c`.


theorem Nat.ascFactorial_succ : ∀ {n k : ℕ}, Nat.ascFactorial n (Nat.succ k) = (n + k) * Nat.ascFactorial n k := by
  sorry

The theorem `Nat.ascFactorial_succ` states that for any two natural numbers `n` and `k`, the ascending factorial of `n` and `k + 1` (represented in Lean as `Nat.ascFactorial n (Nat.succ k)`) is equal to the product of `(n + k)` and the ascending factorial of `n` and `k` (represented as `(n + k) * Nat.ascFactorial n k`). In mathematical terms, the ascending factorial `n.ascFactorial (k + 1)` is equal to the product `(n + k) * n.ascFactorial k`. This essentially captures the recursive nature of the ascending factorial operation.

For all natural numbers n and k, Nat.ascFactorial (Nat.succ n) (Nat.succ k) = (n + k) * Nat.ascFactorial n k.


theorem CategoryTheory.ShortComplex.HasRightHomology.mk' :
    ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
      {S : CategoryTheory.ShortComplex C},
      CategoryTheory.ShortComplex.RightHomologyData S → CategoryTheory.ShortComplex.HasRightHomology S :=
  by sorry

This theorem states that for any type 'C' which is a category with zero morphisms, and any short complex 'S' within this category, if 'S' has right homology data, then 'S' also has right homology. In other words, the right homology data of a short complex in a category with zero morphisms is sufficient to establish the existence of right homology for that short complex.

If 'C' is a category with zero morphisms and 'S' is a short complex in 'C' with right homology data, then 'S' has defined right homologies.


theorem Mathlib.GroupTheory.GroupAction.Basic._auxLemma.17 :
    ∀ {G : Type u_1} {α : Type u_2} [inst : Group G] [inst_1 : MulAction G α] {a : α} {g : G},
      (g ∈ MulAction.stabilizer G a) = (g • a = a) :=
  by sorry

This theorem states that for any group `G` and any type `α` with a multiplication action of `G` on `α`, and for any element `a` of `α` and `g` of `G`, the element `g` belongs to the stabilizer of `a` if and only if the action of `g` on `a` leaves `a` invariant. In other words, `g` is in the stabilizer of `a` under this action if and only if multiplying `a` by `g` results in `a` again.

For any group action of a group `G` on a type `α` and any element `a` in `α`, an element `g` in `G` is in the stabilizer of `a` if and only if `a * g = a`.


Finset.Subset.antisymm

theorem Finset.Subset.antisymm : ∀ {α : Type u_1} {s₁ s₂ : Finset α}, s₁ ⊆ s₂ → s₂ ⊆ s₁ → s₁ = s₂ := by sorry

This theorem states that for any two finite sets `s₁` and `s₂` of a certain type `α`, if `s₁` is a subset of `s₂` and `s₂` is a subset of `s₁`, then `s₁` and `s₂` are equal. In mathematical terms, this is a formalization of the antisymmetry property of the subset relation in set theory.

For any sets `s₁` and `s₂` of type `α`, if `s₁ ⊆ s₂` and `s₂ ⊆ s₁`, then `s₁ = s₂`. (This is the formalization of the antisymmetric property of subset relation in set theory in Lean 4.)


NonUnitalStarAlgHom.ext

theorem NonUnitalStarAlgHom.ext :
    ∀ {R : Type u_1} {A : Type u_2} {B : Type u_3} [inst : Monoid R] [inst_1 : NonUnitalNonAssocSemiring A]
      [inst_2 : DistribMulAction R A] [inst_3 : Star A] [inst_4 : NonUnitalNonAssocSemiring B]
      [inst_5 : DistribMulAction R B] [inst_6 : Star B] {f g : A →⋆ₙₐ[R] B}, (∀ (x : A), f x = g x) → f = g :=
  by sorry

The theorem `NonUnitalStarAlgHom.ext` states that for all types `R`, `A`, and `B`, where `R` is a Monoid, `A` and `B` are NonUnitalNonAssocSemirings with a DistribMulAction from `R` and a `Star` operation, if we have two `Star` algebra homomorphisms (non-unital) `f` and `g` from `A` to `B` over `R`, then if for every element `x` of `A`, `f(x)` equals `g(x)`, it follows that `f` and `g` are the same function. In other words, two `Star` algebra homomorphisms are equal if they map every element of `A` to the same element in `B`.

If `f` and `g` are two non-unital star algebra homomorphisms from a NonUnitalNonAssocSemiring `A` to another with a DistribMulAction from a Monoid `R` and a `Star` operation, such that `f(x) = g(x)` for all `x` in `A`, then `f = g`.


Filter.EventuallyEq.add

theorem Filter.EventuallyEq.add :
    ∀ {α : Type u} {β : Type v} [inst : Add β] {f f' g g' : α → β} {l : Filter α},
      f =ᶠ[l] g → f' =ᶠ[l] g' → (fun x => f x + f' x) =ᶠ[l] fun x => g x + g' x :=
  by sorry

This theorem asserts that for any two pairs of functions `(f, g)` and `(f', g')` mapped from a type `α` to a type `β` that supports addition, if `f` is eventually equal to `g` and `f'` is eventually equal to `g'` under a certain filter `l`, then the function that maps `x` to `f(x) + f'(x)` is eventually equal to the function that maps `x` to `g(x) + g'(x)` under the same filter `l`. "Eventually equal" means that the functions are equal for all inputs from a certain point onward.

If functions `f : α -> β` and `g : α -> β`, and functions `f' : α -> β` and `g' : α -> β` are eventually equal under filter `l`, then their sums `f + f' : α -> β` and `g + g' : α -> β` are eventually equal under the same filter `l`.


theorem Real.arcsin_neg : ∀ (x : ℝ), Real.arcsin (-x) = -Real.arcsin x := by sorry

This theorem states that for every real number 'x', the arcsine of negative 'x' is equal to the negative of the arcsine of 'x'. In other words, the arcsine function has symmetry about the origin, which means flipping the input sign also flips the output sign.

For all real numbers x, arcsin(-x) = -arcsin(x).


theorem forall₅_congr :
    ∀ {α : Sort u_1} {β : α → Sort u_2} {γ : (a : α) → β a → Sort u_3} {δ : (a : α) → (b : β a) → γ a b → Sort u_4}
      {ε : (a : α) → (b : β a) → (c : γ a b) → δ a b c → Sort u_5}
      {p q : (a : α) → (b : β a) → (c : γ a b) → (d : δ a b c) → ε a b c d → Prop},
      (∀ (a : α) (b : β a) (c : γ a b) (d : δ a b c) (e : ε a b c d), p a b c d e ↔ q a b c d e) →
        ((∀ (a : α) (b : β a) (c : γ a b) (d : δ a b c) (e : ε a b c d), p a b c d e) ↔
          ∀ (a : α) (b : β a) (c : γ a b) (d : δ a b c) (e : ε a b c d), q a b c d e) :=
  by sorry

This theorem, `forall₅_congr`, states that for every five nested dependent types `α`, `β`, `γ`, `δ`, and `ε`, and two predicate functions `p` and `q` that depend on these five types, if for all possible parameters, `p` is logically equivalent to `q` (`p` if and only if `q`), then the universal quantification over `p` is logically equivalent to the universal quantification over `q`. In simpler terms, if two predicates are true under the same conditions for all possible values of five nested dependent types, then the statement "all values satisfy `p`" is true if and only if "all values satisfy `q`".

If for all dependent types α, β, γ, δ, and ε, and predicate functions p and q, p(α, β, γ, δ, ε) is logically equivalent to q(α, β, γ, δ, ε) for all parameters, then ∀x, p(x) is logically equivalent to ∀x, q(x).


theorem Polynomial.mul_comp :
    ∀ {R : Type u_1} [inst : CommSemiring R] (p q r : Polynomial R),
      Polynomial.comp (p * q) r = Polynomial.comp p r * Polynomial.comp q r :=
  by sorry

The theorem `Polynomial.mul_comp` states that for any given type `R` which forms a commutative semiring, and for any three polynomials `p`, `q`, and `r` over type `R`, the result of composing the product of `p` and `q` with `r` is equal to the product of the result of composing `p` with `r` and the result of composing `q` with `r`. This can be expressed as: `Polyomial.comp (p * q) r = Polyomial.comp p r * Polyomial.comp q r`. This theorem essentially demonstrates the distributive property of polynomial composition over multiplication.

For any commutative semiring type R and polynomials p, q, and r over R, the distribution law holds: Polyomial.comp (p * q) r = Polyomial.comp p r * Polyomial.comp q r.


theorem Function.surjective_id : ∀ {α : Sort u₁}, Function.Surjective id := by sorry

This theorem states that for any type `α`, the identity function is surjective. In other words, for any `α`, each element of `α` is mapped to by some element of `α` under the identity function. In mathematical terms, this means that for every `b` in `α`, there exists an `a` in `α` such that `id a = b`, which always holds true as `id a` is always `a`.

For any type `α`, the identity function `id : α → α` is surjective.


theorem add_one_zsmul : ∀ {G : Type w} [inst : AddGroup G] (a : G) (n : ℤ), (n + 1) • a = n • a + a := by sorry

This theorem states that for any type `G` that has an addition group structure, and for any element `a` of type `G` and any integer `n`, the statement `(n + 1) • a = n • a + a` holds. In simpler terms, it means that adding 1 to `n` and then performing the scalar multiplication operation on `a` is equal to performing the scalar multiplication operation on `n` and `a`, and then adding `a`.

For any additive group `G` and element `a` in `G`, and any integer `n`, the equation `(n + 1) * a = n * a + a` holds.


theorem IsCompact.closure_of_subset :
    ∀ {X : Type u_1} [inst : TopologicalSpace X] [inst_1 : R1Space X] {s K : Set X},
      IsCompact K → s ⊆ K → IsCompact (closure s) :=
  by sorry

This theorem states that in any topological space, if a set `K` is compact and `s` is a subset of `K`, then the closure of `s` is also compact. Here, compactness refers to the property that for any nontrivial filter containing the set, there is a point in the set such that every set in the filter intersects every neighborhood of that point. The closure of a set is the smallest closed set that contains it.

In any topological space, if a compact set `K` contains a subset `s`, then the closure of `s` is also compact.


theorem MulHom.map_mul :
    ∀ {M : Type u_4} {N : Type u_5} [inst : Mul M] [inst_1 : Mul N] (f : M →ₙ* N) (a b : M), f (a * b) = f a * f b := by
  sorry

This theorem states that for any two types `M` and `N`, if both of them have a multiplication operation and there exists a multiplication-preserving function `f` (also known as a multiplicative homomorphism) from `M` to `N`, then for any two elements `a` and `b` of `M`, the result of applying `f` to the product `a * b` is the same as the product of applying `f` to `a` and `b` individually. In other words, the function `f` preserves the multiplication operation under its mapping from `M` to `N`.

If `f` is a multiplicative homomorphism from type `M` with multiplication `*` to type `N` with multiplication `�� /******/`, then for all `a, b` in `M`, `f(a * b) = f(a) �� /******/ f(b)`.


BddAbove.mono

/-- If `s ⊆ t` and `t` is bounded above, then so is `s`.  -/
theorem BddAbove.mono : ∀ {α : Type u} [inst : Preorder α] ⦃s t : Set α⦄, s ⊆ t → BddAbove t → BddAbove s := by sorry

The theorem `BddAbove.mono` states that for any type `α` with a preorder relation, if `s` is a subset of `t` and `t` is bounded above, then `s` is also bounded above. In other words, if every element of `s` is also an element of `t`, and `t` has an upper bound, then `s` must also have an upper bound.

If a preordered type `α` has a bounded subset `s` that is contained in a bounded subset `t`, then `s` is also bounded.


/-- In an ordered commutative monoid, if each factor `f i` of one finite product is less than or
equal to the corresponding factor `g i` of another finite product, then
`∏ i in s, f i ≤ ∏ i in s, g i`.  -/
theorem Finset.prod_le_prod' :
    ∀ {ι : Type u_1} {N : Type u_5} [inst : OrderedCommMonoid N] {f g : ι → N} {s : Finset ι},
      (∀ i ∈ s, f i ≤ g i) → (Finset.prod s fun i => f i) ≤ Finset.prod s fun i => g i :=
  by sorry

This theorem states that in an ordered commutative monoid, if each element of a finite product, computed using a function `f`, is less than or equal to the corresponding element in another finite product computed using a function `g`, then the total product of `f` elements is less than or equal to the total product of `g` elements. More formally, for any `i` in a finite set `s`, if `f i` is less than or equal to `g i`, then the product of all `f i` (denoted as `∏ i in s, f i`) is less than or equal to the product of all `g i` (denoted as `∏ i in s, g i`).

In an ordered commutative monoid, if for all elements `i` in a finite set `s`, `f i` is less than or equal to `g i`, then the product of all `f i` is less than or equal to the product of all `g i`.


/-- **Alias** of the forward direction of `Asymptotics.isLittleO_iff_forall_isBigOWith`.

---

Definition of `IsLittleO` in terms of `IsBigOWith`.  -/
theorem Asymptotics.IsLittleO.forall_isBigOWith :
    ∀ {α : Type u_1} {E : Type u_3} {F : Type u_4} [inst : Norm E] [inst_1 : Norm F] {f : α → E} {g : α → F}
      {l : Filter α}, f =o[l] g → ∀ ⦃c : ℝ⦄, 0 < c → Asymptotics.IsBigOWith c l f g :=
  by sorry

This theorem states that for two functions `f` and `g` on a type `α` with a filter `l` and for every real number `c` greater than zero, if `f` is little-o of `g` at `l` (denoted `f =o[l] g`), then `f` is also Big-O of `g` at `l` with constant `c` (denoted `Asymptotics.IsBigOWith c l f g`). In simpler terms, this means that if the function `f` eventually grows no faster than `g` for the filter `l`, then we can find a constant `c` such that `f` is bounded by `c * g` under the same conditions.

If `f =o[l] g` (little-o) then there exists a constant `c` such that `Asymptotics.IsBigOWith c l f g` (Big-O).


theorem Ordinal.bsup_le_iff :
    ∀ {o : Ordinal.{u}} {f : (a : Ordinal.{u}) → a < o → Ordinal.{max u v}} {a : Ordinal.{max u v}},
      Ordinal.bsup o f ≤ a ↔ ∀ (i : Ordinal.{u}) (h : i < o), f i h ≤ a :=
  by sorry

The theorem `Ordinal.bsup_le_iff` states that for any ordinal `o`, any function `f` that maps each ordinal less than `o` to an ordinal, and any ordinal `a`, the supremum of the family of ordinals generated by `f` is less than or equal to `a` if and only if for every ordinal `i` less than `o`, `f(i)` is less than or equal to `a`. In other words, the supremum is less than or equal to `a` precisely when all elements of the family are less than or equal to `a`.

For any ordinal `o`, function `f` mapping ordinals less than `o` to ordinals, and ordinal `a`, if `f(i) ≤ a` for all `i` less than `o`, then the supremum of the family generated by `f` is less than or equal to `a`.


theorem Fin.forall_fin_two : ∀ {p : Fin 2 → Prop}, (∀ (i : Fin 2), p i) ↔ p 0 ∧ p 1 := by sorry

This theorem, `Fin.forall_fin_two`, states that for any property `p` applicable to elements of the set `Fin 2` (which contains two elements represented as `0` and `1`), the property `p` holds for all elements of the `Fin 2` set if and only if the property `p` holds for `0` and the property `p` holds for `1`. In other words, if you can prove that `p` is true for both `0` and `1`, then you can assert that `p` is true for any element in `Fin 2`, and vice versa.

For any property `p`, `p` holds for all elements of `Fin 2` if and only if `p` holds for both `0` and `1` in `Fin 2`.


theorem Set.Nonempty.image2 :
    ∀ {α : Type u_1} {β : Type u_3} {γ : Type u_5} {f : α → β → γ} {s : Set α} {t : Set β},
      Set.Nonempty s → Set.Nonempty t → Set.Nonempty (Set.image2 f s t) :=
  by sorry

This theorem states that for any types `α`, `β`, and `γ`, and a binary function `f` from `α` and `β` to `γ`, if `s` is a non-empty set of type `α` and `t` is a non-empty set of type `β`, then the image of `s` and `t` under the function `f` (i.e., `Set.image2 f s t`) is also a non-empty set. This image set is formed by applying `f` to each pair of elements where the first element is from `s` and the second element is from `t`, and collecting the results. Therefore, as long as `s` and `t` have at least one element each, there will always be at least one result in the image set.

For any types `α`, `β`, and `γ`, and a binary function `f` from `α × β` to `γ`, the image of two non-empty sets `s ∈ Set α` and `t ∈ Set β` under `f` is a non-empty set. (Set.image2 preserves non- emptiness)


theorem nhdsSet_singleton : ∀ {X : Type u_1} [inst : TopologicalSpace X] {x : X}, nhdsSet {x} = nhds x := by sorry

This theorem states that for any given topological space `X` and any element `x` of `X`, the filter of neighborhoods of the singleton set containing `x` (`nhdsSet {x}`) is equivalent to the neighborhood filter at `x` (`nhds x`). In other words, the set of all neighborhoods of the singleton set `{x}` is the same as the set of all neighborhoods of the point `x` itself in the topological space `X`.

For any topological space X and element x ∈ X, the filter of neighborhoods of the singleton set {x} equals the neighborhood filter at x.


theorem Finset.coe_vadd_finset :
    ∀ {α : Type u_2} {β : Type u_3} [inst : DecidableEq β] [inst_1 : VAdd α β] (a : α) (s : Finset β),
      ↑(a +ᵥ s) = a +ᵥ ↑s :=
  by sorry

The theorem `Finset.coe_vadd_finset` states that for any given types `α` and `β`, provided that `β` has a decidable equality and `α` and `β` together form a vector addition structure (`VAdd α β`), for any given element `a` of type `α` and a finite set `s` of elements of type `β`, the set obtained by vector-adding `a` to each element of `s` and then converting to a set (`↑(a +ᵥ s)`) is the same as the set obtained by first converting `s` to a set and then vector-adding `a` to each element (`a +ᵥ ↑s`). In mathematical terms, this is saying that the vector addition operation commutes with the operation of converting a finite set to a set.

For any type `α` and `β` with decidable equality and a vector addition structure `VAdd α β`, the operation of converting a finite set `s` of type `β` to a set and then vector-adding an element `a` of type `α`, `a +ᵥ ↑s`, is equal to vector-adding `a` to each element of `s` and then converting the resulting finite set to a set, `↑(a +ᵥ s)`.


theorem Ordinal.le_bsup :
    ∀ {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.bsup o f :=
  by sorry

The theorem `Ordinal.le_bsup` states that for any ordinal `o`, for any function `f` that maps each ordinal less than `o` to another ordinal, and for any specific ordinal `i` which is less than `o`, the ordinal produced by applying the function `f` to `i` is less than or equal to the supremum of the family of ordinals generated by applying `f` to all ordinals less than `o`. This supremum is denoted by `Ordinal.bsup o f`.

For any ordinal `o` and function `f` mapping ordinals less than `o`, the image `f(i)` under `f` of each ordinal `i` less than `o` is less than or equal to the supremum `Ordinal.bsup o f` of all images under `f` of ordinals less than `o`.


theorem Mathlib.Data.Int.Cast.Lemmas._auxLemma.7 :
    ∀ {α : Type u_3} [inst : OrderedRing α] [inst_1 : Nontrivial α] {m n : ℤ}, (↑m ≤ ↑n) = (m ≤ n) := by sorry

This theorem, named `Mathlib.Data.Int.Cast.Lemmas._auxLemma.7`, states that for any type `α` which is part of an ordered ring and is nontrivial, and for any two integers `m` and `n`, the inequality `m` less than or equal to `n` holds if and only if the cast of `m` to type `α` is less than or equal to the cast of `n` to type `α`. In other words, the ordering of `m` and `n` remains the same when they are cast to another type in an ordered ring.

For any nontrivial ordered ring type `α`, if `m` ≤ `n` holds in the integers, then the casts `α(m)` and `α(n)` satisfy `α(m) ≤ α(n)`.


Filter.Tendsto.norm

theorem Filter.Tendsto.norm :
    ∀ {α : Type u_3} {E : Type u_6} [inst : SeminormedAddGroup E] {a : E} {l : Filter α} {f : α → E},
      Filter.Tendsto f l (nhds a) → Filter.Tendsto (fun x => ‖f x‖) l (nhds ‖a‖) :=
  by sorry

This theorem, `Filter.Tendsto.norm`, states that for any seminormed add group `E` and any filter `l` in an arbitrary type `α`, if a function `f : α → E` tends to a value `a` in `E` as `l` tends to infinity, then the norm of `f`, i.e. `‖f x‖`, tends to the norm of `a`, `‖a‖`, as `l` also tends to infinity. This is a formalization of the common mathematical fact that in normed vector spaces, the limit of the norm of a sequence of vectors is equal to the norm of the limit of the sequence, assuming the limit exists.

If a function from a filter in a seminormed add group to the same group tends to a limit in the group, then the sequence of norms of the function's values tends to the norm of the limit.


theorem Polynomial.degree_eq_zero_of_isUnit :
    ∀ {R : Type u} [inst : Semiring R] [inst_1 : NoZeroDivisors R] {p : Polynomial R} [inst_2 : Nontrivial R],
      IsUnit p → Polynomial.degree p = 0 :=
  by sorry

The theorem `Polynomial.degree_eq_zero_of_isUnit` states that for any semiring `R` which does not contain zero divisors and is nontrivial, if a polynomial `p` over `R` is a unit (meaning it has a multiplicative inverse), then the degree of `p` is zero. In other words, a polynomial in such a ring is a unit if and only if it is a nonzero constant polynomial.

In a semiring without zero divisors and containing only the multiplicative identity and units, every unit polynomial has degree zero.


theorem Finset.image₂_inter_subset_right :
    ∀ {α : Type u_1} {β : Type u_3} {γ : Type u_5} [inst : DecidableEq γ] {f : α → β → γ} {s : Finset α}
      {t t' : Finset β} [inst_1 : DecidableEq β],
      Finset.image₂ f s (t ∩ t') ⊆ Finset.image₂ f s t ∩ Finset.image₂ f s t' :=
  by sorry

The theorem `Finset.image₂_inter_subset_right` states that for any types `α`, `β`, and `γ`, and for any binary function `f` from `α` and `β` to `γ`, if we have a set `s` of `α` and two sets `t` and `t'` of `β`, then the image of the function `f` over the set `s` and the intersection of `t` and `t'` is a subset of the intersection of the images of the function `f` over `s` and `t`, and over `s` and `t'` respectively. Here, `DecidableEq γ` and `DecidableEq β` denote that equality is decidable for the types `γ` and `β`.
In mathematical notation, it's saying that $f(s, t \cap t') \subseteq f(s, t) \cap f(s, t')$.

For any types `α`, `β`, and `γ` with decidable equality, and for any binary function `f` from `α` and `β` to `γ`, if `s` is a set of `α` and `t` and `t'` are sets of `β`, then `f(s, t ∩ t') ⊆ f(s, t) ∩ f(s, t')`.


theorem Mathlib.Order.Filter.AtTopBot._auxLemma.4 :
    ∀ {α : Type u_3} [inst : SemilatticeSup α] [inst_1 : Nonempty α] {p : α → Prop},
      (∀ᶠ (x : α) in Filter.atTop, p x) = ∃ a, ∀ b ≥ a, p b :=
  by sorry

The theorem `Mathlib.Order.Filter.AtTopBot._auxLemma.4` states that for any type `α` equipped with a semilattice sup (an algebraic structure with a binary operation that is associative, commutative, and idempotent) and known to be nonempty, and for any property `p` on elements of `α`, the property `p` holds eventually at the limit towards infinity (`Filter.atTop`) if and only if there exists an element `a` in `α` such that `p` holds for all elements `b` greater or equal to `a`.

For any semilattice `α` with a nonempty sup-domain and property `p` on `α`, `p` holds eventually at the limit towards infinity if and only if there exists an element `a` such that `p(b)` holds for all `b ≥ a`.


theorem MeasureTheory.StronglyMeasurable.prod_mk :
    ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {m : MeasurableSpace α} [inst : TopologicalSpace β]
      [inst_1 : TopologicalSpace γ] {f : α → β} {g : α → γ},
      MeasureTheory.StronglyMeasurable f →
        MeasureTheory.StronglyMeasurable g → MeasureTheory.StronglyMeasurable fun x => (f x, g x) :=
  by sorry

The theorem `MeasureTheory.StronglyMeasurable.prod_mk` states that for any two functions `f` and `g`, where `f` maps a measurable space `α` to a topological space `β` and `g` maps the same measurable space `α` to another topological space `γ`, if both `f` and `g` are strongly measurable (i.e., each is the limit of a sequence of simple functions), then the function that maps `x` in `α` to the ordered pair `(f x, g x)` is also strongly measurable.

If `f : α → β` and `g : α → γ` are strongly measurable functions from a measurable space `α` to topological spaces `β` and `γ`, respectively, then the function `x ↦ (f x, g x)` from `α` to `β × γ` is also strongly measurable.


theorem BoxIntegral.Prepartition.IsPartition.iUnion_eq :
    ∀ {ι : Type u_1} {I : BoxIntegral.Box ι} {π : BoxIntegral.Prepartition I},
      BoxIntegral.Prepartition.IsPartition π → BoxIntegral.Prepartition.iUnion π = ↑I :=
  by sorry

The theorem `BoxIntegral.Prepartition.IsPartition.iUnion_eq` states that for any type `ι`, any box `I` of type `ι`, and any prepartition `π` of `I`, if `π` is a partition of `I` (that is, if the boxes of `π` cover the whole `I`), then the union of the boxes of `π` (denoted by `BoxIntegral.Prepartition.iUnion π`) is exactly equal to `I` itself.

For any type `ι`, box `I` of type `ι`, and prepartition `π` of `I` that covers `I`, the union of the boxes in `π` equals `I`.


theorem sup_sdiff : ∀ {α : Type u_2} [inst : GeneralizedCoheytingAlgebra α] {a b c : α}, (a ⊔ b) \ c = a \ c ⊔ b \ c :=
  by sorry

This theorem states that for any type α that has been declared an instance of a Generalized Coheyting Algebra, the supremum (also known as the join or least upper bound, denoted by ⊔) of two elements `a` and `b` subtracted by another element `c` (denoted by \) is equal to the supremum of `a` subtracted by `c` and `b` subtracted by `c`. In other words, the difference operation distributes over the supremum or join operation in a Generalized Coheyting Algebra.

In a Generalized Coheting Algebra, the supremum of (a - c) and (b - c) equals (a \ b) for any elements a, b, and c.


theorem CategoryTheory.Limits.coequalizer.condition :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} (f g : X ⟶ Y)
      [inst_1 : CategoryTheory.Limits.HasCoequalizer f g],
      CategoryTheory.CategoryStruct.comp f (CategoryTheory.Limits.coequalizer.π f g) =
        CategoryTheory.CategoryStruct.comp g (CategoryTheory.Limits.coequalizer.π f g) :=
  by sorry

The theorem `CategoryTheory.Limits.coequalizer.condition` states that for any category `C` and any two morphisms `f` and `g` from object `X` to `Y` in `C` such that `f` and `g` have a coequalizer, the composition of `f` with the coequalizer projection (denoted `CategoryTheory.Limits.coequalizer.π f g`) is equal to the composition of `g` with the coequalizer projection. In other words, the diagram involving `f`, `g`, and the coequalizer projection commutes. This is a fundamental property of coequalizers in category theory.

For any category `C`, given morphisms `f` and `g` from object `X` to `Y` with coequalizer `h : Y -> Z`, we have `f ∘ h = g ∘ h`.


theorem multiplicity.eq_coe_iff :
    ∀ {α : Type u_1} [inst : Monoid α] [inst_1 : DecidableRel fun x x_1 => x ∣ x_1] {a b : α} {n : ℕ},
      multiplicity a b = ↑n ↔ a ^ n ∣ b ∧ ¬a ^ (n + 1) ∣ b :=
  by sorry

The theorem `multiplicity.eq_coe_iff` states that for a given type `α` forming a monoid, for any two elements `a` and `b` of this type, and a natural number `n`, the multiplicity of `a` in `b` equals `n` if and only if `a` raised to the power of `n` divides `b` and `a` raised to `n + 1` does not divide `b`. In other words, `n` is the largest exponent such that `a^n` divides `b` but `a^(n+1)` does not.

For any monoid type `α`, natural number `n`, and elements `a`, `b` of `α`, `a` raised to the power `n` divides `b` and `a` raised to the power `(n+1)` does not divide `b` if and only if the multiplicity of `a` in `b` equals `n`.


theorem Set.singleton_union : ∀ {α : Type u} {a : α} {s : Set α}, {a} ∪ s = insert a s := by sorry

The theorem `Set.singleton_union` states that for any given type `α`, an element `a` of type `α`, and a set `s` of type `Set α`, the union of the singleton set containing `a` (denoted as `{a}`) and the set `s` is equal to the set obtained by inserting `a` into `s`. In other words, the union of a singleton set and another set can be created by simply adding the single element to the other set.

For any type `α`, set `s` of type `Set α`, and element `a` of type `α`, `{a} ∪ s = s.insert a`.


theorem tsub_lt_self :
    ∀ {α : Type u_1} [inst : CanonicallyLinearOrderedAddCommMonoid α] [inst_1 : Sub α] [inst_2 : OrderedSub α] {a b : α}
      [inst_3 : ContravariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1], 0 < a → 0 < b → a - b < a :=
  by sorry

The theorem `tsub_lt_self` states that for any type `α` that is a canonically linearly ordered additive commutative monoid with subtraction and an ordered subtraction operation, given two elements `a` and `b` of type `α` (where `a`, `b` are positive), the difference `a - b` is less than `a`. This is under the condition that `α` is a contravariant class with respect to the addition and less-than-or-equal-to operations. Essentially, this theorem is saying that subtracting a positive value from a number results in a smaller number.

For any additively commutative, canonically linearly ordered monoid `α` with subtraction and the contravariant property with respect to addition and order, given `a`, `b` in `α` with `a > b > 0`, we have `a - b < a`.


theorem Real.rpow_lt_rpow : ∀ {x y z : ℝ}, 0 ≤ x → x < y → 0 < z → x ^ z < y ^ z := by sorry

This theorem states that for any real numbers `x`, `y`, and `z`, if `x` is non-negative, `x` is less than `y`, and `z` is positive, then `x` raised to the power of `z` is less than `y` raised to the power of `z`. In other words, if you have two real numbers where one is smaller than the other and a positive exponent, the exponentiation of the smaller number is also smaller than the exponentiation of the larger number.

For any real numbers `x` with `x ≥ 0`, `y` with `x < y`, and `z` with `z > 0`, we have `x^z < y^z`.


theorem Mathlib.Order.Basic._auxLemma.25 :
    ∀ {α : Type u} [inst : LE α] {p : α → Prop} {x y : α} {hx : p x} {hy : p y},
      ({ val := x, property := hx } ≤ { val := y, property := hy }) = (x ≤ y) :=
  by sorry

This theorem, `Mathlib.Order.Basic._auxLemma.25`, states that for any type `α` with a less than or equal to (`≤`) ordering and a property `p` acting on elements of `α`, and given two elements `x` and `y` of `α` for which `p` holds (that is, `p x` and `p y` are true), then the inequality of the pairs `{ val := x, property := hx }` and `{ val := y, property := hy }` (where `hx` and `hy` denote the truth of `p` for `x` and `y` respectively) is equivalent to the inequality `x ≤ y`. In essence, it asserts that the order of the pairs is determined solely by the order of their value components.

For any type `α` with a total ordering and property `p`, if `x ≤ y` and `p x` hold, then `{x, p x} ≤ {y, p y}`.


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

This theorem states that in any category `C` (of type `u` and category structure `v`) which has zero morphisms, for any two objects `X` and `Y` in the opposite category `Cᵒᵖ`, the unop of the zero morphism is zero. Here, `unop` is an operation that switches an object or morphism from the opposite category back to the original category.

In any category with zero morphisms, the unop of the zero morphism between any two objects is the identity morphism. (Note: In the context of the given theorem, "unop of the zero morphism" means the morphism obtained by switching the zero morphism from the opposite category back to the original category.)


theorem Finset.Nonempty.image₂ :
    ∀ {α : Type u_1} {β : Type u_3} {γ : Type u_5} [inst : DecidableEq γ] {f : α → β → γ} {s : Finset α} {t : Finset β},
      s.Nonempty → t.Nonempty → (Finset.image₂ f s t).Nonempty :=
  by sorry

This theorem states that for any types `α`, `β`, and `γ` with decidable equality on `γ`, and any binary function `f` from `α` and `β` to `γ`, if the finsets `s` and `t` (of types `α` and `β` respectively) are nonempty, then the image of the binary function `f` applied to `s` and `t` (i.e., `Finset.image₂ f s t`) is also nonempty. This essentially means that if we have nonempty sets of `α` and `β`, and a function that can combine elements of `α` and `β` to produce elements of `γ`, we are guaranteed to also have a nonempty set of `γ` as a result.

For decidably equated types `α`, `β`, and `γ`, if `f` is a binary function from `α × β` to `γ` and `s` and `t` are nonempty finsets of `α` and `β` respectively, then `Finset.image₂ f s t` is nonempty.


theorem zpow_add₀ :
    ∀ {G₀ : Type u_1} [inst : GroupWithZero G₀] {a : G₀}, a ≠ 0 → ∀ (m n : ℤ), a ^ (m + n) = a ^ m * a ^ n := by sorry

This theorem states that for any type `G₀` that has a group with zero structure, given any element `a` of this type that is not zero, for any two integers `m` and `n`, the power of `a` to the sum of `m` and `n` is equal to the product of `a` to the power of `m` and `a` to the power of `n`. This is effectively stating the rule of indices for exponents: $a^{m+n} = a^m \cdot a^n$, in the setting of a group with zero.

In a group with zero, the power of a non-zero element equals the product of its powers with respect to individual exponents. ($(a^{m+n})=(a^m)\cdot(a^n)$)


theorem Mathlib.Data.ENat.Basic._auxLemma.5 : ∀ (a : ℕ), (↑a = ⊤) = False := by sorry

This theorem states that for any natural number `a`, the proposition that the coerced value of `a` is equal to infinity (`⊤`) is always false. In other words, no natural number can equal infinity when typecast to an extended natural number (ENat) in Lean 4.

For all natural numbers `a`, the coerced value `a` to ENat is not equal to infinity (⊤).


/-- Given any distinguished triangle `T`, then we know `T.inv_rotate` is also distinguished.
 -/
theorem CategoryTheory.Pretriangulated.inv_rot_of_distTriang :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroObject C]
      [inst_2 : CategoryTheory.HasShift C ℤ] [inst_3 : CategoryTheory.Preadditive C]
      [inst_4 : ∀ (n : ℤ), CategoryTheory.Functor.Additive (CategoryTheory.shiftFunctor C n)]
      [hC : CategoryTheory.Pretriangulated C],
      ∀ T ∈ CategoryTheory.Pretriangulated.distinguishedTriangles,
        CategoryTheory.Pretriangulated.Triangle.invRotate T ∈ CategoryTheory.Pretriangulated.distinguishedTriangles :=
  by sorry

This theorem states that for any category `C` that has a zero object, a shift operation, is preadditive, and pretriangulated, and for any integer `n` where the shift functor is additive, if a triangle `T` is distinguished in the context of category `C`, then the inverse rotation of triangle `T` is also a distinguished triangle in the same category.

In mathematical terms, this theorem concerns the properties of distinguished triangles in pretriangulated categories: specifically, it asserts that the 'inverse rotation' operation (which is a certain transformation applied to the triangle) preserves the property of being distinguished.

In a pretriangulated, preadditive category with a zero object and additive shift functor, the inverse rotation of a distinguished triangle is also a distinguished triangle.


theorem Nat.smul_one_eq_coe : ∀ {R : Type u_9} [inst : Semiring R] (m : ℕ), m • 1 = ↑m := by sorry

This theorem states that for any natural number `m` and any semiring `R`, the result of scaling (`smul`) the number `1` by `m` is equivalent to the coersion of `m` into `R`. Essentially, it emphasizes that in the context of semirings, multiplying `1` by any natural number `m` yields the same value as if `m` was simply converted into the type of the semiring.

For any semiring R and natural number m, 1 × m = R.coerce m.


theorem Filter.principal_empty : ∀ {α : Type u}, Filter.principal ∅ = ⊥ := by sorry

This theorem states that for any type `α`, the principal filter of the empty set is equivalent to the bottom filter. In other words, the collection of all supersets of the empty set forms the most restrictive or trivial filter, often denoted by `⊥`, in the context of filters in set theory.

The principal filter of the empty set is equal to the bottom filter for any type `α`.


theorem one_lt_inv : ∀ {α : Type u_2} [inst : LinearOrderedSemifield α] {a : α}, 0 < a → a < 1 → 1 < a⁻¹ := by sorry

This theorem, `one_lt_inv`, states that for any type `α` which is an instance of a `LinearOrderedSemifield` -- a field of numbers where linear ordering is defined -- if a particular variable `a` of the given type `α` is positive (greater than 0) and also less than 1, then the reciprocal of `a` (denoted by `a⁻¹` in Lean 4) is greater than 1.

If `α` is a LinearOrderedSemifield type and `0 < a < 1` in `α`, then `1 < a⁻¹`.


theorem Mathlib.Order.Lattice._auxLemma.1 : ∀ {α : Type u} [inst : SemilatticeSup α] {a b : α}, (a ≤ a ⊔ b) = True := by
  sorry

This theorem, from the Mathlib library in Lean, states that for any type `α` that is a semilattice with a supremum operation, and for any two elements `a` and `b` of this type, it is always true that `a` is less than or equal to the supremum of `a` and `b`. In mathematical terms, this theorem says that for all `a`, `b` in a given semilattice, we always have $a \leq a \vee b$, where $\vee$ denotes the supremum operation.

In any semilattice with supremum operation, for all elements `a` and `b`, we have `a ≤ a ∨ b` (or equivalently, `a ∧ (a ∨ b) = a`).


theorem MulOpposite.op_surjective : ∀ {α : Type u_1}, Function.Surjective MulOpposite.op := by sorry

The theorem `MulOpposite.op_surjective` states that for any type `α`, the function `MulOpposite.op` is surjective. This means that for every element of the opposite multiplicative group of `α` (denoted `αᵐᵒᵖ`), there is an element in `α` such that when the `MulOpposite.op` function is applied to it, we obtain the former element from the opposite multiplicative group. In other words, every element of the opposite multiplicative group can be reached by applying the `MulOpposite.op` function to some element of `α`.

For every element in the opposite multiplicative group of type `α`, there exists an element in `α` that maps to it under the `MulOppositive.op` function.


theorem Real.tan_arctan : ∀ (x : ℝ), Real.tan (Real.arctan x) = x := by sorry

This theorem states that for all real numbers `x`, the tangent of the arctangent of `x` equals `x`. In other words, the tangent function and the arctangent function are inverses of each other when composed in the order tan(arctan(x)). This is similar to the familiar trigonometric identity that the tangent of the arctangent of a number returns the original number.

The theorem asserts that for all real numbers `x`, the function composition tan(arctan(x)) equals `x`.


Set.Subsingleton.pairwise

theorem Set.Subsingleton.pairwise :
    ∀ {α : Type u_1} {s : Set α}, Set.Subsingleton s → ∀ (r : α → α → Prop), Set.Pairwise s r := by sorry

This theorem states that for any set `s` of a certain type `α`, if `s` is a subsingleton (meaning it contains at most one element), then any relation `r` holds pairwise on the set `s`. In other words, for any two distinct elements `x` and `y` in `s`, `r(x, y)` holds true. This is trivially true as there can't be two distinct elements in a subsingleton set.

If `s` is a subsingleton set, then for any relation `r` on `s`, `r(x, y)` holds for all distinct elements `x` and `y` in `s`.


theorem WellFounded.min_mem :
    ∀ {α : Type u_1} {r : α → α → Prop} (H : WellFounded r) (s : Set α) (h : Set.Nonempty s),
      WellFounded.min H s h ∈ s :=
  by sorry

The theorem `WellFounded.min_mem` states that for any type `α`, binary relation `r` on `α`, and a set `s` of type `α`, if `r` is a well-founded relation (i.e., there are no infinite decreasing sequences) and `s` is a nonempty set, then the minimal element of `s` under the relation `r` (as provided by `WellFounded.min`) is an element of `s`. This asserts the existence of the minimal element in the set `s` under the well-founded relation `r`.

If `α` is a type, `r` is a well-founded relation on `α`, and `s ≠ ∅` is a subset of `α`, then there exists an `x ∈ s` such that for all `y ∈ s`, `x r y`.


theorem Associates.mk_dvd_mk :
    ∀ {α : Type u_1} [inst : CommMonoid α] {a b : α}, Associates.mk a ∣ Associates.mk b ↔ a ∣ b := by sorry

The theorem `Associates.mk_dvd_mk` states that for any commutative monoid `α` and any elements `a` and `b` of `α`, the element `a` divides `b` if and only if the associate of `a` divides the associate of `b`. Here, the associate of an element from a monoid is obtained using the canonical quotient map, `Associates.mk`. In other words, the divisibility relationship between `a` and `b` is preserved when they are mapped into the associates of `α`.

For all commutative monoids `α`, elements `a` and `b` in `α`, if `a` divides `b`, then the associates of `a` and `b` are related by the divisibility relation. (i.e., `Associates.mk a` divides `Associates.mk b`).


theorem Nat.lt_add_one_iff : ∀ {m n : ℕ}, m < n + 1 ↔ m ≤ n := by sorry

This theorem, `Nat.lt_add_one_iff`, states that for any two natural numbers `m` and `n`, `m` is less than `n` plus one if and only if `m` is less than or equal to `n`. It essentially provides a relationship between the "less than" and "less than or equal to" operations in the context of natural numbers, particularly when dealing with the incrementation of a number.

For natural numbers `m` and `n`, `m` is less than `n` + 1 if and only if `m` is less than or equal to `n`.


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

This theorem states that for any type `X` that forms a topological space, the closure of the empty set is also the empty set. In other words, the smallest closed set that contains the empty set, in the context of any given topological space, is the empty set itself.

In any topological space, the closure of the empty set is the empty set.


theorem Mathlib.GroupTheory.Subsemigroup.Basic._auxLemma.2 :
    ∀ {M : Type u_1} [inst : Add M] {s : AddSubsemigroup M} {x : M}, (x ∈ s.carrier) = (x ∈ s) := by sorry

This theorem states that for any type `M` equipped with addition (notated as `Add M`), for any additive subsemigroup `s` of `M` and for any element `x` of `M`, the property of `x` being in the carrier of `s` is equivalent to `x` being in `s` itself. Here, a carrier refers to the set of all elements of the subsemigroup. In other words, this theorem proves that there's no difference between saying an element belongs to the carrier of a subsemigroup and saying it belongs to the subsemigroup directly, in the context of additive semigroups.

For any additive subsemigroup `s` of a type `M` with addition, the carrier of `s` equals `s` itself.


theorem CategoryTheory.Limits.coprod.inl_map :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {W X Y Z : C}
      [inst_1 : CategoryTheory.Limits.HasBinaryCoproduct W X] [inst_2 : CategoryTheory.Limits.HasBinaryCoproduct Y Z]
      (f : W ⟶ Y) (g : X ⟶ Z),
      CategoryTheory.CategoryStruct.comp CategoryTheory.Limits.coprod.inl (CategoryTheory.Limits.coprod.map f g) =
        CategoryTheory.CategoryStruct.comp f CategoryTheory.Limits.coprod.inl :=
  by sorry

The theorem `CategoryTheory.Limits.coprod.inl_map` states that in any category `C`, given two binary coproducts `W ⨿ X` and `Y ⨿ Z`, and morphisms `f : W ⟶ Y` and `g : X ⟶ Z`, the composition of the inclusion map from the first component of the coproduct (`coprod.inl`) with the map induced by `f` and `g` on the coproducts (`coprod.map f g`) is equal to the composition of `f` with the inclusion map from the first component of the coproduct. This is essentially a property that relates the inclusion of elements into the coproduct and the mapping of the coproducts under given morphisms.

In any category, the composition of the inclusion map of the first component of a binary coproduct with the map induced by two morphisms between the coproducts is equal to the composition of those morphisms with the inclusion map of the first component.