theorem Set.insert_nonempty : ∀ {α : Type u} (a : α) (s : Set α), Set.Nonempty (insert a s) := by sorry

The theorem `Set.insert_nonempty` states that for any given type `α` and any element `a` of this type, if we insert `a` into a set `s` of type `α`, the resulting set is nonempty. In other words, inserting any element into a set guarantees non-emptiness of the resulting set, regardless of the original state (empty or nonempty) of the set. This theorem applies to all types, making it a general property of sets in the context of Lean 4.

For any type `α` and element `a` of `α`, the set `a :: s` is nonempty, where `s` is a set of type `α`.


theorem CategoryTheory.Limits.limit.lift_π_assoc :
    ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] {C : Type u} [inst_1 : CategoryTheory.Category.{v, u} C]
      {F : CategoryTheory.Functor J C} [inst_2 : CategoryTheory.Limits.HasLimit F] (c : CategoryTheory.Limits.Cone F)
      (j : J) {Z : C} (h : F.obj j ⟶ Z),
      CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.limit.lift F c)
          (CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.limit.π F j) h) =
        CategoryTheory.CategoryStruct.comp (c.π.app j) h :=
  by sorry

The theorem `CategoryTheory.Limits.limit.lift_π_assoc` states that for any category `J`, any category `C`, any functor `F` from `J` to `C`, any cone `c` over `F`, any object `j` in `J`, and any morphism `h` from `F.obj j` to any object `Z` in `C`, the composition of the morphism `lift` from the cone point of `c` to the limit of `F` with the composition of the projection morphism from the limit of `F` to `F.obj j` and `h` is equal to the composition of the morphism from the cone point of `c` to `F.obj j` and `h`.

In simpler terms, it says that in a category with limits, composing the lift from a cone to the limit with a projection from the limit gives the same result as applying the morphism from the cone directly to the object.

For any cone over a functor and any morphism, composing the lift from the cone point to the limit with the composition of the projection from the limit and the morphism is equal to the composition of the morphism with the lift from the cone point to the object in the domain of the functor.


theorem iff_not_comm : ∀ {a b : Prop}, (a ↔ ¬b) ↔ (b ↔ ¬a) := by sorry

This theorem states that for any two propositions `a` and `b`, the statement "if and only if `a` then not `b`" is equivalent to the statement "if and only if `b` then not `a`". In other words, it is asserting that the logical relationship between `a` and `b` is symmetric, such that if `a` implies that `b` is not true, then `b` must also imply that `a` is not true, and vice versa.

The theorem asserts that for all propositions `a` and `b`, the logical equivalence `(a ↔ ¬ b) ↔ (b ↔ ¬ a)` holds.


theorem Polynomial.derivative_X : ∀ {R : Type u} [inst : Semiring R], Polynomial.derivative Polynomial.X = 1 := by sorry

The theorem `Polynomial.derivative_X` states that for any type `R` that is a semiring, the derivative of the polynomial `Polynomial.X` is equal to 1. In other words, taking the formal derivative of the polynomial variable (also known as indeterminate), which is simply the polynomial \(X\), yields 1. This corresponds to the well-known calculus rule that the derivative of \(x\) with respect to \(x\) is 1.

The derivative of the polynomial indeterminate (Polynomial.X) is equal to 1, for any semiring type R.


HasSubset.Subset.eventuallyLE

theorem HasSubset.Subset.eventuallyLE : ∀ {α : Type u_1} {l : Filter α} {s t : Set α}, s ⊆ t → s ≤ᶠ[l] t := by sorry

This theorem states that for any type `α`, any filter `l` on `α`, and any two sets `s` and `t` of `α`, if `s` is a subset of `t`, then `s` is eventually less than or equal to `t` with respect to the filter `l`. Here, "eventually less than or equal to" is denoted by `≤ᶠ[l]` and represents a concept from the theory of filters in topology.

For any filter `l` on type `α`, if `s` is a subset of `t` in `α`, then `s ≤ᶠ[l] t` holds.


theorem Finsupp.embDomain_apply :
    ∀ {α : Type u_1} {β : Type u_2} {M : Type u_5} [inst : Zero M] (f : α ↪ β) (v : α →₀ M) (a : α),
      (Finsupp.embDomain f v) (f a) = v a :=
  by sorry

The theorem `Finsupp.embDomain_apply` states that for any types `α`, `β`, and `M` where `M` has a zero, and for any function `f` that embeds `α` into `β` and for any finitely supported function `v` from `α` to `M`, the value of the function `Finsupp.embDomain f v` at `f a` is equal to `v a` for any `a` in `α`. In other words, the value of `v a` is transported to `f a` in the finitely supported function created by `Finsupp.embDomain`.

For any function `f: α -> β` embedding `α` into a type `β` with a zero, and any finitely supported function `v: α -> M` from a type `α` to a type `M` with a zero, `Finsupp.embDomain f v a = v a` for all `a` in `α`.


theorem le_iSup₂_of_le :
    ∀ {α : Type u_1} {ι : Sort u_5} {κ : ι → Sort u_7} [inst : CompleteLattice α] {a : α} {f : (i : ι) → κ i → α}
      (i : ι) (j : κ i), a ≤ f i j → a ≤ ⨆ i, ⨆ j, f i j :=
  by sorry

This theorem states that for any type `α` with a complete lattice structure, an indexed type `ι`, and a dependent type `κ` indexed by `ι`, given a function `f` that takes an index `i` from `ι` and a value `j` from the dependent type `κ i` and produces a value in `α`, if a certain value `a` in `α` is less than or equal to the result of applying `f` to `i` and `j`, then `a` is also less than or equal to the supremum (the least upper bound) over all `i` and `j` of `f` applied to `i` and `j`. This is a property related to the order structure of the complete lattice.

For any complete lattice `α` and dependent type `κ` indexed by `ι`, if `a ≤ f i j` for all `i ∈ ι` and `j ∈ κ i`, then `a ≤ sup (i, j) → f i j`.


theorem disjoint_self : ∀ {α : Type u_1} [inst : PartialOrder α] [inst_1 : OrderBot α] {a : α}, Disjoint a a ↔ a = ⊥ :=
  by sorry

The theorem `disjoint_self` states that for any partially ordered set which also has the bottom element, an element `a` is disjoint with itself if and only if `a` is the bottom element. This theorem is applicable in the context of lattices where the infimum (greatest lower bound) might not be unique or requires additional decidability conditions. This definition generalizes the concept of disjoint sets in set theory, seen as elements of the subset lattice.

In a partially ordered set with a bottom element, an element is disjoint with itself if and only if it is the bottom element.


theorem EuclideanDomain.div_zero : ∀ {R : Type u} [inst : EuclideanDomain R] (a : R), a / 0 = 0 := by sorry

This theorem states that in a Euclidean domain `R`, the division of any element `a` by zero is equal to zero. In other words, for all elements `a` in the Euclidean domain `R`, `a / 0` equals `0`. This rule is familiar from conventional number systems, but here it's explicitly stated for any Euclidean domain, which is a type of mathematical structure that generalizes some properties of the integers.

In a Euclidean domain, the division of any element by zero is equal to the additive identity (zero).


theorem Finsupp.erase_ne :
    ∀ {α : Type u_1} {M : Type u_5} [inst : Zero M] {a a' : α} {f : α →₀ M}, a' ≠ a → (Finsupp.erase a f) a' = f a' :=
  by sorry

The theorem `Finsupp.erase_ne` states that for any types `α` and `M` (where `M` has an instance of zero), given any `a` and `a'` of type `α` and a finitely supported function `f` from `α` to `M`, if `a'` is not equal to `a`, then the value of the function `Finsupp.erase a f` at `a'` is equal to the value of the function `f` at `a'`. In other words, erasing `a` from the function `f` does not change the value of `f` at any other points.

For any type `α` and `M` with a zero instance, and any finitely supported function `f` from `α` to `M`, `Finsupp.erase a f a' = f a'` for all `a ≠ a'` in `α`.


theorem Complex.ofReal_cosh : ∀ (x : ℝ), ↑(Real.cosh x) = Complex.cosh ↑x := by sorry

This theorem states that for every real number `x`, the complex number that is the result of mapping `x` through the real hyperbolic cosine function `Real.cosh` and then considering this result as a complex number (done by `↑(Real.cosh x)`) is equal to the complex hyperbolic cosine of `x` considered as a complex number (`Complex.cosh ↑x`). In other words, the real hyperbolic cosine `Real.cosh` function, when lifted to the complex numbers, coincides with the `Complex.cosh` function on the real line.

For every real number `x`, `Complex.cosh (Real.toComplex x) = ↑(Real.cosh x)`.


/-- **Alias** of the reverse direction of `Asymptotics.isBigOWith_iff`.

---

Definition of `IsBigOWith`. We record it in a lemma as `IsBigOWith` is irreducible.  -/
theorem Asymptotics.IsBigOWith.of_bound :
    ∀ {α : Type u_1} {E : Type u_3} {F : Type u_4} [inst : Norm E] [inst_1 : Norm F] {c : ℝ} {f : α → E} {g : α → F}
      {l : Filter α}, (∀ᶠ (x : α) in l, ‖f x‖ ≤ c * ‖g x‖) → Asymptotics.IsBigOWith c l f g :=
  by sorry

The theorem `Asymptotics.IsBigOWith.of_bound` states that for any types `α`, `E`, and `F`, any normed spaces `E` and `F`, any real number `c`, any functions `f: α → E` and `g: α → F`, and any filter `l` on `α`, if it is true that, eventually for `l`, the norm of `f(x)` is less than or equal to `c` times the norm of `g(x)`, then `f` is big-O of `g` with constant `c` at `l`, in the sense of the Landau notation `IsBigOWith`. This means that `‖f‖ / ‖g‖` is eventually bounded by `c`, modulo division by zero issues that are avoided by this definition.

If for all x in the filter l, the norm of f(x) is bounded above by c times the norm of g(x), then f is big-O of g with constant c at filter l.


theorem convexHull_min :
    ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : OrderedSemiring 𝕜] [inst_1 : AddCommMonoid E] [inst_2 : Module 𝕜 E]
      {s t : Set E}, s ⊆ t → Convex 𝕜 t → (convexHull 𝕜) s ⊆ t :=
  by sorry

The theorem `convexHull_min` states that for any ordered semiring `𝕜` and any additively commutative monoid `E` that is a `𝕜`-module, and for any two sets `s` and `t` of type `E`, if `s` is a subset of `t` and `t` is a convex set, then the convex hull of `s` is also a subset of `t`. In other words, the minimal convex set that includes `s` is contained within any larger convex set `t` that also contains `s`.

For any ordered semiring 𝕜 and additively commutative monoid E that is a 𝕜-module, if s is a subset of the convex set t in E, then the convex hull of s is included in t.


theorem Set.smul_set_empty : ∀ {α : Type u_2} {β : Type u_3} [inst : SMul α β] {a : α}, a • ∅ = ∅ := by sorry

This theorem states that for any type `α` and `β` with a scalar multiplication (`SMul`) operation defined, when we multiply an empty set (`∅`) of type `β` by any element (`a`) of type `α`, the result is also the empty set (`∅`). This is analogous to multiplying zero by any number in normal arithmetic; the result is always zero.

For any types `α` and `β` with a scalar multiplication operation, the empty set of type `β` is multiplicatively identic to the zero element of type `α`, i.e., `∅ * a = ∅` for all `a : α`.


Set.Finite.biUnion

theorem Set.Finite.biUnion :
    ∀ {α : Type u} {ι : Type u_1} {s : Set ι},
      Set.Finite s → ∀ {t : ι → Set α}, (∀ i ∈ s, Set.Finite (t i)) → Set.Finite (⋃ i ∈ s, t i) :=
  by sorry

The theorem `Set.Finite.biUnion` states that for any type `α` and index type `ι`, given a set `s` of index type `ι`, if `s` is finite and for any index `i` in `s`, the set `t i` (where `t` is a function from `ι` to sets of `α`) is also finite, then the union of the sets `t i` over all `i` in `s` is finite as well. In mathematical terms, if we have a finite set of indices and each index corresponds to a finite set, then the union of all these finite sets is also a finite set.

If `ι` is a finite type and for each `i` in `ι`, `t i` is a finite set, then the union of `{ti : i ∈ ι}` is finite.


/-- If `J` and `K` are equivalent, then if `J` is connected then `K` is as well.  -/
theorem CategoryTheory.isConnected_of_equivalent :
    ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] {K : Type u₂}
      [inst_1 : CategoryTheory.Category.{v₂, u₂} K],
      (J ≌ K) → ∀ [inst : CategoryTheory.IsConnected J], CategoryTheory.IsConnected K :=
  by sorry

The theorem states that in the context of category theory, if we have two types `J` and `K` which are categories, then if `J` and `K` are equivalent (`J ≌ K`), and if `J` is a connected category, then `K` is also a connected category.
In other words, the property of being a connected category is preserved under equivalence of categories.

If two connected categories `J` and `K` are equivalent, then `K` is also a connected category.


theorem Filter.map₂_mono_left :
    ∀ {α : Type u_1} {β : Type u_3} {γ : Type u_5} {m : α → β → γ} {f : Filter α} {g₁ g₂ : Filter β},
      g₁ ≤ g₂ → Filter.map₂ m f g₁ ≤ Filter.map₂ m f g₂ :=
  by sorry

The theorem `Filter.map₂_mono_left` states that for any types `α`, `β`, and `γ` and any binary function `m : α → β → γ`, if we have two filters `g₁` and `g₂` on `β` such that `g₁` is a subset of `g₂` (or equivalently, `g₁` is finer than `g₂`), then the image of `m` under the filter `f` on `α` and `g₁` is a subset of the image of `m` under `f` and `g₂`. In other words, increasing the coarseness of the filter on the second argument of `m` (from `g₁` to `g₂`) does not decrease the coarseness of the resulting filter on `γ` (from `Filter.map₂ m f g₁` to `Filter.map₂ m f g₂`). This theorem captures a form of monotonicity of the `Filter.map₂` function with respect to its second filter argument.

If `f` is a filter on `α`, `g₁` and `g₂` are filters on `β` with `g₁ ⊆ g₂`, then `Filter.map₂ m f g₁ ⊆ Filter.map₂ m f g₂` for any binary function `m : α → β → γ`.


/-- The monomial function `x^n` tends to `+∞` at `+∞` for any positive natural `n`.
A version for positive real powers exists as `tendsto_rpow_atTop`.  -/
theorem Filter.tendsto_pow_atTop :
    ∀ {α : Type u_3} [inst : OrderedSemiring α] {n : ℕ},
      n ≠ 0 → Filter.Tendsto (fun x => x ^ n) Filter.atTop Filter.atTop :=
  by sorry

The theorem `Filter.tendsto_pow_atTop` states that for any positive natural number `n`, the monomial function `x^n` tends to positive infinity as `x` tends to positive infinity. This is expressed in the context of ordered semiring. The function `x^n` is said to tend towards infinity, if for every neighborhood `a` around infinity, there exists some `x` such that for all `x'` greater than `x`, `x'^n` is in the neighborhood `a`. A corresponding statement for real powers exists as `tendsto_rpow_atTop`.

For every positive natural number `n`, the function `x => x^n` tends to positive infinity as `x` approaches positive infinity in an ordered semiring.


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

This theorem states that for any type `I` and a function `f` mapping `I` to another type `v₁`, given two function instances `x` and `y` (which map `I` to `f i`), and a particular index `i` from `I`, if subtraction is defined on the type `f i`, then the subtraction of `x` and `y` evaluated at `i` is the same as the subtraction of the evaluations of `x` and `y` at `i`. In other words, we can distribute the application of a function over subtraction, similar to how we can distribute multiplication over addition in basic algebra.

For any type `I` and function `f : I → v₁`, if `i ∈ I` has defined subtraction `(v₁ : Type)`, then `(x - y) i = x i - y i`, where `x`, `y : I → f`.


theorem Set.biUnion_subset_biUnion_left :
    ∀ {α : Type u_1} {β : Type u_2} {s s' : Set α} {t : α → Set β}, s ⊆ s' → ⋃ x ∈ s, t x ⊆ ⋃ x ∈ s', t x := by sorry

The theorem `Set.biUnion_subset_biUnion_left` states that for any types `α` and `β`, any two sets `s` and `s'` of type `Set α`, and any function `t` mapping elements of `α` to `Set β`, if `s` is a subset of `s'`, then the union of `t x` for all `x` in `s` is also a subset of the union of `t x` for all `x` in `s'`. In other words, if we have a set of element sets derived from `s`, and `s` is a subset of `s'`, then the derived set from `s` is a subset of the derived set from `s'`.

If `s` is a subset of `s'`, then the union of `t(x)` for all `x` in `s` is a subset of the union of `t(x)` for all `x` in `s'`.


/-- If `r` is a well-founded relation, then any nonempty set has a minimal element
with respect to `r`.  -/
theorem WellFounded.has_min :
    ∀ {α : Type u_4} {r : α → α → Prop}, WellFounded r → ∀ (s : Set α), Set.Nonempty s → ∃ a ∈ s, ∀ x ∈ s, ¬r x a := by
  sorry

The theorem `WellFounded.has_min` states that for any type `α` and any relation `r` on `α`, if `r` is a well-founded relation, then every non-empty set of `α` has a minimal element according to `r`. In other words, given a well-founded relation `r` and a non-empty set `s`, there exists an element `a` in `s` such that, for all other elements `x` in `s`, the relation `r` does not hold from `x` to `a`. This effectively means that `a` is a minimum element of the set `s` with respect to the relation `r`.

If `α` is a type and `r` is a well-founded relation on `α`, then every non-empty subset of `α` has a minimal element with respect to `r`.


theorem HomotopyCategory.eq_of_homotopy :
    ∀ {ι : Type u_2} {V : Type u} [inst : CategoryTheory.Category.{v, u} V] [inst_1 : CategoryTheory.Preadditive V]
      {c : ComplexShape ι} {C D : HomologicalComplex V c} (f g : C ⟶ D),
      Homotopy f g → (HomotopyCategory.quotient V c).map f = (HomotopyCategory.quotient V c).map g :=
  by sorry

The theorem `HomotopyCategory.eq_of_homotopy` states that for any types `ι` and `V`, with `V` a category that is preadditive, for any complex shape `c`, and for any homological complexes `C` and `D` in this category, if there exist morphisms `f` and `g` from `C` to `D` that are homotopic, then the images of `f` and `g` under the quotient functor from complexes to the homotopy category are equal. In other words, homotopic morphisms in the category of complexes get mapped to the same morphism in the homotopy category.

Given a preadditive category `V`, any complex shape `c`, and homological complexes `C` and `D` in `V`, if there exist homotopic morphisms `f` and `g` from `C` to `D`, then their images under the quotient functor to the homotopy category are equal.


/-- The subfield generated by a set includes the set.  -/
theorem Subfield.subset_closure : ∀ {K : Type u} [inst : DivisionRing K] {s : Set K}, s ⊆ ↑(Subfield.closure s) := by
  sorry

This theorem asserts that for any given type `K` equipped with a division ring structure and any set `s` of elements from `K`, the set `s` is included in or is a subset of the subfield generated by `s`. In other words, all elements in the initial set `s` are also present in the subfield that is constructed from `s`. This is a fundamental property of closure operations in algebraic structures like fields and rings.

For any division ring `K` and set `s` of elements from `K`, the subfield generated by `s` contains `s`.


theorem CategoryTheory.ShortComplex.RightHomologyMapData.rightHomologyMap'_eq :
    ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
      {S₁ S₂ : CategoryTheory.ShortComplex C} {φ : S₁ ⟶ S₂} {h₁ : CategoryTheory.ShortComplex.RightHomologyData S₁}
      {h₂ : CategoryTheory.ShortComplex.RightHomologyData S₂}
      (γ : CategoryTheory.ShortComplex.RightHomologyMapData φ h₁ h₂),
      CategoryTheory.ShortComplex.rightHomologyMap' φ h₁ h₂ = γ.φH :=
  by sorry

This theorem states that in a category `C` with zero morphisms, given two short complexes `S₁` and `S₂`, a morphism `φ` from `S₁` to `S₂`, and right homology data `h₁` and `h₂` for `S₁` and `S₂`, respectively, if `γ` is the right homology map data associated with `φ`, `h₁`, and `h₂`, then the right homology map associated with `φ`, `h₁`, and `h₂` is equal to `γ.φH`, the morphism of homologies in `γ`.

In a category with zero morphisms, given two short complexes, a morphism between them, and right homology data, the right homology map of the morphism is equal to the composition of the morphism with the morphism of homologies in the right homology data.


theorem Mathlib.Algebra.Module.Submodule.Map._auxLemma.4 :
    ∀ {R : Type u_1} {R₂ : Type u_3} {M : Type u_5} {M₂ : Type u_7} [inst : Semiring R] [inst_1 : Semiring R₂]
      [inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid M₂] [inst_4 : Module R M] [inst_5 : Module R₂ M₂]
      {σ₁₂ : R →+* R₂} {x : M} {F : Type u_9} [inst_6 : FunLike F M M₂] [inst_7 : SemilinearMapClass F σ₁₂ M M₂] {f : F}
      {p : Submodule R₂ M₂}, (x ∈ Submodule.comap f p) = (f x ∈ p) :=
  by sorry

This theorem, `Mathlib.Algebra.Module.Submodule.Map._auxLemma.4`, states that for two semirings `R` and `R₂`, two additive commutative monoids `M` and `M₂`, which are also modules over `R` and `R₂` respectively, and a function `f` of type `F` that is a semilinear map between `M` and `M₂` with respect to a ring homomorphism `σ₁₂` from `R` to `R₂`, then for any element `x` from `M` and a submodule `p` of `M₂` over `R₂`, `x` is in the preimage of `p` under `f` if and only if the image of `x` under `f` is in `p`. This is essentially a characterization of the preimage of a set under a function in terms of the elements of the set and the function.

For semirings R and R₂, modules M and M₂ over them, a ring homomorphism σ₁₂ from R to R₂, and a semilinear map f of type F from M to M₂, if x is an element of M and p is a submodule of M₂, then x is in the preimage of p under f if and only if the image of x under f is in p.


theorem Finset.mem_powersetCard :
    ∀ {α : Type u_1} {n : ℕ} {s t : Finset α}, s ∈ Finset.powersetCard n t ↔ s ⊆ t ∧ s.card = n := by sorry

The theorem `Finset.mem_powersetCard` states that for any given type `α`, integer `n` and finsets `s` and `t`, the finset `s` is an element of `Finset.powersetCard n t` if and only if `s` is a subset of `t` and the cardinality of `s` is `n`. In other words, a finset `s` belongs to the set of all subsets of `t` of size `n` precisely when `s` is a subset of `t` and has `n` elements.

A finset `s` is an element of `Finset.powersetCard n` of a type `α` if and only if `s` is a subset of size `n` of another finset `t`.


theorem hasDerivWithinAt_univ :
    ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {F : Type v} [inst_1 : NormedAddCommGroup F]
      [inst_2 : NormedSpace 𝕜 F] {f : 𝕜 → F} {f' : F} {x : 𝕜}, HasDerivWithinAt f f' Set.univ x ↔ HasDerivAt f f' x :=
  by sorry

The theorem `hasDerivWithinAt_univ` states that for any function `f` from a non-trivially normed field `𝕜` to a normed additive commutative group `F` over `𝕜`, the derivative of `f` at a point `x` within the universal set (which contains all elements of `𝕜`) is equivalent to saying the function `f` has a derivative at the point `x` without any restriction to a subset of `𝕜`. In simpler terms, the derivative within the whole set is just the derivative at a point. In mathematical notation, it translates to the equivalence of these two statements: $f'(x) \text{ within } \mathbb{R} = f'(x)$.

The theorem `hasDerivWithinAt_univ` asserts that the derivative of a function from a non-trivially normed field to a normed additive commutative group at a point equals the derivative of the function without restriction to a subset, within the universal set.


theorem dvd_mul_of_dvd_left : ∀ {α : Type u_1} [inst : Semigroup α] {a b : α}, a ∣ b → ∀ (c : α), a ∣ b * c := by sorry

This theorem states that for any type `α` that is a semigroup (a mathematical structure with an associative binary operation), given any elements `a`, `b`, and `c` of `α`, if `a` divides `b` then `a` also divides the product of `b` and `c`. In mathematical terms, if $a|b$, then for any $c$, we have $a|bc$. This is a fundamental property of divisibility in algebra.

If `α` is a semigroup and `a` divides `b` in `α`, then `a` divides the product `b * c` in `α`.


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

This theorem, `tsub_le_tsub_left`, states that for any type `α` that has a pre-order, addition that is commutative and associative, subtraction, and ordered subtraction, and for any elements `a` and `b` of `α` such that `a` is less than or equal to `b`, the inequality `c - b ≤ c - a` holds for all `c` in `α`. In simpler terms, it says that if `a` is less than or equal to `b`, then subtracting `b` from any number `c` will always be less than or equal to subtracting `a` from `c`. This is a property of ordered groups or rings, and is often referred to as the principle of subtracting larger numbers results in smaller numbers.

For any commutative and associative additive pre-order type `α` and elements `a ≤ b` in `α`, for all `c` in `α`, we have `c - b ≤ c - a`.


/-- We can transport colimits of shape `J` along an equivalence `J ≌ J'`.
 -/
theorem CategoryTheory.Limits.hasColimitsOfShape_of_equivalence :
    ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] {C : Type u} [inst_1 : CategoryTheory.Category.{v, u} C]
      {J' : Type u₂} [inst_2 : CategoryTheory.Category.{v₂, u₂} J'],
      (J ≌ J') →
        ∀ [inst : CategoryTheory.Limits.HasColimitsOfShape J C], CategoryTheory.Limits.HasColimitsOfShape J' C :=
  by sorry

This theorem states that if we have a category `C` that has colimits of shape `J`, and if `J` is equivalent to another category `J'`, then `C` also has colimits of shape `J'`. In other words, the existence of colimits in a category is preserved under equivalence of categories.

If categories `C` and `D` are equivalent, then `C` has colimits of shape `J` if and only if `D` has colimits of shape `J`.


theorem FreeAlgebra.lift_ι_apply :
    ∀ {R : Type u_1} [inst : CommSemiring R] {X : Type u_2} {A : Type u_3} [inst_1 : Semiring A] [inst_2 : Algebra R A]
      (f : X → A) (x : X), ((FreeAlgebra.lift R) f) (FreeAlgebra.ι R x) = f x :=
  by sorry

The theorem `FreeAlgebra.lift_ι_apply` states that for any commutative semiring `R`, any types `X` and `A`, any semiring structure on `A`, any `R`-algebra structure on `A`, and any function `f : X → A`, when you apply the function `FreeAlgebra.ι R` (which is a canonical function from `X` to `FreeAlgebra R X`) to an element `x : X`, and then apply `FreeAlgebra.lift R f` (which is the unique lift of `f` to a morphism of `R`-algebras `FreeAlgebra R X → A`) to the result, it is equal to the result of applying `f` directly to `x`. In other words, `FreeAlgebra.lift R f` and `FreeAlgebra.ι R` commute with `f`.

For any commutative semiring `R`, given an `R`-algebra `A` with a semiring structure and an `R`-algebra homomorphism `f : FreeAlgebra R X → A` from the free algebra over a type `X` to `A`, the application of `f` to an element `x : X` is equal to the composition of `FreeAlgebra.lift R f` with `FreeAlgebra.ι R x`.


theorem Polynomial.eval_monomial :
    ∀ {R : Type u} [inst : Semiring R] {x : R} {n : ℕ} {a : R},
      Polynomial.eval x ((Polynomial.monomial n) a) = a * x ^ n :=
  by sorry

This theorem states that for any type `R` equipped with a semiring structure, any instance `x` of `R`, any natural number `n`, and any instance `a` of `R`, the evaluation of the polynomial `(Polynomial.monomial n) a` at `x` is equal to `a * x ^ n`. In other words, if you have a polynomial that is just a single term `a * X^n`, and you substitute `x` for `X`, you get `a * x^n`. This is a fundamental property reflecting how polynomials behave under substitution.

For any semiring `R`, `x : R`, natural number `n`, and `a : R`, the evaluation of the monomial `(Polynomial.monomial n) a` at `x` equals `a * x^n`.


theorem List.countP_eq_length_filter :
    ∀ {α : Type u_1} (p : α → Bool) (l : List α), List.countP p l = List.length (List.filter p l) := by sorry

The theorem `List.countP_eq_length_filter` states that for any type `α`, any predicate `p` of type `α → Bool`, and any list `l` of type `List α`, the count of elements in `l` that satisfy the predicate `p` is equal to the length of the list obtained by filtering `l` with the predicate `p`. This is, in mathematical terms, if we denote by $p$ a certain property and by $l$ a list of elements, the number of elements of $l$ having the property $p$ is the same as the number of elements in the filtered list where the filter criteria is the property $p$.

For any type `α`, predicate `p` on `α`, and list `l` of length `n` over `α`, the number of elements in `l` satisfying `p` equals the length of the filtered list `l.filter p`.


theorem Nat.modEq_zero_iff_dvd : ∀ {n a : ℕ}, a ≡ 0 [MOD n] ↔ n ∣ a := by sorry

The theorem `Nat.modEq_zero_iff_dvd` states that for any two natural numbers `n` and `a`, `a` is congruent to 0 modulo `n` if and only if `n` divides `a`. In mathematical terms, it describes the relation between modulo operation and divisibility: if when `a` is divided by `n` the remainder is 0 (`a ≡ 0 [MOD n]`), then `n` is a divisor of `a` (`n ∣ a`). This theorem makes a direct connection between the concepts of modular arithmetic and divisibility.

For any natural numbers `n` and `a`, `a` is congruent to 0 modulo `n` if and only if `n` divides `a`. (Equivalently, `n ∣ a` if and only if `a ≡ 0 [MOD n]`.)


Filter.Tendsto.neg

/-- If a function converges to a value in an additive topological group, then its
negation converges to the negation of this value. -/
theorem Filter.Tendsto.neg :
    ∀ {G : Type w} {α : Type u} [inst : TopologicalSpace G] [inst_1 : Neg G] [inst_2 : ContinuousNeg G] {f : α → G}
      {l : Filter α} {y : G}, Filter.Tendsto f l (nhds y) → Filter.Tendsto (fun x => -f x) l (nhds (-y)) :=
  by sorry

The theorem `Filter.Tendsto.neg` states that for any given function `f` mapping from a type `α` to a type `G`, if `f` converges to a value `y` in a topological space `G` that also forms an additive group with a continuous negation operation, then the function that maps each value `x` in the domain to the negation of `f(x)` converges to the negation of `y`. In other words, if a function's values approach some `y` as the input is filtered through a particular filter `l`, then the values of the negated function also approach the negation of `y` under the same input filter.

If a function from a topological space to an additive group with a continuous negation converges to a value under a filter, then the negated function converges to the negation of that value under the same filter.


theorem Fintype.ofEquiv_card :
    ∀ {α : Type u_1} {β : Type u_2} [inst : Fintype α] (f : α ≃ β), Fintype.card β = Fintype.card α := by sorry

The theorem `Fintype.ofEquiv_card` states that for any two finite types `α` and `β`, if there exists a bijective function (also known as an equivalence) `f` from `α` to `β`, then the cardinality (number of elements) of `α` is identical to the cardinality of `β`. This is a fundamental property in set theory and combinatorics, often referred to as cardinality preserving under bijections.

If `α` and `β` are finite types with a bijective function `f` between them, then `α` and `β` have the same cardinality.


Asymptotics.IsLittleO.congr'

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

This theorem states that for any types `α`, `E`, and `F` with `E` and `F` being normed, given a filter `l` and four functions `f₁`, `f₂` from `α` to `E` and `g₁`, `g₂` from `α` to `F`, if `f₁` is little o of `g₁` with respect to `l`, and `f₁` is eventually equal to `f₂` and `g₁` is eventually equal to `g₂` with respect to the same filter `l`, then `f₂` is little o of `g₂` with respect to `l`. In mathematical terms, this means that the asymptotic behavior of `f₁` and `f₂` is the same, and the same holds for `g₁` and `g₂`, then the asymptotic behavior of `f₂` and `g₂` will also be the same.

If `f₁` is little o of `g₁` and equal to `f₂` eventually, and `g₁` is equal to `g₂` eventually with respect to filter `l`, then `f₂` is little o of `g₂` with respect to `l`.


theorem Set.image_add_right :
    ∀ {α : Type u_2} [inst : AddGroup α] {t : Set α} {b : α}, (fun x => x + b) '' t = (fun x => x + -b) ⁻¹' t := by
  sorry

The `Set.image_add_right` theorem states the following: for any type `α` that forms an additive group, any set `t` of `α`, and any element `b` of `α`, the image of set `t` under the function that adds `b` to each element of `t` (`(fun x => x + b) '' t`) is equal to the preimage of set `t` under the function that subtracts `b` from each element (`(fun x => x + -b) ⁻¹' t`). Essentially, it illustrates the relationship between set transformation by addition and its corresponding transformation by subtraction in the context of an additive group.

For any additive group `α`, set `t` of `α`, and element `b` of `α`, the set `(fun x => x + b) '' t` equals the set `(fun x => x + -b) ⁻¹' t`.


theorem Finset.le_sup' :
    ∀ {α : Type u_2} {β : Type u_3} [inst : SemilatticeSup α] {s : Finset β} (f : β → α) {b : β} (h : b ∈ s),
      f b ≤ Finset.sup' s ⋯ f :=
  by sorry

The theorem `Finset.le_sup'` states that for any types `α` and `β`, where `α` has a semilattice superstructure, for any function `f` mapping from `β` to `α`, and for any element `b` of a nonempty finite set `s` of type `β`, the image of `b` under `f` is less than or equal to the supremum of the images of the elements of `s` under `f`. In other words, for all `b` in the set `s`, `f(b)` is less than or equal to the supremum of `f(s)`.

For any semilattice `α`, function `f` from a nonempty finite set `β` to `α`, and element `b` in `β`, we have `f(b) ≤ sup(map f s)`, where `s` is the set and `map f s` is the image of `s` under `f`.


theorem MeasureTheory.set_lintegral_univ :
    ∀ {α : Type u_1} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} (f : α → ENNReal),
      ∫⁻ (x : α) in Set.univ, f x ∂μ = ∫⁻ (x : α), f x ∂μ :=
  by sorry

This theorem, named `MeasureTheory.set_lintegral_univ`, states that for any type `α`, a measurable space `m` on `α`, a measure `μ` on `α`, and a function `f` from `α` to the extended nonnegative real numbers (usually denoted [0, ∞]), the set integral of `f` over the universal set (the set containing all elements of `α`) with respect to the measure `μ` is equal to the integral of `f` with respect to the measure `μ` without specifying a set. Here, ∫⁻ represents the Lebesgue integral or more specifically, the set integral with respect to a measure.

For any measurable space `(α, m)`, measure `μ`, and measurable function `f` from `α` to [0, ∞], the set integral of `f` over the universal set with respect to `μ` equals the integral of `f` with respect to `μ`.


theorem isUnit_of_dvd_one : ∀ {α : Type u_1} [inst : CommMonoid α] {a : α}, a ∣ 1 → IsUnit a := by sorry

The theorem `isUnit_of_dvd_one` states that for any commutative monoid `α`, if an element `a` of `α` divides the multiplicative identity (1), then `a` is a unit. Here, a unit is an element that has a two-sided inverse. In other words, if `a` is such that there exists another element in `α` such that their product is 1, then `a` has a two-sided inverse, hence it is a unit.

If an element of a commutative monoid has a multiplicative inverse, then it is a unit.


theorem mul_right_cancel₀ :
    ∀ {M₀ : Type u_1} [inst : Mul M₀] [inst_1 : Zero M₀] [inst_2 : IsRightCancelMulZero M₀] {a b c : M₀},
      b ≠ 0 → a * b = c * b → a = c :=
  by sorry

This theorem states that for any type `M₀` endowed with multiplication and a zero element, and where multiplication by zero on the right side cancels out any non-zero values, given three elements `a`, `b`, and `c` of `M₀`, if `b` is not equal to zero and the product of `a` and `b` is equal to the product of `c` and `b`, then `a` must be equal to `c`. This is a form of the "cancellation law" for multiplication.

If `M₀` is a type with multiplication and zero such that `a * b = c * b` implies `a = c` for all non-zero `b` in `M₀`, then `M₀` satisfies the left cancellation law for multiplication.


theorem Finset.not_nonempty_iff_eq_empty : ∀ {α : Type u_1} {s : Finset α}, ¬s.Nonempty ↔ s = ∅ := by sorry

This theorem states that for any given type `α` and a finite set `s` of this type, the set `s` is not nonempty if and only if the set `s` is empty. In other words, a finite set is not nonempty if it doesn't contain any elements, which is equivalent to saying that the set is empty.

A finite set is nonempty if and only if it is not empty.


theorem Mathlib.Data.Int.Cast.Basic._auxLemma.3 :
    ∀ {R : Type u} [inst : AddGroupWithOne R] (n : ℕ), -↑(n + 1) = ↑(Int.negSucc n) := by sorry

This theorem states that for any natural number `n` and any type `R` that forms an additive group with a distinguished one, the negation of the cast of `n + 1` is the same as the cast of `Int.negSucc n`. In terms of mathematical notation, this is saying that for all natural numbers `n` and any `R` in the AddGroupWithOne, `-↑(n + 1) = ↑(Int.negSucc n)`. The `Int.negSucc` function gives the negative of the successor (or next) integer, so this theorem essentially asserts a property about negations and successors in additive groups with a distinguished one.

For any natural number `n` and additive group `R` with one, the negation of `n + 1` in `R` equals the additive inverse of `n` in `R`.


theorem exists_nat_ge : ∀ {α : Type u_1} [inst : OrderedSemiring α] [inst_1 : Archimedean α] (x : α), ∃ n, x ≤ ↑n := by
  sorry

This theorem, `exists_nat_ge`, states that for any type `α` that is an ordered semiring and is Archimedean (meaning that there are no infinitely small positive numbers), given any element `x` of type `α`, there exists a natural number `n` such that `x` is less than or equal to `n`. In simpler terms, it says that any number in an Archimedean ordered semiring is either less than or equal to some natural number.

In any Archimedean ordered semiring, every element is less than or equal to some natural number.


theorem Function.bijective_iff_existsUnique :
    ∀ {α : Sort u_1} {β : Sort u_2} (f : α → β), Function.Bijective f ↔ ∀ (b : β), ∃! a, f a = b := by sorry

The theorem `Function.bijective_iff_existsUnique` states that for all types `α` and `β` and for a function `f` from `α` to `β`, `f` is bijective if and only if for every element `b` in `β`, there exists a unique element `a` in `α` such that `f(a) = b`. In other words, a function is bijective (both injective and surjective) if each element of the codomain is mapped exactly by one element from the domain.

A function from type `α` to type `β` is bijective if and only if for every `b` in `β`, there exists a unique `a` in `α` such that `f(a) = b`.


theorem pow_mem :
    ∀ {M : Type u_4} {A : Type u_5} [inst : Monoid M] [inst_1 : SetLike A M] [inst_2 : SubmonoidClass A M] {S : A}
      {x : M}, x ∈ S → ∀ (n : ℕ), x ^ n ∈ S :=
  by sorry

This theorem states that for any given type `M` with a Monoid structure and another type `A` that behaves like a set of `M` (with `S` as an instance of `A`), if an element `x` of type `M` belongs to `S`, then `x` raised to the power of any natural number `n` also belongs to `S`. In other words, if `x` is an element of a given submonoid `S`, then all powers of `x` are also elements of `S`.

If `x` is an element of a submonoid `S` of a monoid `M`, then for all natural numbers `n`, `x^n` is also an element of `S`.


theorem bit0_eq_two_mul : ∀ {α : Type u} [inst : NonAssocSemiring α] (n : α), bit0 n = 2 * n := by sorry

The theorem `bit0_eq_two_mul` states that for any type `α` that is an instance of a non-associative semiring (a structure with two binary operations that generalizes many algebraic structures such as rings, fields, etc.), the function `bit0` applied to any element `n` of `α` is equal to 2 multiplied by `n`. The `bit0` function is defined as the sum of `n` with itself, so effectively, this theorem asserts that doubling `n` through addition is the same as multiplying `n` by 2.

For any non-associative semiring type `α`, the function `bit0` on `α` (defined as the sum of an element with itself) equals the multiplication by 2.


theorem isPreconnected_empty : ∀ {α : Type u} [inst : TopologicalSpace α], IsPreconnected ∅ := by sorry

The theorem `isPreconnected_empty` asserts that for any type `α` equipped with a topology (i.e., a topological space), the empty set `∅` is preconnected. According to the provided definition, a set is preconnected if it does not have a non-trivial open partition. The theorem thus states that the empty set does not have such a partition, making it preconnected in any topological space.

In any topological space, the empty set is preconnected, that is, it does not have a non-trivial open partition.


theorem Mathlib.Data.ENNReal.Basic._auxLemma.6 : ∀ {r : NNReal}, (↑r = ⊤) = False := by sorry

This theorem states that for all nonnegative real numbers (`NNReal`), it is false that they are equal to positive infinity (`⊤`). In other words, no nonnegative real number can be equal to positive infinity.

For all nonnegative real numbers `x`, `x` is not equal to positive infinity (`⊤`).


theorem UniformSpace.Completion.continuous_map :
    ∀ {α : Type u_1} [inst : UniformSpace α] {β : Type u_2} [inst_1 : UniformSpace β] {f : α → β},
      Continuous (UniformSpace.Completion.map f) :=
  by sorry

The theorem `UniformSpace.Completion.continuous_map` states that for all types `α` and `β` which are equipped with a `UniformSpace` structure, and for any function `f` from `α` to `β`, the map `UniformSpace.Completion.map f` is continuous. In other words, if we take a function from one `UniformSpace` to another and apply the completion functor to it, the resulting function is guaranteed to be continuous. Here, continuity of a function means that the inverse image of any open set in the co-domain is open in the domain. In the context of uniform spaces (which are a generalization of metric spaces), this theorem ensures that we can work with complete spaces without loss of continuity.

The completion of a continuous function between uniform spaces is a continuous function.


theorem Complex.exp_mul_I : ∀ (x : ℂ), Complex.exp (x * Complex.I) = Complex.cos x + Complex.sin x * Complex.I := by
  sorry

The theorem `Complex.exp_mul_I` states that for all complex numbers `x`, the exponential of `x` multiplied by the imaginary unit equals the complex cosine of `x` plus the complex sine of `x` multiplied by the imaginary unit. In mathematical terms, it expresses the well-known Euler's formula in complex analysis: e^(ix) = cos(x) + i sin(x) for any complex number x.

For all complex numbers x, Complex.exp x = Complex.cos x + Complex.i * Complex.sin x.


theorem Nat.divisors_zero : Nat.divisors 0 = ∅ := by sorry

The theorem `Nat.divisors_zero` states that the set of divisors of 0, as given by the function `Nat.divisors`, is the empty set. In other words, there are no natural numbers that divide 0.

The set of divisors of 0, as defined in Lean's Nat.divisors function, is the empty set.


theorem Multiset.map_le_map :
    ∀ {α : Type u_1} {β : Type v} {f : α → β} {s t : Multiset α}, s ≤ t → Multiset.map f s ≤ Multiset.map f t := by
  sorry

The theorem `Multiset.map_le_map` asserts that for any two multisets `s` and `t` of an arbitrary type `α`, and a function `f` from `α` to another arbitrary type `β`, if `s` is a sub-multiset of `t`, then the multiset obtained by mapping `f` over `s` is also a sub-multiset of the multiset obtained by mapping `f` over `t`. In mathematical terms, if $s$ and $t$ are multisets from a set $A$ and $f: A \rightarrow B$ is a function, then $s \subseteq t$ implies that $f(s) \subseteq f(t)$. The multiplicity of an element in a multiset is preserved during this mapping operation.

If `s` is a sub-multiset of `t` in type `α` and `f` is a function from `α` to `β`, then `f(s)` is a sub-multiset of `f(t)`.


theorem iff_eq_eq : ∀ {a b : Prop}, (a ↔ b) = (a = b) := by sorry

This theorem, named `iff_eq_eq`, states that for all propositions `a` and `b`, the logical equivalence of `a` and `b` (denoted as `a ↔ b` in Lean 4) is equal to the statement that `a` and `b` are the same proposition (denoted as `a = b` in Lean 4). In other words, it asserts the equivalence between logical equivalence and propositional equality in the context of propositional logic.

The logical equivalence of propositions `a` and `b` (`a ↔ b`) is equivalent to their propositional equality (`a = b`) in propositional logic.


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

This theorem, `Int.neg_mul`, states that for any two integers `a` and `b`, the result of multiplying negative `a` (`-a`) with `b` is the same as the negative of the product of `a` and `b` (`-(a * b)`). This is essentially a restatement of the rule in arithmetic that multiplying a negative number by a positive number yields a negative number.

For any integers `a` and `b`, `-(a * b) = (-a) * b`.


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

This theorem states that for any two functions `f : α → β` and `g : α → γ` defined on a measure space `(α, m, μ)`, where `α` is a set, `m` is a σ-algebra on `α`, and `μ` is a measure on `m`, if both `f` and `g` are almost everywhere strongly measurable with respect to measure `μ`, then the function that takes `x` in `α` to the pair `(f x, g x)` in `β × γ` is also almost everywhere strongly measurable with respect to `μ`. In other words, the property of being almost everywhere strongly measurable is preserved under forming the product of two functions. Here, a function is said to be almost everywhere strongly measurable if it is almost everywhere equal to the limit of a sequence of simple functions.

If `f : α → β` and `g : α → γ` are almost everywhere strongly measurable functions on the measure space `(α, m, μ)`, then the function `x ↦ (f x, g x)` from `α` to `β × γ` is also almost everywhere strongly measurable.


theorem PNat.ne_zero : ∀ (n : ℕ+), ↑n ≠ 0 := by sorry

This theorem states that for every positive natural number `n`, the integer representation of `n` is not equal to zero. In other words, there is no positive natural number that equals zero when converted to an integer.

For every positive natural number `n`, 0 ≠Int. n.


theorem Set.subsingleton_empty : ∀ {α : Type u}, Set.Subsingleton ∅ := by sorry

The theorem `Set.subsingleton_empty` asserts that for any type `α`, the empty set is a `Subsingleton`. In other words, the empty set has at most one element for any given type. This is intuitively true as the empty set doesn't contain any elements.

The empty set is a Propositional Equivalence type with no elements. (In Lean, this is represented as an instance of `Subsingleton`.)


Function.Surjective.denseRange

/-- A surjective map has dense range.  -/
theorem Function.Surjective.denseRange :
    ∀ {X : Type u_1} [inst : TopologicalSpace X] {α : Type u_4} {f : α → X}, Function.Surjective f → DenseRange f := by
  sorry

The theorem `Function.Surjective.denseRange` states that for any topological space `X` and any type `α`, if a function `f` from `α` to `X` is surjective (i.e., for every element of `X` there is some element of `α` such that the function `f` maps that element of `α` to the given element of `X`), then the range of `f` is dense in `X`. In other words, every open subset of `X` contains at least one point from the image of `f`.

If a function from a type to a topological space is surjective, then its range is dense in the space.


theorem AddMonoid.exponent_nsmul_eq_zero : ∀ {G : Type u} [inst : AddMonoid G] (g : G), AddMonoid.exponent G • g = 0 :=
  by sorry

The theorem `AddMonoid.exponent_nsmul_eq_zero` states that for any given additive monoid `G` and any element `g` of `G`, if you add `g` to itself `AddMonoid.exponent G` times, the result will be the zero element of `G`. In other words, the `AddMonoid.exponent G` is the smallest positive integer such that `n • g = 0` for all `g` in `G` if it exists, otherwise it is zero by convention.

For any additive monoid G and element g in G, the power g^(AddMonoid.exponent G) equals the additive identity in G.


/-- Two morphisms into a pullback are equal if their compositions with the pullback morphisms are
equal  -/
theorem CategoryTheory.Limits.pullback.hom_ext :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z : C} {f : X ⟶ Z} {g : Y ⟶ Z}
      [inst_1 : CategoryTheory.Limits.HasPullback f g] {W : C} {k l : W ⟶ CategoryTheory.Limits.pullback f g},
      CategoryTheory.CategoryStruct.comp k CategoryTheory.Limits.pullback.fst =
          CategoryTheory.CategoryStruct.comp l CategoryTheory.Limits.pullback.fst →
        CategoryTheory.CategoryStruct.comp k CategoryTheory.Limits.pullback.snd =
            CategoryTheory.CategoryStruct.comp l CategoryTheory.Limits.pullback.snd →
          k = l :=
  by sorry

The theorem `CategoryTheory.Limits.pullback.hom_ext` states that in a category `C`, given two morphisms `f : X ⟶ Z` and `g : Y ⟶ Z` with a pullback, and two morphisms `k` and `l` from some object `W` into the pullback, if the compositions of `k` and `l` with the first and second projections of the pullback are equal, then `k` and `l` must be equal.

In other words, in the category theory context, it asserts a uniqueness property for morphisms into the pullback object: any two morphisms which are equal when composed with the pullback projections are themselves equal.

In a category, given morphisms with a pullback and equal compositions with the pullback projections, the morphisms are equal.


theorem UniformSpace.Completion.coe_zero : ∀ {α : Type u_3} [inst : UniformSpace α] [inst_1 : Zero α], ↑α 0 = 0 := by
  sorry

This theorem states that for any type `α` that is a uniform space and has a zero element, the completion of the space maps the zero element of `α` to the zero element of the completion. In mathematics terms, if `α` is a uniform space and `0` is a zero element in `α`, the embedding of `α` into its completion sends `0` to `0`.

If `(α, d)` is a uniform space with a zero element `0`, then the completion `(Ⓐα, ∥.∥)` of `α` contains the zero element `ℝ⁇0` such that the embedding `α ��射游 Ⓐα` sends `0` to `ℝ⁇0`.


/-- **Alias** of the reverse direction of `lipschitzWith_iff_dist_le_mul`. -/
theorem LipschitzWith.of_dist_le_mul :
    ∀ {α : Type u} {β : Type v} [inst : PseudoMetricSpace α] [inst_1 : PseudoMetricSpace β] {K : NNReal} {f : α → β},
      (∀ (x y : α), dist (f x) (f y) ≤ ↑K * dist x y) → LipschitzWith K f :=
  by sorry

The theorem `LipschitzWith.of_dist_le_mul` states that for any two types `α` and `β`, where both are equipped with a pseudo metric space structure, and for any nonnegative real number `K` and function `f` that maps `α` to `β`, if for all `x` and `y` in `α`, the distance between `f(x)` and `f(y)` is less than or equal to `K` times the distance between `x` and `y`, then the function `f` is Lipschitz continuous with constant `K`. This theorem is an alias of the reverse direction of `lipschitzWith_iff_dist_le_mul`.

For any types equipped with pseudo metric spaces `α` and `β`, and for any function `f` from `α` to `β` and non-negative real `K`, if `d(f(x), f(y)) ≤ K * d(x, y)` for all `x, y` in `α`, then `f` is Lipschitz continuous with constant `K`.


/-- To prove a property of a product, it suffices to prove that
the property is multiplicative and holds on factors.  -/
theorem Finset.prod_induction :
    ∀ {α : Type u_3} {s : Finset α} {M : Type u_6} [inst : CommMonoid M] (f : α → M) (p : M → Prop),
      (∀ (a b : M), p a → p b → p (a * b)) → p 1 → (∀ x ∈ s, p (f x)) → p (Finset.prod s fun x => f x) :=
  by sorry

The theorem `Finset.prod_induction` states that, given a function `f` from a type `α` to a commutative monoid `M`, a property `p` on `M`, and a finite set `s` of elements of type `α`, if the property `p` is multiplicative (i.e., if `p(a * b)` is true whenever `p(a)` and `p(b)` are true) and the property `p` holds for the neutral element 1 and for all elements of the form `f(x)` for `x` in the set `s`, then the property `p` must also hold for the product of all `f(x)`'s where `x` is in the set `s`. In other words, to prove a property of a product, it is sufficient to prove that the property is multiplicative and holds on the factors of the product.

If `f : α -> M` maps a finite set `s` to commutative monoid elements, `1` is neutral, `p(1)` holds, and `p` is multiplicative, then `∏x ∈ s. p(f x)` holds.


theorem Mathlib.Algebra.Order.Monoid.Lemmas._auxLemma.8 :
    ∀ {α : Type u_1} [inst : Add α] [inst_1 : LT α]
      [inst_2 : CovariantClass α α (Function.swap fun x x_1 => x + x_1) fun x x_1 => x < x_1]
      [inst_3 : 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

The theorem `Mathlib.Algebra.Order.Monoid.Lemmas._auxLemma.8` states that for all types `α` that have an addition operation and a less-than relation, provided they satisfy both a CovariantClass property and a ContravariantClass property with respect to a `Function.swap` operation on addition and less-than, for any terms `a`, `b`, and `c` of type `α`, the relation `(b + a < c + a) = (b < c)` holds. In simpler terms, this theorem is about the cancellation property in ordered monoids: if you add the same term `a` to two terms `b` and `c`, the inequality between `b` and `c` does not change.

In an ordered monoid, swapping the order of adding a term to two other terms preserves the inequality between them: i.e., for all `α` with CovariantClass and ContravariantClass structures, `(b < c) = (b + a < c + a)` for any `a, b, c` in `α`.


theorem le_add_left : ∀ {α : Type u} [inst : CanonicallyOrderedAddCommMonoid α] {a b c : α}, a ≤ c → a ≤ b + c := by
  sorry

This theorem, named `le_add_left`, states that for any type `α` that forms a canonically ordered additive commutative monoid, given three elements `a`, `b` and `c` of this type, if `a` is less than or equal to `c` (`a ≤ c`), then `a` is also less than or equal to the sum of `b` and `c` (`a ≤ b + c`). This theorem provides a property about the relation between elements of a canonically ordered additive commutative monoid.

For any additive commutative monoid with a canonical order, if `a` is less than or equal to `c`, then `a` is also less than or equal to `c + b`.


theorem Finsupp.coe_add : ∀ {α : Type u_1} {M : Type u_5} [inst : AddZeroClass M] (f g : α →₀ M), ⇑(f + g) = ⇑f + ⇑g :=
  by sorry

This theorem states that for any two functions `f` and `g` of type `α →₀ M`, where `M` is a type with an addition and zero operation (`AddZeroClass`), the operation of applying the function `(f + g)` is equivalent to separately applying and then adding the results of functions `f` and `g`. In mathematical terms, for all `α` in `Type u_1` and `M` in `Type u_5` with `AddZeroClass` structure, the function application of the sum of `f` and `g` is equal to the sum of the function applications of `f` and `g`.

For any functions `f` and `g` of type `α →₀ M` with `M` being an `AddMonoid`, the function `(f + g)` equals the application of `f` followed by `g` and the addition of their results.


theorem Function.Surjective.image_preimage :
    ∀ {α : Type u_2} {β : Type u_3} {f : α → β}, Function.Surjective f → ∀ (s : Set β), f '' (f ⁻¹' s) = s := by sorry

This theorem states that for every types `α` and `β`, and for every function `f` from `α` to `β`, if the function `f` is surjective, then for every set `s` of type `β`, the image under `f` of the preimage under `f` of `s` is equal to `s`. In mathematical terms, it states that for a surjective function `f: α → β`, for all subsets `s` of `β`, `f(f⁻¹(s)) = s`. This effectively captures the property of surjective functions where every element in the codomain `β` is the image of at least one element from the domain `α`.

For every surjective function `f: α → β`, the image of `f` of the preimage of any subset `s` of `β` equals `s`.


/-- **Alias** of `ne_top_of_lt`. -/
theorem LT.lt.ne_top : ∀ {α : Type u} [inst : Preorder α] [inst_1 : OrderTop α] {a b : α}, a < b → a ≠ ⊤ := by sorry

This theorem, called `LT.lt.ne_top`, states that for any type `α` with a `Preorder` and `OrderTop` structure, if a is less than b (denoted by "a < b"), then a cannot be equal to the top element (denoted by "a ≠ ⊤"). Essentially, if some element a is less than another element b in this ordered structure, a cannot be the maximum (or "top") element in this structure.

In any preordered type with a top element, there are no elements related by the strict order relation and equal to the top element.


theorem Multiset.dedup_ext :
    ∀ {α : Type u_1} [inst : DecidableEq α] {s t : Multiset α},
      Multiset.dedup s = Multiset.dedup t ↔ ∀ (a : α), a ∈ s ↔ a ∈ t :=
  by sorry

This theorem states that for any type `α` with decidable equality and for any two multisets `s` and `t` of type `α`, the operation `Multiset.dedup` results in identical multisets for `s` and `t` if and only if each element `a` of type `α` is a member of `s` if and only if it is a member of `t`. In other words, two multisets have the same elements after removing duplicates if and only if they contain the same elements before removing duplicates.

For any type `α` with decidable equality, two multisets `s` and `t` of type `α` have identical `Multiset.dedup` outputs if and only if they have the same elements before duplicates are removed.


theorem CategoryTheory.Limits.pullback.lift_fst :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {W X Y Z : C} {f : X ⟶ Z} {g : Y ⟶ Z}
      [inst_1 : CategoryTheory.Limits.HasPullback f g] (h : W ⟶ X) (k : W ⟶ Y)
      (w : CategoryTheory.CategoryStruct.comp h f = CategoryTheory.CategoryStruct.comp k g),
      CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.pullback.lift h k w)
          CategoryTheory.Limits.pullback.fst =
        h :=
  by sorry

This theorem states that in any category `C`, for any four objects `W`, `X`, `Y`, `Z` and two morphisms `f : X ⟶ Z` and `g : Y ⟶ Z` such that the pullback of `f` and `g` exists, if we have two other morphisms `h : W ⟶ X` and `k : W ⟶ Y` satisfying the property that the composition of `h` and `f` is equal to the composition of `k` and `g` (represented by `w : CategoryTheory.CategoryStruct.comp h f = CategoryTheory.CategoryStruct.comp k g`), then the composition of the pullback lift of `h`, `k` and `w` with the first projection of the pullback equals `h`. This theorem is essentially verifying one of the universal properties of the pullback in category theory: the unique map into the pullback that makes the required diagrams commute.

In any category, given morphisms `f : X ⟶ Z`, `g : Y ⟶ Z`, `h : W ⟶ X`, `k : W �re� Y`, and a pullback `p : X ⏯ Z ⨝ Y`, if `h` and `k` satisfy `comp h f = comp k g` and `w : comp (pullback.fst p) h = h`, then `comp (pullback.lift p h) (pullback.lift p k w) (pullback.snd p) = h`.


theorem dvd_lcm_left :
    ∀ {α : Type u_1} [inst : CancelCommMonoidWithZero α] [inst_1 : GCDMonoid α] (a b : α), a ∣ lcm a b := by sorry

This theorem states that for any type `α` which is a cancel commutative monoid with zero and a GCD monoid, and for any elements `a` and `b` of type `α`, `a` divides the least common multiple (LCM) of `a` and `b`. In other words, for all `a` and `b` in the given type, the LCM of `a` and `b` is always a multiple of `a`.

For any cancel commutative monoid with zero and a GCD monoid `α`, for all `a, b ∈ α`, `a` divides the least common multiple of `a` and `b`.


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

This theorem states that for all types `α`, `β`, and `γ` where `γ` has decidable equality, and for any binary function `f` from `α` and `β` to `γ`, if we have two subsets `s` and `t` of `α` and `β` respectively, and these subsets are included in larger sets `s'` and `t'` respectively (`s ⊆ s'` and `t ⊆ t'`), then the image of the binary function `f` applied to the smaller subsets is also included in the image of the same function applied to the larger sets (`Finset.image₂ f s t ⊆ Finset.image₂ f s' t'`). In mathematical terms, it expresses the property that the image of a function is monotone with respect to set inclusion.

For any function between two sets with decidable equality and a decidable image, the image of two included sets is included in the image of their supersets.


theorem map_multiset_prod :
    ∀ {α : Type u_2} {β : Type u_3} [inst : CommMonoid α] [inst_1 : CommMonoid β] {F : Type u_5}
      [inst_2 : FunLike F α β] [inst_3 : MonoidHomClass F α β] (f : F) (s : Multiset α),
      f (Multiset.prod s) = Multiset.prod (Multiset.map (⇑f) s) :=
  by sorry

The theorem `map_multiset_prod` states that for any two types `α` and `β` with commutative monoid structures, any `FunLike` object `F` from `α` to `β` that also obeys `MonoidHomClass` (making `F` a monoid homomorphism), a function `f` of type `F`, and a multiset `s` of type `α`, the result of applying `f` to the product of the multiset `s` is equal to the product of the multiset obtained by mapping `f` over `s`. This can be interpreted as the homomorphism `f` preserving the product operation while transforming elements from `α` to `β`.

For any commutative monoids types `α` and `β`, any `FunLike` monoid homomorphism `F` from `α` to `β`, and any multiset `s` of `α`, the application of `F` to the product of `s` is equal to the product of the image of `s` under `F`.


/-- **Alias** of the reverse direction of `inv_pos`. -/
theorem inv_pos_of_pos : ∀ {α : Type u_1} [inst : LinearOrderedSemifield α] {a : α}, 0 < a → 0 < a⁻¹ := by sorry

This theorem, `inv_pos_of_pos`, states that for any value `a` from a linearly ordered semifield `α`, if `a` is greater than zero, then its multiplicative inverse `a⁻¹` is also greater than zero. In mathematical terms, if `0 < a`, then it follows that `0 < a⁻¹`. This theorem essentially mirrors the reverse direction of the `inv_pos` theorem.

If `α` is a linearly ordered semifield and `0 < a` in `α`, then `0 < a⁻¹`.


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

The theorem `Finset.Nonempty.of_image₂_right` states that, for any types `α`, `β`, and `γ` with `γ` having decidable equality, and given a binary function `f` from `α` and `β` to `γ`, and two finite sets `s` and `t` of types `α` and `β` respectively, if the image of the function `f` over the Cartesian product of `s` and `t` is nonempty, then `t` is also nonempty. In mathematical terms, if there exists at least one element in the set ${f(a,b) | a ∈ s, b ∈ t}$, then there exists at least one element in set `t`.

If `f` is a binary function from types `α` and `β` to a type `γ` with decidable equality, and the image of `f` over the Cartesian product of nonempty finite sets `s` and `t` of types `α` and `β` respectively is nonempty, then `t` is nonempty.


Rack.PreEnvelGroupRel'.rel

/-- A quick way to convert a `PreEnvelGroupRel'` to a `PreEnvelGroupRel`.
 -/
theorem Rack.PreEnvelGroupRel'.rel :
    ∀ {R : Type u} [inst : Rack R] {a b : Rack.PreEnvelGroup R},
      Rack.PreEnvelGroupRel' R a b → Rack.PreEnvelGroupRel R a b :=
  by sorry

This theorem provides a fast method to convert a `PreEnvelGroupRel'` into a `PreEnvelGroupRel` for any given rack `R`. For all elements `a` and `b` of the pre-envelope group of `R`, if there exists a `PreEnvelGroupRel'` relation between `a` and `b`, then there also exists a `PreEnvelGroupRel` relation between `a` and `b`. The proof of this theorem is not shown here.

For any rack R, if two elements of its pre-envelope group are related by a `PreEnvelGroupRel'`, then they are also related by a `PreEnvelGroupRel`.


theorem Int.le_ceil : ∀ {α : Type u_2} [inst : LinearOrderedRing α] [inst_1 : FloorRing α] (a : α), a ≤ ↑⌈a⌉ := by sorry

This theorem states that for any element 'a' of a certain type 'α', where 'α' is a linearly ordered ring with a flooring operation, the value of 'a' is always less than or equal to the ceiling of 'a'. The ceiling function, denoted as '⌈a⌉', rounds 'a' up to the nearest integer, and the theorem ensures that 'a' will never be larger than this rounded value.

For any element 'a' in a linearly ordered ring with a flooring operation, the element 'a' is less than or equal to its ceiling '⌈a⌉'.


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

This theorem states that for any type `α` which is a LinearOrderedRing, the absolute value of an element `a` from this ring multiplied by itself is equal to `a` multiplied by itself. In mathematical terms, for all `a` in a LinearOrderedRing `α`, we have `|a| * |a| = a * a`. This theorem generalizes the fact that the square of the absolute value of a real number is equal to the square of the number itself.

For any linear ordered ring `α` and its element `a`, the absolute value of `a` squared equals `a` multiplied by itself: `|a| * |a| = a * a`.


theorem iInf_neg : ∀ {α : Type u_1} [inst : CompleteLattice α] {p : Prop} {f : p → α}, ¬p → ⨅ (h : p), f h = ⊤ := by
  sorry

This theorem states that for any type `α` that forms a complete lattice, for any proposition `p`, and any function `f` from `p` to `α`, if the proposition `p` is not true, then the infimum (greatest lower bound) over `f` for all `h` in the truth set of `p` is equal to the top element of the lattice (i.e., the greatest element). In other words, if the condition `p` never holds, the lower bound of the function `f` is the largest possible value in the lattice.

For any complete lattice `α` and proposition `p`, if `p` is false, then the infimum of `f` over all `h` in the truth set of `p` equals the top element of `α`.


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

---

Definition of `IsLittleO` in terms of `IsBigOWith`.  -/
theorem Asymptotics.IsLittleO.of_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 α}, (∀ ⦃c : ℝ⦄, 0 < c → Asymptotics.IsBigOWith c l f g) → f =o[l] g :=
  by sorry

The theorem `Asymptotics.IsLittleO.of_isBigOWith` states that for any types `α`, `E`, and `F` with the latter two possessing a norm, and for any functions `f : α → E` and `g : α → F` with a given filter `l` on `α`, if for all real numbers `c` greater than 0, `f` is big-O of `g` within `c` and `l` (i.e., the norm of `f` is eventually bounded by `c` times the norm of `g`), then `f` is little-o of `g` at `l`. In other words, `f` grows no faster than `g` at `l`.

If for all `c > 0`, the norm of `f(x)` is eventually bounded by `c` times the norm of `g(x)` for all `x` in a filter `l` on `α`, then `f` is little-o of `g` at `l`.


theorem Polynomial.toFinsupp_monomial :
    ∀ {R : Type u} [inst : Semiring R] (n : ℕ) (r : R), ((Polynomial.monomial n) r).toFinsupp = fun₀ | n => r := by
  sorry

This theorem states that for any semiring `R`, any natural number `n`, and any element `r` of `R`, the finsupp (finite support function) of the polynomial obtained by applying the monomial `r * X^n` is a function that maps `n` to `r` and all other inputs to zero. In other words, this function returns `r` when applied to `n` and `0` otherwise, which is consistent with the fact that a polynomial monomial only has one term with a non-zero coefficient.

For any semiring `R` and natural number `n`, the finitte support function of the polynomial `r * X^n` in `R[X]` is the function mapping `i` to `(if i = n then r else 0)`.


theorem Nat.div_add_mod : ∀ (m n : ℕ), n * (m / n) + m % n = m := by sorry

This theorem states that for any two natural numbers `m` and `n`, the sum of `n` times the quotient of `m` divided by `n` and the remainder of `m` divided by `n` is equal to `m`. This is a formalization of the "division algorithm", or Euclidean division, which states that for any two positive integers `m` and `n`, there exist unique integers `q` and `r` such that `m = n*q + r` and `0 ≤ r < |n|`, where `q` is the quotient and `r` is the remainder.

For any natural numbers `m` and `n`, `m` equals the sum of `n` times the quotient of `m` by `n` and the remainder of `m` divided by `n`.


theorem zero_tsub :
    ∀ {α : Type u_1} [inst : CanonicallyOrderedAddCommMonoid α] [inst_1 : Sub α] [inst_2 : OrderedSub α] (a : α),
      0 - a = 0 :=
  by sorry

This theorem, named `zero_tsub`, states that for any type `α` that has a structure of a canonically ordered additive commutative monoid and also supports subtraction operation which obeys the ordering, the result of subtracting any element `a` of that type from zero is always zero. In other words, in such a structured type, zero minus any element equals zero.

For any additively commutative monoid with subtraction operation respecting its ordering, subtracting any element from zero yields zero.


theorem Units.val_pow_eq_pow_val : ∀ {α : Type u} [inst : Monoid α] (a : αˣ) (n : ℕ), ↑(a ^ n) = ↑a ^ n := by sorry

This theorem states that for any type `α` that forms a monoid and for any unit `a` of type `α` and a natural number `n`, the value of `a` raised to the power of `n` is equal to the value of `a` raised to the power of `n` in the context of monoids. In other words, the power of a unit in a monoid, when coerced to the underlying type, is the same as the power of the coerced unit in the underlying type.

For any monoid `α` with unit `a`, and natural number `n`, the coerced power `(a : α) ^ n` equals the underlying power `(a : type α) ^ n`.


theorem Nat.zero_sub : ∀ (n : ℕ), 0 - n = 0 := by sorry

This theorem in Lean 4 states that for any natural number 'n', the result of subtracting 'n' from zero is always zero. In other words, it formalizes the mathematical concept that $0 - n = 0$ for all natural numbers 'n'.


theorem Int.odd_iff_not_even : ∀ {n : ℤ}, Odd n ↔ ¬Even n := by sorry

This theorem states that for all integers `n`, `n` is odd if and only if `n` is not even. Here, an integer `n` is considered odd if there exists an integer `k` such that `n` equals `2*k + 1` and `n` is considered even if there exists an `r` such that `n` equals `r + r`. The theorem establishes the logical equivalence between these two conditions, meaning that `n` cannot be both odd and even at the same time.

An integer `n` is odd if and only if it is not even. Equivalently, `n` is odd if and only if it can be written in the form `2*k + 1` for some integer `k`, and it is even if and only if it can be written in the form `r + r` for some integer `r`.


theorem exists_rat_gt : ∀ {α : Type u_1} [inst : LinearOrderedField α] [inst_1 : Archimedean α] (x : α), ∃ q, x < ↑q :=
  by sorry

This theorem, `exists_rat_gt`, states that for any given number `x` of a type `α`, where `α` is a linearly ordered field with the Archimedean property, there exists a rational number `q` such that `x` is less than `q`. In other words, for any number in an Archimedean field, you can always find a rational number that is greater than it.

For any number `x` in an Archimedean field `α`, there exists a rational number `q` such that `x` < `q`.


theorem Finset.sum_filter :
    ∀ {α : Type u_3} {β : Type u_4} {s : Finset α} [inst : AddCommMonoid β] (p : α → Prop) [inst_1 : DecidablePred p]
      (f : α → β), (Finset.sum (Finset.filter p s) fun a => f a) = Finset.sum s fun a => if p a then f a else 0 :=
  by sorry

This theorem, `Finset.sum_filter`, states that for any finite set `s` of type `α`, any function `f` from `α` to `β` (where `β` is an additive commutative monoid), and any predicate `p` on `α` that is decidable, the sum of `f(a)` over all elements `a` in the subset of `s` that satisfy `p` is equal to the sum of `f(a)` over all elements `a` in `s`, where `f(a)` is taken to be 0 when `a` does not satisfy `p`. In other words, the sum of the values of a function over the elements of a filtered finite set is the same as the sum over the entire set, where the function is zero for elements not in the filter.

For any finite set `s`, function `f` from `α` to an additive commutative monoid `β`, and decidable predicate `p` on `α`, the sum of `f(a)` over elements `a` in `s` that satisfy `p` is equal to the sum of `f(a)` over all elements in `s`, with `f(a)` being 0 for elements not satisfying `p`.


theorem Mathlib.Data.Polynomial.Degree.Definitions._auxLemma.17 :
    ∀ {R : Type u} [inst : Semiring R], Polynomial.Monic 1 = True := by sorry

The theorem `Mathlib.Data.Polynomial.Degree.Definitions._auxLemma.17` states that for any type `R` that has a structure of semiring, the polynomial `1` is monic. This is because a polynomial is defined as monic if its leading coefficient is 1, and the leading coefficient of the polynomial `1` is indeed 1.

For any semiring `R`, the constant polynomial `1` over `R` is monic.


theorem add_sub_add_right_eq_sub : ∀ {G : Type u_3} [inst : AddGroup G] (a b c : G), a + c - (b + c) = a - b := by sorry

This theorem states that for all types `G` that form an additive group, for any three elements `a`, `b`, and `c` of this type, the result of adding `c` to `a`, and then subtracting the result of adding `c` to `b`, is equal to the result of subtracting `b` from `a`. In mathematical notation, this would be represented as `a + c - (b + c) = a - b`.

For all types `G` that form an additive group, the operation of adding and then subtracting is commutative, that is, `a + c - (b + c) = a - b` for all elements `a`, `b`, and `c` in `G`.


theorem Ordinal.typein_enum :
    ∀ {α : Type u} (r : α → α → Prop) [inst : IsWellOrder α r] {o : Ordinal.{u}} (h : o < Ordinal.type r),
      Ordinal.typein r (Ordinal.enum r o h) = o :=
  by sorry

The theorem `Ordinal.typein_enum` states that for any well-ordered set `α` with a well-ordering relation `r`, and for any ordinal `o` that is less than the order type of the relation `r`, the order type of an element (specified by the function `Ordinal.enum`) in the well order is equal to the ordinal `o` itself. In simpler terms, the function `Ordinal.typein` when applied to an element of the well-ordered set, which is obtained via the function `Ordinal.enum` using an ordinal `o`, will return the same ordinal `o`.

For any well-ordered set `(α, r)` and ordinal `o < |r|`, `Ordinal.typein (Ordinal.enum r o α) = o`.


theorem Finset.prod_mul_distrib :
    ∀ {α : Type u_3} {β : Type u_4} {s : Finset α} {f g : α → β} [inst : CommMonoid β],
      (Finset.prod s fun x => f x * g x) = (Finset.prod s fun x => f x) * Finset.prod s fun x => g x :=
  by sorry

The theorem `Finset.prod_mul_distrib` in Lean 4 states that for any given type `α`, another type `β` under a commutative monoid structure, a finite set `s` of `α`, and two functions `f` and `g` from `α` to `β`, the product of the values obtained by multiplying the outputs of `f` and `g` for each element in the set `s` is equal to the product of the outputs of `f` for each element in the set `s`, multiplied by the product of the outputs of `g` for each element in the set `s`. In mathematical terms, this theorem represents the distributive property of multiplication over addition in a commutative monoid: $\prod_{x\in s}(f(x)g(x)) = \left(\prod_{x\in s}f(x)\right)\left(\prod_{x\in s}g(x)\right)$.

For any commutative monoid `β` and functions `f` and `g` from a finite set `s` of a type `α` to `β`, the product of the element-wise products of `f` and `g` equals the product of the `f`-values and the product of the `g`-values over all elements in `s`.


theorem MeasureTheory.L1.SimpleFunc.integrable :
    ∀ {α : Type u_1} {E : Type u_4} [inst : MeasurableSpace α] [inst_1 : NormedAddCommGroup E]
      {μ : MeasureTheory.Measure α} (f : ↥(MeasureTheory.Lp.simpleFunc E 1 μ)),
      MeasureTheory.Integrable (↑(MeasureTheory.Lp.simpleFunc.toSimpleFunc f)) μ :=
  by sorry

This theorem states that for any measurable space `α`, any normed add commutative group `E`, and any measure `μ` on `α`, if `f` is an element of the subspace of `Lp` consisting of equivalence classes of an integrable simple function (i.e., `f` belongs to `MeasureTheory.Lp.simpleFunc E 1 μ`), then the representative function of `f` (given by `MeasureTheory.Lp.simpleFunc.toSimpleFunc f`) is integrable with respect to the measure `μ`. In other words, the representative function is measurable and its norm has a finite integral over `α` with respect to measure `μ`.

For any measurable space `α`, any normed add commutative group `E`, and any measure `μ` on `α`, if `f` is an integrable simple function in `Lp(μ, E)`, then its representative function is an integrable function with respect to `μ`.


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

This theorem states that for any type `G` that is an additive commutative group, given any three elements `a`, `b`, and `c` of the group `G`, `a` minus `b` equals `c` if and only if `a` equals `b` plus `c`. This is a property of additive commutative groups that connects the operation of subtraction with the operation of addition.

For any additive commutative group G and elements a, b, and c in G, a - b = c if and only if a = b + c.


/-- If `s` is a measurable set, then the outer measure of `t` with respect to the restriction of
the measure to `s` equals the outer measure of `t ∩ s`. This is an alternate version of
`Measure.restrict_apply`, requiring that `s` is measurable instead of `t`.  -/
theorem MeasureTheory.Measure.restrict_apply' :
    ∀ {α : Type u_2} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} {s t : Set α},
      MeasurableSet s → ↑↑(μ.restrict s) t = ↑↑μ (t ∩ s) :=
  by sorry

This theorem states that, given two sets `s` and `t` of a certain type `α` (which exists in a measurable space equipped with a measure (`μ`)), if `s` is a measurable set, then the outer measure of `t` with respect to the restriction of the measure to `s` is equal to the outer measure of the intersection of `t` and `s` under the measure `μ`. This gives an alternative version of `Measure.restrict_apply`, where the measurability requirement is placed on `s` rather than `t`. In mathematical terms, it says that for a measurable set `s`, $\mu'(t) = \mu(t \cap s)$, where $\mu'$ is the measure restricted to `s`.

For a measurable set `s` in a measurable space with measure `μ`, the outer measure of `t` under the restriction of `μ` to `s` equals the outer measure of `t ∩ s`.


theorem Cardinal.lt_aleph0 : ∀ {c : Cardinal.{u_1}}, c < Cardinal.aleph0 ↔ ∃ n, c = ↑n := by sorry

The theorem `Cardinal.lt_aleph0` asserts that for any cardinal number `c`, the condition `c` being less than `ℵ₀` (the smallest infinite cardinal, also known as the cardinality of natural numbers) is equivalent to the existence of a natural number `n` such that `c` is equal to the cardinality of `n`. In other words, a cardinal number is less than the smallest infinite cardinal if and only if it corresponds to a finite set.

A cardinal number `c` is less than the first infinite cardinal `ℵ₀` if and only if it is the cardinality of a finite set.


theorem le_mul_of_one_le_left' :
    ∀ {α : Type u_1} [inst : MulOneClass α] [inst_1 : LE α]
      [inst_2 : CovariantClass α α (Function.swap fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1] {a b : α},
      1 ≤ b → a ≤ b * a :=
  by sorry

This theorem states that for any type `α` that is equipped with multiplication operation, identity element for multiplication (`1`), and a less than or equal to order relation (`≤`), and also satisfies the property of covariance with respect to multiplication and the order relation, if a given element `b` of this type is greater than or equal to `1`, then any other element `a` of this type is less than or equal to the product of `b` and `a` (i.e., `b * a`). In mathematical notation, if `α` is a monoid under multiplication with a partial order `≤` that is covariant and `1 ≤ b`, then we have `a ≤ b * a` for all `a` in `α`.

In a monoid `α` with a covariant partial order `≤` and identity element `1`, if `1 ≤ b` then `a ≤ b * a` for all `a` in `α`.


theorem measurable_prod_mk_right :
    ∀ {α : Type u_1} {β : Type u_2} {m : MeasurableSpace α} {mβ : MeasurableSpace β} {y : β},
      Measurable fun x => (x, y) :=
  by sorry

The theorem `measurable_prod_mk_right` states that for any types `α` and `β`, if `α` and `β` are both equipped with a measurable space structure, and for any fixed element `y` of type `β`, the function that takes an element `x` (of type `α`) and maps it to the pair `(x, y)` is a measurable function. In other words, the pre-image of any measurable set under this function is also a measurable set.

For any measurable types `α` and `β`, the function `x ↦ (x, y)` from `α` to `α × β` is measurable for any fixed `y` in `β`.


/-- Adding the first vector passed to `oangle` to the second vector does not change the sign of
the angle.  -/
theorem Orientation.oangle_sign_add_right :
    ∀ {V : Type u_1} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V]
      [inst_2 : Fact (FiniteDimensional.finrank ℝ V = 2)] (o : Orientation ℝ V (Fin 2)) (x y : V),
      Real.Angle.sign (Orientation.oangle o x (x + y)) = Real.Angle.sign (Orientation.oangle o x y) :=
  by sorry

This theorem states that, regardless of the orientation of a real, finite two-dimensional vector space, the sign of the oriented angle from a vector `x` to the vector `x + y` is identical to the sign of the oriented angle from `x` to `y`. In simpler terms, adding a vector `x` to another vector `y` does not change the sign of the angled orientation from `x` to `y`. This theorem is significant in the field of inner product spaces and vector orientations.

The oriented angle from a vector `x` to `y` is equal in sign to the oriented angle from `x` to `(x + y)`.


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

This theorem states that for any two integers `a` and `b`, adding `b` and its negation `-b` to `a` will always result in `a`. In other words, the sum of an integer `a` and the addition of an integer `b` and its negation `-b` will always be `a`. This corresponds to the fact that adding any number with its additive inverse results in zero, hence does not change the value of `a`. In mathematical notation, this is expressed as `a + b + (-b) = a` for all `a`, `b` in the set of integers.

For all integers `a` and `b`, the sum of `a`, `b`, and the negation of `b` equals `a`. In other words, `a + b + (-b) = a`.


theorem norm_nonneg' : ∀ {E : Type u_6} [inst : SeminormedGroup E] (a : E), 0 ≤ ‖a‖ := by sorry

This theorem states that for any type `E` that is a seminormed group, the norm of any element `a` of `E` is nonnegative. In other words, for every element in a seminormed group, its norm is always greater than or equal to zero. This is symbolically represented in LaTeX as, ∀a ∈ E, 0 ≤ ‖a‖.

In a seminormed group, the norm of every element is nonnegative. (∀a ∈ E, 0 ≤ ‖a‖)


theorem Filter.hasBasis_cocompact :
    ∀ {X : Type u} [inst : TopologicalSpace X], Filter.HasBasis (Filter.cocompact X) IsCompact compl := by sorry

The theorem `Filter.hasBasis_cocompact` asserts that for any type `X` equipped with a topological space structure, the filter `cocompact X`, which is generated by the complements of compact sets, has a basis given by the collection of complements of compact sets. In other words, every set in the `cocompact X` filter can be written as a union of complements of compact sets, and for every complement of a compact set, there is a set in the `cocompact X` filter that contains it.

The filter generated by the complements of compact sets in a topological space has a basis consisting of complements of compact sets.


theorem Set.Icc_subset_Icc :
    ∀ {α : Type u_1} [inst : Preorder α] {a₁ a₂ b₁ b₂ : α}, a₂ ≤ a₁ → b₁ ≤ b₂ → Set.Icc a₁ b₁ ⊆ Set.Icc a₂ b₂ := by
  sorry

The theorem `Set.Icc_subset_Icc` states that for any type `α` that has a preorder (a binary relation that is reflexive and transitive), and for any four elements `a₁`, `a₂`, `b₁`, `b₂` of this type, if `a₂` is less than or equal to `a₁` and `b₁` is less than or equal to `b₂`, then the closed interval from `a₁` to `b₁` is a subset of the closed interval from `a₂` to `b₂`. In other words, if we increase the lower bound and decrease the upper bound of an interval, then the resulting interval is a subset of the original one.

For any type `α` with a preorder and `a₁ ≤ a₂` and `b₁ ≤ b₂`, the interval `[a₁, b₁]` is a subset of the interval `[a₂, b₂]`.


theorem Int.ceil_le :
    ∀ {α : Type u_2} [inst : LinearOrderedRing α] [inst_1 : FloorRing α] {z : ℤ} {a : α}, ⌈a⌉ ≤ z ↔ a ≤ ↑z := by sorry

This theorem, `Int.ceil_le`, states that for any type `α` which is a linearly ordered ring and also a floor ring, and any integer `z` and element `a` of type `α`, the ceiling (the smallest integer greater than or equal to `a`) of `a` is less than or equal to `z` if and only if `a` is less than or equal to the integer version of `z`. Essentially, it describes the relationship between the ceiling function and inequality in the context of ordered rings.

For any linearly ordered ring and floor ring type `α`, and integers `z` and `a` of type `α`, `ceil a <= z` if and only if `a <= to_int z`.


theorem Mathlib.Data.Set.Intervals.Basic._auxLemma.42 :
    ∀ {α : Type u} (x : α) (a b : Set α), (x ∈ a ∪ b) = (x ∈ a ∨ x ∈ b) := by sorry

This theorem, named `Mathlib.Data.Set.Intervals.Basic._auxLemma.42`, states that for any type `α`, any element `x` of this type, and any two sets `a` and `b` of this type, `x` belongs to the union of `a` and `b` if and only if `x` belongs to `a` or `x` belongs to `b`. This statement is a formulation of the basic principle of set union in the context of set theory.

For any type `α`, and sets `a` and `b` in `α`, an element `x` belongs to the union of `a` and `b` if and only if `x` is in `a` or `x` is in `b`.


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

This theorem states that for any type `α` that forms a Coheyting Algebra, the set difference (represented by the `\` symbol) of the top element `⊤` and any element `a` from the algebra is equal to the negation (`￢a`) of `a`. In other words, when you remove `a` from the 'whole' (`⊤`), what you get is the 'not' of `a` in a Coheyting Algebra.

In a coatomistic lattice (Coheting Algebra), the set difference between the top element and any element is equal to the negation of that element. Hence, ⊤ \ a = ￢a.


theorem Nat.succ_min_succ : ∀ (x y : ℕ), min (Nat.succ x) (Nat.succ y) = Nat.succ (min x y) := by sorry

This theorem states that for every pair of natural numbers 'x' and 'y', the minimum of the successors of 'x' and 'y' (i.e., 'x+1' and 'y+1') is equal to the successor (i.e., plus one) of the minimum of 'x' and 'y'. In other words, incrementing both numbers and then taking the minimum yields the same result as first taking the minimum and then incrementing.

For all natural numbers x and y, x.succ min x y = y.succ min x y.


theorem CategoryTheory.Limits.IsLimit.map_π :
    ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃}
      [inst_1 : CategoryTheory.Category.{v₃, u₃} C] {F G : CategoryTheory.Functor J C}
      (c : CategoryTheory.Limits.Cone F) {d : CategoryTheory.Limits.Cone G} (hd : CategoryTheory.Limits.IsLimit d)
      (α : F ⟶ G) (j : J),
      CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.IsLimit.map c hd α) (d.π.app j) =
        CategoryTheory.CategoryStruct.comp (c.π.app j) (α.app j) :=
  by sorry

The theorem `CategoryTheory.Limits.IsLimit.map_π` states that for any two categories `J` and `C`, and any two functors `F` and `G` from `J` to `C`, given a cone `c` over the diagram formed by `F`, another cone `d` over the diagram formed by `G`, where `d` is a limit cone, and a natural transformation `α` from `F` to `G`, the composition of the map induced by `c`, `hd`, and `α` with the projection of `d` at `j` equals the composition of the projection of `c` at `j` with the application of `α` at `j`. This statement is about the compatibility of the mapping of limit cones with the projections of the cones.

Given cones $c$ and $d$ over functors $F$ and $G$ from category $J$ to category $C$ with $d$ a limit cone, and a natural transformation $\alpha$ from $F$ to $G$, the maps induced by $c$, $d$, and $\alpha$ commute at each object $j$ in $J$: $(c\_j)^*\alpha\_j = d\_j\circ (F(j) \to G(j))_\alpha$.


theorem Init.Data.Nat.Basic._auxLemma.3 : ∀ (n : ℕ), (n < n) = False := by sorry

This theorem, `Init.Data.Nat.Basic._auxLemma.3`, asserts that for any natural number `n`, the proposition that `n` is less than `n` is false. In other words, no natural number is less than itself.

For all natural numbers n, n is not less than n.


theorem Finset.mem_preimage :
    ∀ {α : Type u} {β : Type v} {f : α → β} {s : Finset β} {hf : Set.InjOn f (f ⁻¹' ↑s)} {x : α},
      x ∈ Finset.preimage s f hf ↔ f x ∈ s :=
  by sorry

The theorem `Finset.mem_preimage` states that for any types `α` and `β`, a mapping `f` from `α` to `β`, a finite set `s` of type `β`, and given that `f` is injective on the preimage of `s`, for any element `x` of type `α`, `x` is within the preimage of `s` under `f` if and only if `f(x)` is in `s`. In simpler terms, it provides a condition to identify whether an element belongs to the preimage of a set under a certain mapping.

Given an injective map `f` from type `α` to type `β`, and a finite set `s` in `β`, an element `x` in `α` is in the preimage of `s` under `f` if and only if `f(x)` is in `s`.


theorem ZeroAtInftyContinuousMap.coe_add :
    ∀ {α : Type u} {β : Type v} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] [inst_2 : AddZeroClass β]
      [inst_3 : ContinuousAdd β] (f g : ZeroAtInftyContinuousMap α β), ⇑(f + g) = ⇑f + ⇑g :=
  by sorry

This theorem states that for any two continuous functions 'f' and 'g' from one topological space 'α' to another 'β' (where 'β' has a zero and an addition operation, and the addition operation is continuous), the addition of the functions 'f' and 'g' (which gives another continuous function from 'α' to 'β') behaves as expected: applying this sum function to an input is the same as separately applying 'f' and 'g' to that input and then adding the results. This is to say, for these continuous functions, addition is preserved under the function application operation.

For any continuous functions $f, g : X \rightarrow Y$ from a topological space $X$ to a topological group $Y$ with a continuous addition operation, the function $h : X \rightarrow Y$ defined by $h(x) = f(x) + g(x)$ is continuous, and for all $x \in X$, $h(x) = f(x) + g(x) = f(x) + g(x)$.


IsOpen.union

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

The theorem `IsOpen.union` states that for any type `X` that has a topological space structure, if `s₁` and `s₂` are sets of elements of type `X` and both `s₁` and `s₂` are open in this topological space, then their union `s₁ ∪ s₂` is also open in this topological space. This is a basic property in topology that the union of two open sets is itself an open set.

If `X` is a topological space and `s₁` and `s₂` are open sets in `X`, then their union `s₁ ∪ s₂` is also an open set in `X`.


minpoly.irreducible

/-- A minimal polynomial is irreducible.  -/
theorem minpoly.irreducible :
    ∀ {A : Type u_1} {B : Type u_2} [inst : CommRing A] [inst_1 : Ring B] [inst_2 : Algebra A B] {x : B}
      [inst_3 : IsDomain A] [inst_4 : IsDomain B], IsIntegral A x → Irreducible (minpoly A x) :=
  by sorry

The theorem `minpoly.irreducible` states that for any commutative ring `A`, any ring `B`, and any element `x` in `B`, if `A` and `B` are integral domains and `x` is integral over `A`, then the minimal polynomial of `x` over `A` is irreducible. In other words, the minimal polynomial cannot be factored into two non-constant polynomials. This is an important property in the theory of field extensions, ensuring that minimal polynomials have a unique factorization, similar to prime numbers in the integers.

Given commutative integral domains A and B, and an element x in B integral over A, the minimal polynomial of x over A is irreducible.


theorem Finset.val_eq_zero : ∀ {α : Type u_1} {s : Finset α}, s.val = 0 ↔ s = ∅ := by sorry

This theorem states that for any set `s` of a generic type `α`, the value of `s` is zero if and only if `s` is an empty set. In other words, it establishes a relationship between the finiteness of a set in Lean 4 and its emptiness. Specifically, a finite set `s` is empty (denoted as ∅) exactly when its value is zero.

A set of type `α` in Lean 4 is empty if and only if its value is equal to the empty set (∅) or zero.


theorem Finset.card_le_univ : ∀ {α : Type u_1} [inst : Fintype α] (s : Finset α), s.card ≤ Fintype.card α := by sorry

The theorem `Finset.card_le_univ` states that for any given type `α` that is a finite type (i.e., has a `Fintype` instance), the number of elements (`card`) in any finite set (`Finset`) `s` of that type will always be less than or equal to the total number of elements in the type `α` itself. This is essentially a statement about the cardinality of subsets in a finite universal set, and corresponds to the intuitive idea that a subset can't be larger than the whole set.

For any finite type `α` and finite set `s` of type `α`, the cardinality of `s` is less than or equal to the cardinality of `α`.


Primrec.encode

theorem Primrec.encode : ∀ {α : Type u_1} [inst : Primcodable α], Primrec Encodable.encode := by sorry

The theorem `Primrec.encode` states that for any type `α` that is primcodable (i.e., it can be encoded as a natural number), the encoding function `Encodable.encode` is primitive recursive. In other words, the process of encoding an element of such a type `α` into a natural number can be defined using a finite set of basic operations and recursion.

For any primcodable type `α`, the encoding function `Encodable.encode α` is primitive recursive.


theorem MeasureTheory.measurable_spanningSets :
    ∀ {α : Type u_1} {m0 : MeasurableSpace α} (μ : MeasureTheory.Measure α) [inst : MeasureTheory.SigmaFinite μ]
      (i : ℕ), MeasurableSet (MeasureTheory.spanningSets μ i) :=
  by sorry

This theorem states that for any measure space `α` with a measurable space structure `m0` and a sigma finite measure `μ`, and for any natural number `i`, the `i`-th set in the sequence of sets that spans the entire space `α` and have finite measure (obtained by `MeasureTheory.spanningSets μ i`) is a measurable set. In other words, every set in this sequence of spanning sets is measurable.

For any measure space `(α, m0, μ)` and natural number `i`, the `i`-th set in the sequence of measurable sets with finite measure spanning `α` (obtained by `MeasureTheory.spanningSets μ i`) is measurable.


theorem UniformSpace.Completion.extension_coe :
    ∀ {α : Type u_1} [inst : UniformSpace α] {β : Type u_2} [inst_1 : UniformSpace β] {f : α → β} [inst_2 : T0Space β],
      UniformContinuous f → ∀ (a : α), UniformSpace.Completion.extension f (↑α a) = f a :=
  by sorry

This theorem states that for any types `α` and `β` which are uniform spaces, and for any function `f` from `α` to `β` which is uniformly continuous, then the extension of `f` to the completion of `α` evaluated at any point `a` of `α` (notated as `↑α a`) is equal to `f` evaluated at `a`. This essentially means that when `f` is uniformly continuous, its extension to the completion of `α` acts exactly like `f` on the original points of `α`. Furthermore, the theorem assumes that `β` is a T0 space, which is a separation axiom in topology that says for any two distinct points in `β`, there exists an open set containing one of them but not the other.

If `α` and `β` are uniform spaces, `f : α → β` is uniformly continuous, and `β` is T0, then for any `a : α`, `f (↑α a) = f a`.


theorem Linarith.mul_neg : ∀ {α : Type u_1} [inst : StrictOrderedRing α] {a b : α}, a < 0 → 0 < b → b * a < 0 := by
  sorry

This theorem, `Linarith.mul_neg`, states that for any strict ordered ring `α`, if we have two elements `a` and `b` of this ring, if `a` is less than zero and `b` is greater than zero, then the product of `b` and `a` is less than zero. Here, a strict ordered ring is a ring that also has a total order compatible with the ring operations (addition and multiplication).

In a strict ordered ring, the product of two elements with one being negative and the other positive is negative.


theorem List.ext_get :
    ∀ {α : Type u_1} {l₁ l₂ : List α},
      List.length l₁ = List.length l₂ →
        (∀ (n : ℕ) (h₁ : n < List.length l₁) (h₂ : n < List.length l₂),
            List.get l₁ { val := n, isLt := h₁ } = List.get l₂ { val := n, isLt := h₂ }) →
          l₁ = l₂ :=
  by sorry

The theorem `List.ext_get` states that for any two lists `l₁` and `l₂` of the same type `α`, if the length of `l₁` is equal to the length of `l₂` and for every natural number `n` less than the length of `l₁` and `l₂`, the `n`-th element of `l₁` is equal to the `n`-th element of `l₂`, then `l₁` is equal to `l₂`. In other words, two lists are considered equal if they have the same length and their corresponding elements are equal.

If two lists of the same type have the same length and agree in their elements up to every position, then they are equal.


theorem PartialHomeomorph.right_inv :
    ∀ {X : Type u_1} {Y : Type u_3} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y]
      (e : PartialHomeomorph X Y) {x : Y}, x ∈ e.target → ↑e (↑(PartialHomeomorph.symm e) x) = x :=
  by sorry

The theorem `PartialHomeomorph.right_inv` states that for any two topological spaces `X` and `Y`, along with a partial homeomorphism `e` from `X` to `Y`, if a point `x` belongs to the target set of `e`, then applying `e` to the inverse of `x` under the symmetry operation of `e` (denoted by `PartialHomeomorph.symm e`) will give back `x`. In other words, the partial homeomorphism `e` and its inverse `PartialHomeomorph.symm e` cancel each other on the target set of `e`, acting as the right inverse of each other.

For any partial homeomorphisms $e: X \rightarrow Y$ and $x \in \operatorname{rge}(e)$, we have $e(\operatorname{symm}_e(x)) = x$, where $\operatorname{symm}_e(x)$ denotes the symmetry of $x$ with respect to $e$.