/-- NB: `Nat.card` is defined to be `0` for infinite types.  -/
theorem Finite.card_eq_zero_of_embedding :
    ∀ {α : Type u_1} {β : Type u_2} [inst : Nonempty α], (α ↪ β) → Nat.card α = 0 → Nat.card β = 0 := by sorry

This theorem states that for any two types `α` and `β` with `α` being nonempty, if there exists an injective function (embedding) from `α` to `β`, and the cardinality of `α` (as computed by `Nat.card`) is 0, then the cardinality of `β` must also be 0. The cardinality, as computed by `Nat.card`, is the size of the set, but it is defined to be 0 for infinite sets. Thus, this theorem is saying that if `α` is infinite and there exists an injective map from `α` to `β`, then `β` must also be infinite.

If `α` is a nonempty type with an injective function to an infinite `β`, then `β` is also infinite.


theorem Real.log_pow : ∀ (x : ℝ) (n : ℕ), Real.log (x ^ n) = ↑n * Real.log x := by sorry

This theorem states that for every real number `x` and natural number `n`, the logarithm of `x` to the power of `n` is equal to `n` times the logarithm of `x`. In mathematical notation, this would be written as: $\log(x^n) = n \cdot \log(x)$. This property is essential in simplifying logarithmic expressions and is widely used in mathematical analysis and computations.

For all real numbers x and natural numbers n, log(x^n) = n * log(x).


theorem AlgebraicGeometry.PropertyIsLocalAtTarget.openCover_iff :
    ∀ {P : CategoryTheory.MorphismProperty AlgebraicGeometry.Scheme},
      AlgebraicGeometry.PropertyIsLocalAtTarget P →
        ∀ {X Y : AlgebraicGeometry.Scheme} (f : X ⟶ Y) (𝒰 : AlgebraicGeometry.Scheme.OpenCover Y),
          P f ↔ ∀ (i : 𝒰.J), P CategoryTheory.Limits.pullback.snd :=
  by sorry

The theorem `AlgebraicGeometry.PropertyIsLocalAtTarget.openCover_iff` states that for any morphism property `P` in the category of algebraic schemes, if `P` is local at the target, then for any two algebraic schemes `X` and `Y` and any morphism `f` from `X` to `Y` and an open cover `𝒰` of `Y`, then the property `P` holds for the morphism `f` if and only if `P` holds for the second projection of the pullback (`CategoryTheory.Limits.pullback.snd`) for every index `i` in the index set of the open cover `𝒰`. In other words, a property of a morphism between algebraic schemes is local at the target if it holds for a morphism if and only if it holds for the second projection of the pullback over all elements of any open cover of the target scheme.

For any morphism property in the category of algebraic schemes, if it is local at the target, then the property holds for the morphism if and only if it holds for the second projection of the pullback over every index in the open cover of the target scheme.


theorem WithTop.sub_top : ∀ {α : Type u_1} [inst : Sub α] [inst_1 : Zero α] {a : WithTop α}, a - ⊤ = 0 := by sorry

The theorem `WithTop.sub_top` states that for any type `α` that has subtraction (`Sub α`) and zero (`Zero α`) operations defined, subtracting the top element `⊤` from any element `a` of the type `WithTop α` (which is essentially the type `α` augmented with an additional top element `⊤`), will always result in zero. This theorem is valid irrespective of the specific element `a` chosen from the `WithTop α` type.

For any type `α` with subtraction and zero operations, `⊤ - a = Zero α` for all `a` in `WithTop α`.


theorem Mathlib.Combinatorics.SetFamily.Compression.Down._auxLemma.2 :
    ∀ {α : Type u_1} {β : Type u_2} [inst : DecidableEq β] {f : α → β} {s : Finset α} {b : β},
      (b ∈ Finset.image f s) = ∃ a ∈ s, f a = b :=
  by sorry

This theorem states that for any types `α` and `β` with a decidable equality on `β`, a function `f` from `α` to `β`, a finite set `s` of elements of type `α`, and an element `b` of type `β`, `b` is in the image of `s` under `f` if and only if there exists an element `a` in `s` such that `f(a)` equals `b`. This theorem thus characterizes the image of a finite set under a function in terms of the function's values on the elements of the set.

For any decidable type `β`, finite set `s` of elements from type `α`, and function `f` from `α` to `β`, an element `b` is in the image of `s` under `f` if and only if there exists an element `a` in `s` such that `f(a) = b`.


theorem IsOpenMap.image_mem_nhds :
    ∀ {X : Type u_1} {Y : Type u_2} {f : X → Y} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y],
      IsOpenMap f → ∀ {x : X} {s : Set X}, s ∈ nhds x → f '' s ∈ nhds (f x) :=
  by sorry

This theorem states that for any types `X` and `Y`, and a function `f` mapping `X` to `Y`, given that `X` and `Y` are topological spaces and `f` is an open map, for any point `x` in `X` and any set `s` that is a neighborhood of `x`, the image of `s` under `f` is a neighborhood of the image of `x` under `f`. In simpler terms, if `s` is close to `x`, then `f(s)` is close to `f(x)`, assuming `f` is an open mapping between the topological spaces.

Given topological spaces X and Y and an open map f from X to Y, for all x in X and every neighborhood s of x, the image f(s) is a neighborhood of f(x).


theorem Mathlib.Algebra.Order.Monoid.WithTop._auxLemma.21 :
    ∀ {α : Type u} [inst : Add α] {a b : WithTop α}, (a + b = ⊤) = (a = ⊤ ∨ b = ⊤) := by sorry

This theorem states that for any given type `α` which has an addition operation (`Add α`), and for any two elements `a` and `b` of the type `WithTop α` (which is essentially the type `α` plus an additional element `⊤`), the sum `a + b` equals `⊤` if and only if either `a` equals `⊤` or `b` equals `⊤`.

For any type `α` with addition and for any `a, b ∈ WithTop α`, the sum `a + b` equals `⊤` if and only if `a = ⊤` or `b = ⊤`.


theorem Metric.isOpen_iff :
    ∀ {α : Type u} [inst : PseudoMetricSpace α] {s : Set α}, IsOpen s ↔ ∀ x ∈ s, ∃ ε > 0, Metric.ball x ε ⊆ s := by
  sorry

The theorem `Metric.isOpen_iff` is a characterization of open sets in a pseudometric space. It states that for any type `α` with a pseudometric space structure and for any set `s` of type `α`, the set `s` is open if and only if for every element `x` in `s`, there exists a number `ε` greater than zero such that the open ball centered at `x` with radius `ε` is a subset of `s`. In other words, every point in an open set is the center of some open ball completely contained in the set.

A subset of a pseudometric space is open if and only if each of its points is the center of some open ball entirely contained within the subset.


theorem NNReal.tendsto_coe :
    ∀ {α : Type u_1} {f : Filter α} {m : α → NNReal} {x : NNReal},
      Filter.Tendsto (fun a => ↑(m a)) f (nhds ↑x) ↔ Filter.Tendsto m f (nhds x) :=
  by sorry

This theorem states that for any type `α`, any filter on `α` named `f`, any function `m` from `α` to the nonnegative real numbers `NNReal`, and any nonnegative real number `x`, the function `m` tends towards `x` with respect to the filter `f` if and only if the real part of the function `m`, denoted by `(fun a => ↑(m a))`, tends towards the real part of `x` with respect to the filter `f`. This basically connects the limit concepts in the context of nonnegative real numbers and their real counter-part.

For any type `α`, filter `f` on `α`, function `m` from `α` to `NNReal`, and real number `x`, the function `m` tends towards `x` with respect to `f` if and only if the real part of `m` tends towards the real part of `x` with respect to `f`.


CategoryTheory.OplaxNatTrans.ext

theorem CategoryTheory.OplaxNatTrans.ext :
    ∀ {B : Type u₁} [inst : CategoryTheory.Bicategory B] {C : Type u₂} [inst_1 : CategoryTheory.Bicategory C]
      {F G : CategoryTheory.OplaxFunctor B C} {α β : F ⟶ G} {m n : α ⟶ β}, (∀ (b : B), m.app b = n.app b) → m = n :=
  by sorry

This theorem states that in the context of bicategories and oplax functors, if two natural transformations `α` and `β` between oplax functors `F` and `G` have two morphisms `m` and `n` from `α` to `β` such that the application of `m` and `n` to any object `b` in the bicategory `B` gives the same result, then `m` and `n` are the same morphism. This theorem is a statement about the uniqueness of morphisms between natural transformations in the setting of oplax functors. The theorem holds for any types `B` and `C` that form bicategories.

In the context of bicategories and oplax functors, if two natural transformations between them have morphisms making all component maps equal, then those morphisms are equal.


theorem Nat.pow_lt_pow_left : ∀ {a b : ℕ}, a < b → ∀ {n : ℕ}, n ≠ 0 → a ^ n < b ^ n := by sorry

This theorem states that for any two natural numbers 'a' and 'b', if 'a' is less than 'b', then 'a' raised to any non-zero natural number 'n' will be less than 'b' raised to the 'n'. In other words, for all natural numbers 'a', 'b', and 'n', where 'a' is less than 'b' and 'n' is not zero, $a^n$ is less than $b^n$.

For all natural numbers $a, b, n$ with $a < b$ and $n \neq 0$, $a^n < b^n$.


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

This theorem states that for any type `α` that has a structure of a partial order and a bottom element, every element `a` of `α` is disjoint with the bottom element of `α`. Here, two elements of a lattice are defined as disjoint if their greatest lower bound (infimum) is the bottom element. This concept generalizes the idea of disjoint sets, viewed as members of the subset lattice.

For any partial order type `α` with a bottom element, every element `a` is disjoint from the bottom element, i.e., their infimum is the bottom element.


ContinuousLinearMap.isBoundedLinearMap

/-- A continuous linear map satisfies `IsBoundedLinearMap`  -/
theorem ContinuousLinearMap.isBoundedLinearMap :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F]
      (f : E →L[𝕜] F), IsBoundedLinearMap 𝕜 ⇑f :=
  by sorry

This theorem states that for any continuous linear map `f` from a normed vector space `E` over a nontrivially normed field `𝕜` to another normed vector space `F` over the same field, `f` satisfies the property of a bounded linear map. Here, 'bounded' means that there is a constant C such that the norm of `f(x)` is less than or equal to C times the norm of `x` for all `x` in `E`.

For any continuous linear map `f` from a normed vector space `E` to another normed vector space `F` over the same nontrivially normed field, `f` is a bounded linear map with a constant `C` such that `‖f(x)‖ ≤ C * ‖x‖ for all `x` in `E`.


theorem List.chain'_iff_get :
    ∀ {α : Type u} {R : α → α → Prop} {l : List α},
      List.Chain' R l ↔
        ∀ (i : ℕ) (h : i < List.length l - 1),
          R (List.get l { val := i, isLt := ⋯ }) (List.get l { val := i + 1, isLt := ⋯ }) :=
  by sorry

The theorem `List.chain'_iff_get` states that for any given type `α`, a binary relation `R` on `α`, and list `l` of type `α`, the relation `R` forms a chain on `l` if and only if the relation `R` holds between any element at index `i` and its successor at index `i + 1` for all `i` such that `i` is less than the length of the list minus one. Here, `List.get l { val := i, isLt := ⋯ }` retrieves the element at index `i` in the list `l` and `List.Chain' R l` denotes that `R` holds between adjacent elements in `l`.

For any type `α` and list `l` of length `n` over `α`, the relation `R` is a chain on `l` if and only if `R(l(i), l(i+1))` holds for all `0 ≤ i < n-1`.


theorem finsum_eq_sum :
    ∀ {α : Type u_1} {M : Type u_5} [inst : AddCommMonoid M] (f : α → M) (hf : Set.Finite (Function.support f)),
      (finsum fun i => f i) = Finset.sum (Set.Finite.toFinset hf) fun i => f i :=
  by sorry

This theorem states that for any type `α` and `M`, given that `M` has an addition that is both commutative and associative, and a function `f : α → M`, if the set of elements `α` for which `f` is non-zero (the support of `f`) is finite, then the sum of `f(x)` for all `x` in the domain is equal to the sum of `f(x)` for all `x` in the finite set that represents the support of `f`. In mathematical terms, this theorem says that ∑ f(x) (where the sum ranges over all x) equals ∑ f(x) (where the sum only ranges over x in the support of f), provided the support of f is a finite set.

If `α` is a finite type with a commutative and associative addition, and `f : α → M` is a function with finite support, then the sum of `f(x)` over all `x` in `α` equals the sum of `f(x)` over the finite support of `f`.


theorem Set.Ico_subset_Iio_self : ∀ {α : Type u_1} [inst : Preorder α] {a b : α}, Set.Ico a b ⊆ Set.Iio b := by sorry

The theorem `Set.Ico_subset_Iio_self` states that for any type `α` equipped with a preorder, and any two elements `a` and `b` of type `α`, the left-closed right-open interval from `a` to `b`, denoted `Set.Ico a b`, is a subset of the left-infinite right-open interval ending at `b`, denoted `Set.Iio b`. In other words, all elements `x` satisfying `a ≤ x < b` are also elements satisfying `x < b`.

For any preordered type `α` and elements `a < b` in `α`, the left-closed right-open interval `Set.Ico a b` is a subset of the left-infinite right-open interval `Set.Iio b`.


Continuous.surjective

/-- A continuous function which tendsto `Filter.atTop` along `Filter.atTop` and to `atBot` along
`at_bot` is surjective.  -/
theorem Continuous.surjective :
    ∀ {α : Type u} [inst : ConditionallyCompleteLinearOrder α] [inst_1 : TopologicalSpace α] [inst_2 : OrderTopology α]
      [inst_3 : DenselyOrdered α] {δ : Type u_1} [inst_4 : LinearOrder δ] [inst_5 : TopologicalSpace δ]
      [inst_6 : OrderClosedTopology δ] {f : α → δ},
      Continuous f →
        Filter.Tendsto f Filter.atTop Filter.atTop →
          Filter.Tendsto f Filter.atBot Filter.atBot → Function.Surjective f :=
  by sorry

This theorem asserts that if you have a continuous function `f` from a type `α` to another type `δ` and both `α` and `δ` are equipped with a conditionally complete linear order, a topological space structure, and an order topology, and `α` is densely ordered, and `δ` has an order-closed topology, then if the function `f` has the property that it tends to infinity (`Filter.atTop`) along the infinite sequence in `α` (`Filter.atTop`), and tends to negative infinity (`Filter.atBot`) along the sequence tending to negative infinity in `α` (`Filter.atBot`), then `f` is a surjective function. In other words, for every element in `δ`, there exists an element in `α` such that `f` maps this element in `α` to that specific element in `δ`.

If `f` is a continuous function from a densely ordered, conditionally complete linear order `α` with an order topology and an order-closed topology to another such order `δ`, and `f` tends to infinity on sequences tending to infinity in `α` and to negative infinity on sequences tending to negative infinity in `α`, then `f` is surjective.


theorem measurable_of_measurable_on_compl_singleton :
    ∀ {α : Type u_1} {β : Type u_2} {m : MeasurableSpace α} {mβ : MeasurableSpace β} [inst : MeasurableSingletonClass α]
      {f : α → β} (a : α), Measurable (Set.restrict {x | x ≠ a} f) → Measurable f :=
  by sorry

The theorem `measurable_of_measurable_on_compl_singleton` states that for any types `α` and `β`, any measurable spaces `m` over `α` and `mβ` over `β`, any measurable singleton class over `α`, and any function `f` from `α` to `β`, if the restriction of the function `f` to the set of all elements in `α` that are not equal to a given element `a` (denoted as `{x | x ≠ a}`) is measurable, then the function `f` itself is measurable. This means that if we know the behavior of a function on all elements except for one, and that behavior is measurable, then the function itself is measurable.

If a function between measurable spaces is measurable on the complement of a single element, then it is measurable.


theorem ge_iff_le : ∀ {α : Type u} [inst : LE α] {x y : α}, x ≥ y ↔ y ≤ x := by sorry

This theorem, `ge_iff_le`, states that for all types `α` equipped with a less than or equal to (`≤`) ordering, and for any two elements `x` and `y` of type `α`, `x` is greater than or equal to `y` if and only if `y` is less than or equal to `x`. This is a universal property of ordered sets, and is essentially a restatement of the definition of "greater than or equal to" in terms of "less than or equal to".

For all types `α` with a `≤` ordering, `x ≤ y` if and only if `y ≤ x`.


theorem Filter.cocompact_eq_cofinite :
    ∀ (X : Type u_2) [inst : TopologicalSpace X] [inst_1 : DiscreteTopology X], Filter.cocompact X = Filter.cofinite :=
  by sorry

This theorem states that for any type `X`, given a topological space structure and a discrete topology on `X`, the filter generated by complements to compact sets in `X` (`Filter.cocompact X`) is equal to the cofinite filter (`Filter.cofinite`). The cofinite filter is the filter of subsets whose complements are finite. This means in such a discrete topological space, the complements of compact sets form a collection of sets where each complement set is finite.

In a discrete topological space, the filter of complements to compact sets is equal to the cofinite filter.


theorem Complex.sin_zero : Complex.sin 0 = 0 := by sorry

This theorem states that the sine of zero in the complex number system is zero. In other words, when we apply the complex sine function, as defined through the exponential function, to the number zero, the result is zero.

The complex sine function evaluates to zero at zero. (sin(0) = 0 in the complex numbers)


theorem inv_mul_cancel_right₀ :
    ∀ {G₀ : Type u_3} [inst : GroupWithZero G₀] {b : G₀}, b ≠ 0 → ∀ (a : G₀), a * b⁻¹ * b = a := by sorry

This theorem states that for any non-zero element `b` of a group with zero `G₀`, and for any element `a` of the same group, the product of `a`, the inverse of `b` and `b` is equal to `a`. This essentially captures the property that multiplying by an element and its inverse (in the given order) in a group with zero acts as an identity operation.

For any group with zero `G₀` and any `a, b` in `G₀^*, a * b^(-1) * b = a`, where `*` denotes group multiplication and `^(-1)` denotes group inversion.


theorem Mathlib.Analysis.SpecialFunctions.Log.Basic._auxLemma.3 :
    ∀ {x : ℝ}, (Real.log x = 0) = (x = 0 ∨ x = 1 ∨ x = -1) := by sorry

This theorem states that for any real number 'x', the logarithm of 'x' equals to zero if and only if 'x' equals to zero, one, or negative one. This means, apart from 0, 1 and -1, the logarithm of any other real number will not be zero. This is in the context of the Real.log function in Lean 4, which is defined as the inverse of the exponential for positive numbers, the logarithm of the absolute value for negative numbers, and zero for zero.

For any real number x, x = 0, 1, or -1 if and only if log(x) = 0.


/-- If a filter `f` is majorated by some `𝓝 x`, then it is majorated by `𝓝 (Filter.lim f)`. We
formulate this lemma with a `[Nonempty X]` argument of `lim` derived from `h` to make it useful for
types without a `[Nonempty X]` instance. Because of the built-in proof irrelevance, Lean will unify
this instance with any other instance.  -/
theorem le_nhds_lim :
    ∀ {X : Type u} [inst : TopologicalSpace X] {f : Filter X} (h : ∃ x, f ≤ nhds x), f ≤ nhds (lim f) := by sorry

This theorem states that given a filter `f` in a topological space `X` such that there exists an element `x` in `X` for which the filter `f` is majorated by the neighborhood filter at `x` (meaning that `f` is contained in `nhds x`), then this filter `f` is also majorated by the neighborhood filter at `Filter.lim f` (the limit of filter `f`). The theorem requires that `X` is nonempty, with the nonemptiness derived from `h`. This is written in a way that makes it usable for types that don't already have a `Nonempty X` instance. Due to proof irrelevance in Lean, this instance will be congruent with any other instance.

If a filter `f` in a nonempty topological space `X` is majorated by the neighborhood filter of an element `x` in `X`, then `f` is majorated by the neighborhood filter of the limit of `f`.


/-- Specialization of `Finset.prod_nbij'` that automatically fills in most arguments.

See `Fintype.prod_equiv` for the version where `s` and `t` are `univ`.  -/
theorem Finset.prod_equiv :
    ∀ {ι : Type u_6} {κ : Type u_7} {α : Type u_8} [inst : CommMonoid α] {s : Finset ι} {t : Finset κ} {f : ι → α}
      {g : κ → α} (e : ι ≃ κ),
      (∀ (i : ι), i ∈ s ↔ e i ∈ t) →
        (∀ i ∈ s, f i = g (e i)) → (Finset.prod s fun i => f i) = Finset.prod t fun i => g i :=
  by sorry

The `Finset.prod_equiv` theorem states that for any types `ι`, `κ`, and `α` where `α` is a commutative monoid, given two finite sets `s` and `t` with elements from `ι` and `κ` respectively, functions `f : ι → α` and `g : κ → α`, and a bijective function `e : ι ≃ κ`, if for every element `i` in `s`, `i` maps to an element in `t` under `e`, and the function `f` applied to `i` is equal to the function `g` applied to `e(i)`, then the product of `f(i)` as `i` ranges over the elements of `s` is equal to the product of `g(i)` as `i` ranges over the elements of `t`. This theorem generalizes the idea that changing the labels of the elements does not change the product of a sequence.

Given finite sets `s` and `t` from type `Finset ι` and `Finset κ`, bijective function `e : ι ≃ κ`, functions `f : ι → α` and `g : κ → α` such that `f i = g (e i)` for all `i` in `s`, the product of `f` over `s` equals the product of `g` over `t`.


MeasureTheory.NullMeasurableSet.congr

theorem MeasureTheory.NullMeasurableSet.congr :
    ∀ {α : Type u_2} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} {s t : Set α},
      MeasureTheory.NullMeasurableSet s μ → s =ᶠ[MeasureTheory.Measure.ae μ] t → MeasureTheory.NullMeasurableSet t μ :=
  by sorry

This theorem states that for any type `α` equipped with a measurable space and a measure `μ`, and any two sets `s` and `t` of type `α`, if `s` is a null measurable set with respect to `μ`, and `s` equals `t` almost everywhere (i.e., except for a set of null measure), then `t` is also a null measurable set with respect to `μ`. In other words, it says that the property of being a null measurable set is preserved under equality almost everywhere.

If two sets have the same elements almost everywhere and are null measurable with respect to a measure, then each is null measurable.


theorem Disjoint.sup_sdiff_cancel_right :
    ∀ {α : Type u_2} [inst : GeneralizedCoheytingAlgebra α] {a b : α}, Disjoint a b → (a ⊔ b) \ b = a := by sorry

This theorem states that for any generalized Coheyting algebra, if two elements `a` and `b` are disjoint (that is, any element that is less than or equal to both `a` and `b` is also less than or equal to the bottom element), then the result of the operation of taking the supremum (or join) of `a` and `b` and then subtracting `b` (denoted as `(a ⊔ b) \ b`) is equal to `a`. Essentially, in the context of a generalized Coheyting algebra, if `a` and `b` are disjoint, subtracting `b` from the union of `a` and `b` leaves `a` untouched.

In a generalized Cohesion algebra, if `a` and `b` are disjoint, then `(a ⊔ b) \ b = a`.


TopologicalSpace.OpenNhds.openEmbedding

theorem TopologicalSpace.OpenNhds.openEmbedding :
    ∀ {X : TopCat} {x : ↑X} (U : TopologicalSpace.OpenNhds x),
      OpenEmbedding ⇑(TopologicalSpace.Opens.inclusion U.obj) :=
  by sorry

This theorem states that for any topological space 'X' and any point 'x' in 'X', if 'U' is an open neighborhood of 'x' in 'X', then the function given by the inclusion of 'U' into 'X' is an open embedding. An open embedding is a function that is both an embedding and an open map, meaning it injectively maps 'U' into 'X' while preserving the topology, i.e., the open subsets of 'U' are mapped to open subsets of 'X'.

Given any topological space 'X' and point 'x' in 'X', if 'U' is an open neighborhood of 'x', then the inclusion function from 'U' to 'X' is a topological embedding. (A topological embedding is an open and injective function that preserves the topology.)


theorem NonUnitalAlgebra.subset_adjoin :
    ∀ (R : Type u) {A : Type v} [inst : CommSemiring R] [inst_1 : NonUnitalNonAssocSemiring A] [inst_2 : Module R A]
      [inst_3 : IsScalarTower R A A] [inst_4 : SMulCommClass R A A] {s : Set A}, s ⊆ ↑(NonUnitalAlgebra.adjoin R s) :=
  by sorry

The theorem `NonUnitalAlgebra.subset_adjoin` states that for any commutative semiring `R` and any non-unital non-associative semiring `A`, where `A` is a module over `R` and `R` and `A` form a scalar tower, and `R` and `A` are commutative under scalar multiplication, any set `s` of elements from `A` is a subset of the set obtained by adjoining `s` to the non-unital algebra over `R`. In other words, all elements of `s` are included in the non-unital algebra generated by `s` over `R`.

For any commutative semiring `R`, commutative non-unital non-associative semiring `A` that is a module over `R` and forms a scalar tower with `R`, if `s` is a subset of `A`, then `s` is included in the non-unital algebra generated by `s` over `R`.


theorem Real.neg_pi_div_two_le_arcsin : ∀ (x : ℝ), -(Real.pi / 2) ≤ Real.arcsin x := by sorry

This theorem states that for every real number 'x', the value of the arcsine function at 'x' is always greater than or equal to negative pi divided by 2. This is essentially stating the lower bound of the range of the arcsine function in the real number system.

For all real numbers x, arcsin x ≥ -π/2.


theorem UniqueFactorizationMonoid.dvd_of_mem_normalizedFactors :
    ∀ {α : Type u_1} [inst : CancelCommMonoidWithZero α] [inst_1 : NormalizationMonoid α]
      [inst_2 : UniqueFactorizationMonoid α] {a p : α}, p ∈ UniqueFactorizationMonoid.normalizedFactors a → p ∣ a :=
  by sorry

The theorem `UniqueFactorizationMonoid.dvd_of_mem_normalizedFactors` states that for any type `α` that has instances of `CancelCommMonoidWithZero`, `NormalizationMonoid`, and `UniqueFactorizationMonoid`, if element `p` is in the multiset of normalized factors of `a` (i.e., `p` is a normalized prime factor of `a`), then `p` divides `a`. In other words, every normalized prime factor of a number divides that number.

For any type `α` with instances of `CancelCommMonoidWithZero`, `NormalizationMonoid`, and `UniqueFactorizationMonoid`, every normalized prime factor `p` of an element `a` is a divisor of `a`.


theorem MeasureTheory.average_neg :
    ∀ {α : Type u_1} {E : Type u_2} {m0 : MeasurableSpace α} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E]
      (μ : MeasureTheory.Measure α) (f : α → E), ⨍ (x : α), -f x ∂μ = -⨍ (x : α), f x ∂μ :=
  by sorry

This theorem states that for any measure space `α` and any normed commutative addition group `E` that is a normed space over the real numbers, if we have a measure `μ` on `α` and a function `f` from `α` to `E`, the integral of the negative of `f` with respect to `μ` is equal to the negative of the integral of `f` with respect to `μ`. Essentially, negating a function and then integrating it, or integrating the function first and then negating, yield the same result.

For any measure space `α`, any normed commutative addition group `E` over the real numbers, and any function `f` from `α` to `E`, we have `∫(-f) dμ = -∫(f) dμ`.


/-- A variant of `Ring.inverse_unit`.  -/
theorem Ring.inverse_invertible :
    ∀ {α : Type u} [inst : MonoidWithZero α] (x : α) [inst_1 : Invertible x], Ring.inverse x = ⅟x := by sorry

This theorem, `Ring.inverse_invertible`, states that for any type `α` that has a structure of a monoid with zero, for any element `x` of `α` that's invertible, the `Ring.inverse` operation applied to `x` yields the multiplicative inverse of `x`, written as `⅟x`. In other words, if we have an invertible element in a monoid with zero, the `Ring.inverse` function acts as the standard inversion operation.

For any monoid with zero `α` and invertible element `x` in `α`, `Ring.inverse x = ⅟x`.


theorem Quaternion.mul_re :
    ∀ {R : Type u_3} [inst : CommRing R] (a b : Quaternion R),
      (a * b).re = a.re * b.re - a.imI * b.imI - a.imJ * b.imJ - a.imK * b.imK :=
  by sorry

This theorem states that for any commutative ring `R` and any two quaternions `a` and `b` over `R`, the real part (`re`) of the product of `a` and `b` is calculated as the product of their real parts minus the product of their i-component imaginary parts, minus the product of their j-component imaginary parts, minus the product of their k-component imaginary parts. This is essentially the multiplication rule for quaternions.

For any commutative ring `R` and quaternions `a` and `b` over `R`, the real part of their product `(a * b).re` is equal to `(a.re * b.re) - (a.i * b.i) - (a.j * b.j) - (a.k * b.k)`.


theorem minpoly.dvd_map_of_isScalarTower :
    ∀ (A : Type u_3) (K : Type u_4) {R : Type u_5} [inst : CommRing A] [inst_1 : Field K] [inst_2 : CommRing R]
      [inst_3 : Algebra A K] [inst_4 : Algebra A R] [inst_5 : Algebra K R] [inst_6 : IsScalarTower A K R] (x : R),
      minpoly K x ∣ Polynomial.map (algebraMap A K) (minpoly A x) :=
  by sorry

The theorem `minpoly.dvd_map_of_isScalarTower` states that for any types `A`, `K` and `R` with `A` being a commutative ring, `K` being a field and `R` being a commutative ring, and given the algebra structures of `A` over `K`, `A` over `R`, and `K` over `R` and the fact that a scalar tower exists between `A`, `K`, and `R`. For any element `x` of `R`, the minimum polynomial of `x` over `K` divides the result of mapping the minimum polynomial of `x` over `A` through the algebra map from `A` to `K`. In other words, this theorem establishes a divisibility relationship between the minimum polynomial of `x` in different algebraic structures, under the mapping of those polynomials by the algebra map, when the algebraic structures form a scalar tower.

Given a scalar tower of commutative rings `A` over `K` and `K` over `R`, and an element `x` of `R`, the minimum polynomial of `x` over `K` divides the minimum polynomial of `x` mapped through the algebra homomorphism from `A` to `K`.


theorem Polynomial.map_expand :
    ∀ {R : Type u} [inst : CommSemiring R] {S : Type v} [inst_1 : CommSemiring S] {p : ℕ} {f : R →+* S}
      {q : Polynomial R}, Polynomial.map f ((Polynomial.expand R p) q) = (Polynomial.expand S p) (Polynomial.map f q) :=
  by sorry

The theorem `Polynomial.map_expand` states that for any commutative semirings `R` and `S`, any natural number `p`, any ring homomorphism `f` from `R` to `S`, and any polynomial `q` over `R`, mapping the polynomial `q` expanded by a factor of `p` across the ring hom `f` is the same as expanding the polynomial obtained by mapping `q` across `f` by a factor of `p`. In other words, the operations of `Polynomial.map f` and `Polynomial.expand p` commute.

For any commutative semirings R and S, natural number p, ring homomorphism f from R to S, and polynomial q over R, the expanded polynomial q with respect to p, mapped over f, is equal to the mapped polynomial obtained by expanding f(q) by p.


theorem hasStrictDerivAt_id : ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] (x : 𝕜), HasStrictDerivAt id 1 x := by
  sorry

This theorem states that the identity function has a strict derivative of 1 at any point `x` in the domain of a nontrivially normed field. In mathematical terms, the derivative of the identity function is always 1, which is expressed in the theorem as `HasStrictDerivAt id 1 x`. Thus, in the limit as `y` and `z` approach `x`, the difference between the values of the identity function at `y` and `z` is equal to the difference between `y` and `z`, plus a term that tends to zero faster than `y - z`.

The identity function over a nontrivially normed field has a strict derivative equal to 1 at every point.


IsLocallyConstant.tfae

theorem IsLocallyConstant.tfae :
    ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] (f : X → Y),
      List.TFAE
        [IsLocallyConstant f, ∀ (x : X), ∀ᶠ (x' : X) in nhds x, f x' = f x, ∀ (x : X), IsOpen {x' | f x' = f x},
          ∀ (y : Y), IsOpen (f ⁻¹' {y}), ∀ (x : X), ∃ U, IsOpen U ∧ x ∈ U ∧ ∀ x' ∈ U, f x' = f x] :=
  by sorry

The theorem `IsLocallyConstant.tfae` states that for any two types `X` and `Y` with `X` being a topological space and any function `f` from `X` to `Y`, the following five properties are equivalent:

1. `f` is a locally constant function, i.e., the preimage of any set under `f` is an open set.
2. For every `x` in `X`, eventually (for all `x'` in the neighborhood of `x`), `f x'` equals `f x`.
3. For every `x` in `X`, the set `{x' | f x' = f x}` is an open set.
4. For every `y` in `Y`, the preimage of `{y}` under `f` is an open set.
5. For every `x` in `X`, there exists an open set `U` containing `x` such that, for all `x'` in `U`, `f x'` equals `f x`.

In other words, these conditions are equivalent ways of characterizing a locally constant function in a topological space.

A function between topological spaces is locally constant if and only if its preimages of open sets and the sets where it is constant are interchangeable.


theorem Trivialization.coe_fst' :
    ∀ {B : Type u_2} {F : Type u_3} {Z : Type u_5} [inst : TopologicalSpace B] [inst_1 : TopologicalSpace F]
      {proj : Z → B} [inst_2 : TopologicalSpace Z] (e : Trivialization F proj) {x : Z},
      proj x ∈ e.baseSet → (↑e x).1 = proj x :=
  by sorry

The theorem `Trivialization.coe_fst'` states that for all types `B`, `F`, and `Z`, given a topological space on `B`, `F`, and `Z`, and a projection function `proj` from `Z` to `B`, if `e` is a trivialization of `F` with respect to `proj` and `x` is an element of `Z` such that the projection of `x` is in the base set of `e`, then the first component of the pair resulting from applying `e` to `x` is equal to the projection of `x`.
In simpler terms, this theorem is about the properties of a mathematical construct called a "trivialization" in the context of topological spaces. It asserts that, under certain conditions, applying a trivialization to an element of a space and then taking the first component of the result, is the same as just projecting the element to another space.

Given a trivialization `e` and an element `x` in the domain of `e` with `proj(x)` in the base set, the first component of `e x` equals `proj(x)`.


theorem Trivialization.mem_target :
    ∀ {B : Type u_2} {F : Type u_3} {Z : Type u_5} [inst : TopologicalSpace B] [inst_1 : TopologicalSpace F]
      {proj : Z → B} [inst_2 : TopologicalSpace Z] (e : Trivialization F proj) {x : B × F},
      x ∈ e.target ↔ x.1 ∈ e.baseSet :=
  by sorry

This theorem, named `Trivialization.mem_target`, states that for all types `B`, `F`, and `Z` where `B`, `F`, and `Z` are topological spaces and `proj` is a function from `Z` to `B`, given a trivialization `e` of `F` using `proj`, and an ordered pair `x` of type `B × F`, `x` is in the target of the trivialization if and only if the first component of `x` is in the base set of the trivialization. In other words, it relates the membership of an element in the target of a trivialization to the membership of its first component in the base set of the trivialization.

For any topological spaces B, F, and Z, and a trivialization e of F over B using a function proj, an element (x, y) of B × F belongs to the target of e if and only if the first component x of x is in the base set of e.


/-- If `R / K / A` is an extension tower, `x : R` is separable over `A`, then it's also separable
over `K`.  -/
theorem Polynomial.Separable.map_minpoly :
    ∀ {A : Type u_1} [inst : CommRing A] (K : Type u_2) [inst_1 : Field K] [inst_2 : Algebra A K] {R : Type u_3}
      [inst_3 : CommRing R] [inst_4 : Algebra A R] [inst_5 : Algebra K R] [inst_6 : IsScalarTower A K R] {x : R},
      Polynomial.Separable (minpoly A x) → Polynomial.Separable (minpoly K x) :=
  by sorry

The theorem `Polynomial.Separable.map_minpoly` states that if you have an extension tower `R / K / A`, where `R`, `K` and `A` are types with necessary algebraic structure (`A` and `R` are commutative rings, `K` is a field, and there are algebra instances from `A` to `K`, `K` to `R`, and `A` to `R`, along with a scalar tower structure), then a polynomial `x` which is of type `R` and is separable over `A` is also separable over `K`. In this context, a polynomial is said to be separable if it is coprime with its derivative.

If `R` is a commutative ring, `K` is a field, `A` is a commutative ring with an algebra structure over `R`, `K` and `A`, and `x` is a separable polynomial of degree `n` over `A`, then `x` is also separable over `K` if and only if `x` and its derivative `dx/dx` have no common roots in `K`.


theorem Set.Ici_inter_Ici :
    ∀ {α : Type u_1} [inst : SemilatticeSup α] {a b : α}, Set.Ici a ∩ Set.Ici b = Set.Ici (a ⊔ b) := by sorry

The theorem `Set.Ici_inter_Ici` states that for any type `α` that is a semilattice with a supremum operation (`⊔`), and for any elements `a` and `b` of this type, the intersection of the interval of elements greater than or equal to `a` (`Set.Ici a`) and the interval of elements greater than or equal to `b` (`Set.Ici b`) is equal to the interval of elements greater than or equal to the supremum of `a` and `b` (`Set.Ici (a ⊔ b)`). This means, in more natural terms, that when we take the overlap of all elements larger than `a` and all elements larger than `b`, we end up with all elements larger than the maximum of `a` and `b`.

For any semilattice with supremum `α`, `Set.Ici a ∩ Set.Ici b = Set.Ici (a ⊔ b)`.


OrderRingIso.ext

theorem OrderRingIso.ext :
    ∀ {α : Type u_2} {β : Type u_3} [inst : Mul α] [inst_1 : Add α] [inst_2 : LE α] [inst_3 : Mul β] [inst_4 : Add β]
      [inst_5 : LE β] {f g : α ≃+*o β}, (∀ (a : α), f a = g a) → f = g :=
  by sorry

This theorem states that for any two types `α` and `β`, where `α` and `β` are both equipped with multiplication, addition, and a less than or equal to order, if `f` and `g` are both order-preserving ring isomorphisms from `α` to `β`, then if for all elements of `α`, the application of `f` and `g` yield the same result, it follows that `f` and `g` are the same isomorphism. Essentially, it means that if two order-preserving ring isomorphisms between the same sets behave the same way, they are the same isomorphism.

If `α` and `β` are ordered rings, `f` and `g` are order-preserving ring isomorphisms from `α` to `β`, and `f(x) = g(x)` for all `x` in `α`, then `f = g`.


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

This theorem is about the zero morphisms and monomorphisms in a category. Specifically, for any category 'C' with zero morphisms and given objects 'X', 'Y', and 'Z' in 'C', it states that if 'f' is a morphism from 'X' to 'Y' and 'g' is a monomorphism from 'Y' to 'Z', then if the composition of 'f' and 'g' is a zero morphism, 'f' must also be a zero morphism. In other words, if composing 'f' with a monomorphism results in a zero morphism, 'f' itself must be a zero morphism.

If `f : X -> Y` is a morphism, `g : Y -> Z` is a monomorphism, and their composition `g ∘ f` is a zero morphism in a category with zero morphisms, then `f` is a zero morphism.


theorem MeasureTheory.StronglyMeasurable.measurableSet_le :
    ∀ {α : Type u_1} {β : Type u_2} {m : MeasurableSpace α} [inst : TopologicalSpace β] [inst_1 : Preorder β]
      [inst_2 : OrderClosedTopology β] [inst_3 : TopologicalSpace.PseudoMetrizableSpace β] {f g : α → β},
      MeasureTheory.StronglyMeasurable f → MeasureTheory.StronglyMeasurable g → MeasurableSet {a | f a ≤ g a} :=
  by sorry

This theorem states that for every pair of functions `f` and `g` from an arbitrary type `α` to an ordered type `β` equipped with a topological space, a pre-order structure, an order-closed topology, and a pseudometrizable topological space, if both `f` and `g` are strongly measurable (meaning they are limits of simple functions), then the set of elements `a` in `α` for which `f(a)` is less than or equal to `g(a)` is a measurable set.

For functions `f` and `g` from an arbitrary type `α` to an ordered and pseudometrizable topological space `β`, if `f` and `g` are strongly measurable, then the set `{a : α | f a ≤ g a}` is measurable.


theorem interior_Iic :
    ∀ {α : Type u} [inst : TopologicalSpace α] [inst_1 : LinearOrder α] [inst_2 : OrderTopology α]
      [inst_3 : DenselyOrdered α] [inst_4 : NoMaxOrder α] {a : α}, interior (Set.Iic a) = Set.Iio a :=
  by sorry

The theorem `interior_Iic` states that for any type `α` that has a topological space structure, a linear order structure, an order topology structure, a densely ordered structure, and a NoMaxOrder structure, the interior of the left-infinite right-closed interval up to any point `a` is equal to the left-infinite right-open interval up to `a`. In mathematical terms, this translates to saying that the interior of the half-closed interval `(-∞, a]` is the open interval `(-∞, a)`. This holds in a linearly ordered topological space where every two elements have another element strictly between them and no element is the largest.

In a densely ordered, linearly topological space without a maximum element, the interior of the left-infinite right-closed interval equal to the left-infinite right-open interval.


Filter.HasBasis.ker

theorem Filter.HasBasis.ker :
    ∀ {α : Type u_1} {ι : Sort u_4} {l : Filter α} {p : ι → Prop} {s : ι → Set α},
      Filter.HasBasis l p s → Filter.ker l = ⋂ i, ⋂ (_ : p i), s i :=
  by sorry

For any type `α` and index type `ι`, this theorem states that given a filter `l` on the type `α`, a predicate `p` on the index type `ι`, and a function `s` mapping each index to a set of `α`, if this system has a filter basis, then the kernel (i.e., the intersection of all sets) of the filter `l` is the intersection over all indices `i` such that `p i` holds, of the sets `s i`. In simpler terms, the theorem is saying that the kernel of a filter, given a filter basis, can be described as the intersection of certain associated sets, as dictated by the basis.

Given a filter `l` on type `α` with filter basis `{s i | ι : Type, i : ι, p i}`, the kernel of `l` equals the intersection over all `i` such that `p i` holds, of the sets `s i`.


ContDiffWithinAt.mul

/-- The product of two `C^n` functions within a set at a point is `C^n` within this set
at this point.  -/
theorem ContDiffWithinAt.mul :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type uE} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {x : E} {n : ℕ∞} {𝔸 : Type u_3} [inst_3 : NormedRing 𝔸] [inst_4 : NormedAlgebra 𝕜 𝔸]
      {s : Set E} {f g : E → 𝔸},
      ContDiffWithinAt 𝕜 n f s x → ContDiffWithinAt 𝕜 n g s x → ContDiffWithinAt 𝕜 n (fun x => f x * g x) s x :=
  by sorry

This theorem states that the product of two continuously differentiable (`C^n`) functions within a set at a certain point, is also continuously differentiable at this point within this set. In more detail, given a nontrivially normed field `𝕜`, a normed additive commutative group `E` which is a normed space over `𝕜`, a point `x` in `E`, `n` which can be any natural number or infinity, a normed ring `𝔸` that is a normed algebra over `𝕜`, a set `s` of elements of type `E`, and two functions `f` and `g` mapping from `E` to `𝔸`, if both `f` and `g` are continuously differentiable within `s` at `x`, then the function defined by the product of `f` and `g` is also continuously differentiable within `s` at `x`.

If two continuously differentiable functions map a normed vector space to its associated algebra, then their product is also continuously differentiable at a given point in the domain.


Multiset.ext

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

The theorem `Multiset.ext` states that for any type `α` with decidable equality and any two multisets `s` and `t` of type `α`, the multisets `s` and `t` are equal if and only if, for every element `a` of type `α`, the count of `a` in `s` is equal to the count of `a` in `t`. In other words, two multisets are considered equal when they have the same elements with the same multiplicities.

Two multisets of type `α` are equal if and only if they have the same multiplicity for each element `α`.


theorem nhds_iInf : ∀ {α : Type u} {ι : Sort u_1} {t : ι → TopologicalSpace α} {a : α}, nhds a = ⨅ i, nhds a := by sorry

The theorem `nhds_iInf` asserts that for any type `α`, any index type `ι`, any function `t` that maps from index type `ι` to `TopologicalSpace α`, and any element `a` of type `α`, the neighborhood filter `nhds a` is equal to the infimum of the neighborhood filters `nhds a` over all `i` in index type `ι`. This means that the neighborhood of a point `a` in a topological space is the smallest filter that contains all the neighborhood filters of `a` for each topology created by the function `t`.

The neighborhood filter of a point in a topological space is the infimum of the neighborhood filters of that point under all possible topologies on the space.


theorem Filter.limsup_le_limsup :
    ∀ {β : Type u_2} {α : Type u_6} [inst : ConditionallyCompleteLattice β] {f : Filter α} {u v : α → β},
      u ≤ᶠ[f] v →
        autoParam (Filter.IsCoboundedUnder (fun x x_1 => x ≤ x_1) f u) _auto✝ →
          autoParam (Filter.IsBoundedUnder (fun x x_1 => x ≤ x_1) f v) _auto✝¹ →
            Filter.limsup u f ≤ Filter.limsup v f :=
  by sorry

The theorem `Filter.limsup_le_limsup` states that for any given types `β` and `α`, where `β` is a conditionally complete lattice, and any filter `f` on `α` with functions `u` and `v` from `α` to `β`, if `u` is less than or equal to `v` for all elements in the filter `f`, and if the image of `f` under `u` is not tending towards infinity (i.e., it is cobounded), and the image of `f` under `v` is eventually bounded, then the upper limit (limsup) of `u` along `f` is less than or equal to the upper limit (limsup) of `v` along `f`. In mathematical terms, if $u \leq v$ almost everywhere on $f$, and $u$ is cobounded and $v$ is bounded under $f$, then $\limsup_{x \in f} u(x) \leq \limsup_{x \in f} v(x)$.

If $u \leq v$ almost everywhere in a cobounded filter $f$ over a conditionally complete lattice $\beta$, then $\limsup_{x \in f} u(x) \leq \limsup_{x \in f} v(x)$.


theorem Ordinal.lift_down :
    ∀ {a : Ordinal.{u}} {b : Ordinal.{max u v}}, b ≤ Ordinal.lift.{v, u} a → ∃ a', Ordinal.lift.{v, u} a' = b := by
  sorry

The theorem `Ordinal.lift_down` states that for any two ordinals `a` and `b`, where `a` is of type `Ordinal.{u}` and `b` is of type `Ordinal.{max u v}`, if `b` is less than or equal to the ordinal obtained by lifting `a` (i.e. `Ordinal.lift.{v, u} a`), then there exists another ordinal `a'` such that the ordinal obtained by lifting `a'` is equal to `b`. In simpler terms, this theorem guarantees a "down" operation for every "lift" operation on ordinals, provided the lifted ordinal is greater than or equal to the original ordinal.

For any ordinals `a` of type `Ordinal.{u}` and `b` of type `Ordinal.{max u v}`, if `b <= Ordinal.lift.{v, u} a`, then there exists an ordinal `a'` such that `Ordinal.lift.{v, u} a' = b`.


theorem Commute.pow_left : ∀ {M : Type u_2} [inst : Monoid M] {a b : M}, Commute a b → ∀ (n : ℕ), Commute (a ^ n) b :=
  by sorry

The theorem `Commute.pow_left` states that for any type `M` with a defined Monoid structure, if two elements `a` and `b` commute (i.e., `a * b = b * a`), then `a` raised to any natural number `n` commutes with `b`. In other words, if `a` and `b` commute, then `a^n * b = b * a^n` for any natural number `n`.

If `a` and `b` are commuting elements of a monoid `M`, then `a^n * b = b * a^n` for all natural numbers `n`.


theorem right_lt_sup : ∀ {α : Type u} [inst : SemilatticeSup α] {a b : α}, b < a ⊔ b ↔ ¬a ≤ b := by sorry

This theorem, referred to as `right_lt_sup`, states that for any type `α` that forms a semilattice with a supremum operation (denoted `⊔`), given any two elements `a` and `b` of this type, `b` is less than the supremum of `a` and `b` (`a ⊔ b`) if and only if `a` is not less than or equal to `b`. This theorem is a key part of the definition and properties of a semilattice, and it helps describe the relationship between the elements and the supremum operation.

For any semilattice `α` with supremum operation `⊔`, and any `a, b ∈ α`, `b < a ⊔ b` if and only if `a ≤ b`.


ContinuousLinearMap.differentiable

theorem ContinuousLinearMap.differentiable :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F]
      (e : E →L[𝕜] F), Differentiable 𝕜 ⇑e :=
  by sorry

The theorem `ContinuousLinearMap.differentiable` states that for any continuous linear map `e` from a normed addtive commutative group `E` to another such group `F`, both equipped with a normed space structure over a non-trivially normed field `𝕜`, the map `e` is differentiable at every point of `E`. In other words, all continuous linear maps are differentiable everywhere.

Every continuous linear map between normed additive commutative groups, equipped with normed space structures over a non-trivially normed field, is differentiable.


theorem MvPowerSeries.inv_eq_zero :
    ∀ {σ : Type u_1} {k : Type u_3} [inst : Field k] {φ : MvPowerSeries σ k},
      φ⁻¹ = 0 ↔ (MvPowerSeries.constantCoeff σ k) φ = 0 :=
  by sorry

This theorem states that for any type `σ`, field `k`, and multivariate formal power series `φ` in variables of type `σ` with coefficients in `k`, the inverse of `φ` is zero if and only if the constant coefficient of `φ` is zero. Here, `MvPowerSeries σ k` represents a multivariate power series indexed by type `σ` with coefficients in the field `k`, and `MvPowerSeries.constantCoeff σ k φ` retrieves the constant coefficient of this power series. The theorem is essentially confirming that if the constant term of a multivariate power series in a field is zero, the series has no multiplicative inverse.

For any multivariate formal power series φ of type σ with coefficients in a field k, the constant coefficient of φ being zero if and only if φ has no multiplicative inverse.


Multiset.Nodup.pmap

theorem Multiset.Nodup.pmap :
    ∀ {α : Type u_1} {β : Type u_2} {p : α → Prop} {f : (a : α) → p a → β} {s : Multiset α} {H : ∀ a ∈ s, p a},
      (∀ (a : α) (ha : p a) (b : α) (hb : p b), f a ha = f b hb → a = b) →
        Multiset.Nodup s → Multiset.Nodup (Multiset.pmap f s H) :=
  by sorry

The theorem `Multiset.Nodup.pmap` asserts that for any types `α` and `β`, a property `p : α → Prop`, a function `f : (a : α) → p a → β` mapping elements of the type `α` satisfying the property `p` to elements of the type `β`, and a multiset `s : Multiset α` where every element satisfies property `p`, if the function `f` guarantees that, whenever it maps two different elements satisfying property `p` to the same value, then those two elements were identical in the first place, and if the multiset `s` does not contain any duplicate elements, then the multiset obtained by mapping `f` over `s` (denoted `Multiset.pmap f s H`) also does not contain any duplicate elements. In simpler terms, if you start with a set without duplicates and apply a function that doesn't collapse different values to the same result, then the transformed set will also not have any duplicates.

Given a multiset of distinct elements from type `α` and a function `f : α → β` such that `f` maps distinct elements satisfying `p(x)` to distinct values, the multiset obtained by applying `f` to the elements of the original multiset (with the property `p` as hypothesis) also does not contain any duplicate elements.


theorem MeasurableEmbedding.ae_map_iff :
    ∀ {α : Type u_2} {β : Type u_3} {m0 : MeasurableSpace α} {m1 : MeasurableSpace β} {f : α → β},
      MeasurableEmbedding f →
        ∀ {p : β → Prop} {μ : MeasureTheory.Measure α},
          (∀ᵐ (x : β) ∂MeasureTheory.Measure.map f μ, p x) ↔ ∀ᵐ (x : α) ∂μ, p (f x) :=
  by sorry

The theorem `MeasurableEmbedding.ae_map_iff` states that for any types `α` and `β`, measurable spaces `m0` and `m1` on `α` and `β` respectively, a function `f` from `α` to `β`, if `f` is a measurable embedding, then for any property `p` of elements in `β` and any measure `μ` on `α`, the property `p` holds almost everywhere for the measure induced by mapping `μ` via `f` if and only if the property `p` composed with `f` holds almost everywhere with respect to `μ`. "Almost everywhere" is a measure-theoretic concept meaning that the set of points where the property does not hold has measure zero.

For measurable spaces (α, m0) and (β, m1), function f: α → β being a measurable embedding implies that m0-almost everywhere x in α has image under f that satisfies property p if and only if property p holds m1-almost everywhere for the image of x under f.


theorem diffContOnCl_const :
    ∀ {𝕜 : Type u_1} {E : Type u_2} {F : Type u_3} [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedAddCommGroup F] [inst_3 : NormedSpace 𝕜 E] [inst_4 : NormedSpace 𝕜 F] {s : Set E} {c : F},
      DiffContOnCl 𝕜 (fun x => c) s :=
  by sorry

This theorem, `diffContOnCl_const`, states that for any type 𝕜 that is a non-trivially normed field, any type E and F that are normed additive commutative groups, and with 𝕜 as the normed space for both E and F, for any set s of type E and any constant c of type F, the function which maps any element to the constant c is differentially continuous on the closure of the set s. This means the derivative of this constant function is continuous on the set s.

For any non-trivially normed field 𝕜, any normed additive commutative groups E and F with 𝕜 as their common normed space, and any constant c in F, the function mapping every element in the closed set s of E to c is differentially continuous.


theorem Real.contDiff_exp : ∀ {n : ℕ∞}, ContDiff ℝ n Real.exp := by sorry

This theorem states that for all natural numbers `n` extended to infinity, the real exponential function `Real.exp` is continuously differentiable `n` times. In mathematical terms, it means that the derivative of any order of the exponential function exists and is continuous on the real numbers.

The real exponential function `Real.exp` is continuously differentiable to all orders on the real numbers.


/-- Any Finsupp `f : ℕ →₀ ℕ` whose support is in the primes is equal to the factorization of
the product `∏ (a : ℕ) in f.support, a ^ f a`.  -/
theorem Nat.prod_pow_factorization_eq_self :
    ∀ {f : ℕ →₀ ℕ}, (∀ p ∈ f.support, Nat.Prime p) → Nat.factorization (Finsupp.prod f fun x x_1 => x ^ x_1) = f := by
  sorry

This theorem states that given a finitely supported function `f : ℕ →₀ ℕ` where the support of `f` includes only prime numbers, the factorization of the product obtained by raising each element `a` in the support of `f` to the power of `f a` results in `f` itself. In mathematical terms, if `f` is a function where every input taken from the support of `f` gives a prime number, then the factorization of the product of `a ^ f(a)` (where `a` is in the support of `f`) is equal to the original function `f`.

For a finitely supported function `f : ℕ →₀ ℕ` with prime support, the product of `a ^ f(a)` for `a` in the support of `f` equals the function `f` itself.


theorem Matroid.Base.eq_of_subset_base :
    ∀ {α : Type u_1} {M : Matroid α} {B₁ B₂ : Set α}, M.Base B₁ → M.Base B₂ → B₁ ⊆ B₂ → B₁ = B₂ := by sorry

This theorem establishes a property of bases in a matroid. In particular, for any type `α` and any matroid `M` over `α`, if `B₁` and `B₂` are both sets of `α` and are both bases in `M`, then if `B₁` is a subset of `B₂`, it must be the case that `B₁` is equal to `B₂`. This theorem is useful in understanding the structure and properties of bases in matroids.

In any matroid, if two bases have non-empty intersection, then they are equal.


theorem Multiset.coe_bind :
    ∀ {α : Type u_1} {β : Type v} (l : List α) (f : α → List β),
      (Multiset.bind ↑l fun a => ↑(f a)) = ↑(List.bind l f) :=
  by sorry

This theorem, `Multiset.coe_bind`, establishes the equivalence between the `bind` operations of multisets and lists. Specifically, for any list `l` of elements of some type `α` and any function `f` mapping elements of `α` to list of elements of some type `β`, the `bind` operation on the multiset equivalent of `l` with the function that applies `f` and then converts to a multiset, is equivalent to the list obtained by applying the `bind` operation on `l` with `f`. This `bind` operation applies `f` to each element of the list/multiset and then joins all the results together.

For any list `l` and function `f`, the multiset `bind` operation of `f` over the multiset representation of `l` is equivalent to the list obtained by applying the list `bind` operation of `f` to `l`.


theorem Cardinal.aleph'_le : ∀ {o₁ o₂ : Ordinal.{u_1}}, Cardinal.aleph' o₁ ≤ Cardinal.aleph' o₂ ↔ o₁ ≤ o₂ := by sorry

The theorem `Cardinal.aleph'_le` states that for any two ordinals `o₁` and `o₂`, the cardinality of the aleph function applied to `o₁` is less than or equal to that applied to `o₂` if and only if `o₁` is less than or equal to `o₂`. In terms of set theory, it means that the order of the aleph function, which assigns cardinals to ordinals, is preserved: smaller ordinals correspond to smaller cardinals (or equivalently, smaller sizes of sets).

The theorem `Cardinal.aleph'_le` asserts that for all ordinals `o₁ o₂`, `ℵ(o₁) ≤ ℵ(o₂)` if and only if `o₁ ≤ o₂`.


theorem ArithmeticFunction.moebius_apply_of_squarefree :
    ∀ {n : ℕ}, Squarefree n → ArithmeticFunction.moebius n = (-1) ^ ArithmeticFunction.cardFactors n := by sorry

This theorem states that for a natural number `n` that is squarefree (meaning that the only squares that divide `n` are the squares of units), the value of the Möbius function `μ` at `n` equals `(-1)` raised to the power of the number of prime factors of `n`. In other words, if `n` is squarefree, the sign of the Möbius function at `n` depends on whether `n` has an even or odd number of distinct prime factors. If the number of prime factors is even, `μ(n) = 1`, and if the number of prime factors is odd, `μ(n) = -1`.

For a squarefree natural number `n`, the Möbius function `μ(n)` equals `(-1)^k`, where `k` is the number of prime factors of `n`.


theorem Cardinal.aleph'_lt : ∀ {o₁ o₂ : Ordinal.{u_1}}, Cardinal.aleph' o₁ < Cardinal.aleph' o₂ ↔ o₁ < o₂ := by sorry

The theorem `Cardinal.aleph'_lt` states that for any two ordinals `o₁` and `o₂`, the Aleph function applied to `o₁` is less than the Aleph function applied to `o₂` if and only if `o₁` is less than `o₂`. In other words, this theorem guarantees that the ordinal ordering is preserved under the Aleph function.

The Aleph function maps smaller ordinals to smaller cardinalities.


theorem EuclideanDomain.div_self : ∀ {R : Type u} [inst : EuclideanDomain R] {a : R}, a ≠ 0 → a / a = 1 := by sorry

The theorem `EuclideanDomain.div_self` states that for any type `R` that is an instance of the `EuclideanDomain` class, if `a` is a non-zero element of `R`, then the division of `a` by itself equals 1. Essentially, it asserts the property of division where any non-zero number divided by itself results in 1, for any Euclidean domain.

For any EuclideanDomain `R` and non-zero element `a` in `R`, `a / a = 1`.


theorem Finset.coe_compl : ∀ {α : Type u_1} [inst : Fintype α] [inst_1 : DecidableEq α] (s : Finset α), ↑sᶜ = (↑s)ᶜ :=
  by sorry

The theorem `Finset.coe_compl` states that for any given type `α`, which has a finite number of elements (`Fintype α`) and decidable equality (`DecidableEq α`), and for any finite set of `α` (`s : Finset α`), the complement of the set `s` translated to a type^{} (`↑sᶜ`) is equal to the complement of the translated set `s` (`(↑s)ᶜ`). In other words, the operation of taking the complement commutes with the operation of translating a set from `Finset α` to `Set α`.

For any finite type `α` with decidable equality, the complement of a finite set `s` in type `α` is equal to the complement of its image under coercion from `Finset α` to `Set α`.


theorem frontier_le_subset_eq :
    ∀ {α : Type u} {β : Type v} [inst : TopologicalSpace α] [inst_1 : LinearOrder α] [inst_2 : OrderClosedTopology α]
      {f g : β → α} [inst_3 : TopologicalSpace β],
      Continuous f → Continuous g → frontier {b | f b ≤ g b} ⊆ {b | f b = g b} :=
  by sorry

This theorem states that for all types α and β with α being a type associated with a topological space, a linear order, and an order-closed topology, and β being a type associated with a topological space, and for all continuous functions f and g from β to α, the frontier (boundary) of the set of elements in β for which f(b) is less than or equal to g(b) is a subset of the set of elements in β for which f(b) equals g(b).

For all continuous functions f and g from a topological space β with order-closed topology and type α, the boundary of the set where f < g equals the set where f = g.


SimpleGraph.Reachable.elim

theorem SimpleGraph.Reachable.elim :
    ∀ {V : Type u} {G : SimpleGraph V} {p : Prop} {u v : V},
      SimpleGraph.Reachable G u v → (SimpleGraph.Walk G u v → p) → p :=
  by sorry

This theorem states that for any type `V`, any simple graph `G` of type `V`, any proposition `p`, and any vertices `u` and `v` of type `V`, if `u` and `v` are reachable in graph `G` (i.e., there exists a walk from `u` to `v` in the graph), then if the existence of a walk from `u` to `v` implies the truth of proposition `p`, it follows that `p` is true. In simpler terms, it allows us to make inferences about a property `p` given the condition that there is a walk between two vertices in a simple graph.

If in a simple graph, there is a walk between vertices `u` and `v`, and the proposition `p` holds along every walk from `u` to `v`, then `p` is true for `v`.


theorem Bool.true_and : ∀ (b : Bool), (true && b) = b := by sorry

This theorem states that for all Boolean values `b`, the logical "and" operation (represented by `&&`) between `true` and `b` is equal to `b` itself. In other words, `true` combined with any Boolean value `b` using the "and" operation will always yield `b`. This is a basic property of Boolean algebra.

For all Boolean values `b`, `true && b = b`.


theorem Fintype.card_subtype_compl :
    ∀ {α : Type u_1} [inst : Fintype α] (p : α → Prop) [inst_1 : Fintype { x // p x }] [inst_2 : Fintype { x // ¬p x }],
      Fintype.card { x // ¬p x } = Fintype.card α - Fintype.card { x // p x } :=
  by sorry

The theorem `Fintype.card_subtype_compl` states that for all types `α` that have finite number of elements (i.e., are 'fintypes'), and for any property `p` that elements of `α` might or might not satisfy, the number of elements in `α` that do not satisfy `p` (`Fintype.card { x // ¬p x }`) is equal to the total number of elements in `α` (`Fintype.card α`) minus the number of elements in `α` that do satisfy `p` (`Fintype.card { x // p x }`). In other words, it is a formal statement of the principle that the size of the complement of a subset of a finite set is the total size of the set minus the size of the subset.

For a fintype `α` and property `p` on `α`, the number of elements not satisfying `p` equals the total number of elements minus the number of elements satisfying `p`. In other words, `Fintype.card { x // ¬p x } = Fintype.card α - Fintype.card { x // p x }`.


theorem midpoint_self :
    ∀ (R : Type u_1) {V : Type u_2} {P : Type u_4} [inst : Ring R] [inst_1 : Invertible 2] [inst_2 : AddCommGroup V]
      [inst_3 : Module R V] [inst_4 : AddTorsor V P] (x : P), midpoint R x x = x :=
  by sorry

The theorem `midpoint_self` states that for any point `x` in an affine space `P`, which is associated with a vector space `V` over a ring `R`, the midpoint of the segment from `x` to `x` itself is `x`. This is a mathematical way of saying that the midpoint of a line segment with the same start and end points is just the point itself. This holds true for any ring `R` where `2` is invertible, any additive commutative group `V`, any `R`-module structure on `V`, and any affine torsor `P` over `V`.

For any point `x` in an affine space `P` over a ring `R` where 2 is invertible, the midpoint of the segment from `x` to `x` is `x`.


theorem Nat.prime_def_lt'' : ∀ {p : ℕ}, Nat.Prime p ↔ 2 ≤ p ∧ ∀ (m : ℕ), m ∣ p → m = 1 ∨ m = p := by sorry

The theorem `Nat.prime_def_lt''` states that for any natural number `p`, `p` is a prime number if and only if `p` is greater than or equal to 2 and for every natural number `m` that divides `p`, `m` is either equal to 1 or `p`. In mathematical terms, this theorem provides an equivalent definition for a natural number to be prime: a natural number `p` is prime if it is at least 2 and the only divisors of `p` are `1` and `p` itself.

A natural number `p` is prime if and only if `p` is greater than 1 and has no divisors other than 1 and `p`.


theorem le_of_inf_le_sup_le :
    ∀ {α : Type u} [inst : DistribLattice α] {x y z : α}, x ⊓ z ≤ y ⊓ z → x ⊔ z ≤ y ⊔ z → x ≤ y := by sorry

This theorem asserts that for any type `α` that is a distributive lattice, given any three elements `x`, `y`, and `z` from this type, if the infimum (greatest lower bound) of `x` and `z` is less than or equal to the infimum of `y` and `z`, and the supremum (least upper bound) of `x` and `z` is less than or equal to the supremum of `y` and `z`, then `x` is less than or equal to `y`. This can be viewed as a type of comparative property in the context of lattice theory.

If `α` is a distributive lattice and `x ≤ inf(y, z)`, `inf(x, z) ≤ inf(y, z)`, and `sup(x, z) ≤ sup(y, z)`, then `x ≤ y`.


theorem Primrec.nat_double_succ : Primrec fun n => 2 * n + 1 := by sorry

This theorem states that the function that maps each natural number `n` to `2*n + 1` is primitive recursive. In other words, for every natural number `n`, the operation of doubling `n` and then adding 1 can be computed using a fixed, finite number of steps, with each step being a basic arithmetic operation or a test for zero or equality.

The function that maps each natural number `n` to `2*n + 1` is a primitive recursive function.


theorem Set.encard_le_card : ∀ {α : Type u_1} {s t : Set α}, s ⊆ t → Set.encard s ≤ Set.encard t := by sorry

This theorem states that for any given type `α`, and any two sets `s` and `t` of that type, if `s` is a subset of `t` (`s ⊆ t`), then the cardinality of `s` (`Set.encard s`) is less than or equal to the cardinality of `t` (`Set.encard t`). In mathematical terms, this theorem asserts that the cardinality of a subset is always less than or equal to the cardinality of the set which contains it.

For any type `α` and sets `s` and `t` of type `α`, if `s` is a subset of `t`, then `#s ≤ #t`, where `#s` and `#t` denote the cardinalities of `s` and `t`, respectively.


theorem Mathlib.Algebra.Order.Ring.Defs._auxLemma.3 :
    ∀ {α : Type u} [inst : StrictOrderedSemiring α] {a : α}, 0 < a → ∀ (n : ℕ), (0 < a ^ n) = True := by sorry

This theorem, from the `Mathlib.Algebra.Order.Ring.Defs._auxLemma.3`, states that for any strictly ordered semiring `α` and any element `a` from `α`, if `a` is greater than zero, then for any natural number `n`, `a` raised to the power of `n` is also greater than zero. In simpler terms, any positive number raised to any natural number power in a strictly ordered semiring will always yield a positive result.

In a strictly ordered semiring, if 0 < a then a^n > 0 for all natural numbers n.


/-- If a function has a limit, then its liminf coincides with its limit.  -/
theorem Filter.Tendsto.liminf_eq :
    ∀ {α : Type u_2} {β : Type u_3} [inst : ConditionallyCompleteLinearOrder α] [inst_1 : TopologicalSpace α]
      [inst_2 : OrderTopology α] {f : Filter β} {u : β → α} {a : α} [inst_3 : Filter.NeBot f],
      Filter.Tendsto u f (nhds a) → Filter.liminf u f = a :=
  by sorry

This theorem states that for any function `u` from a type `β` to a `ConditionallyCompleteLinearOrder` type `α`, if the function `u` has a limit `a` (in the sense that, for any neighborhood of `a`, the preimage of this neighborhood under `u` is eventually in the filter `f`), then the `liminf` -- the least upper bound of the set of values `a` such that `u(x) ≥ a` eventually holds in the filter `f` -- of `u` along `f` is equal to this limit `a`. Here, it is assumed that `α` is equipped with a topology compatible with its order structure and that `f` is a non-trivial filter.

If `u` is a function from type `β` to a conditionally complete linear order `α` with topology compatible with its order structure, and `f` is a non-trivial filter, then `u`'s limit `a` equals the `liminf` of `u` along `f` in `α` if and only if for any neighborhood of `a`, the preimage of that neighborhood under `u` is eventually in `f`.


theorem NonUnitalRingHom.mem_srange :
    ∀ {R : Type u} {S : Type v} [inst : NonUnitalNonAssocSemiring R] [inst_1 : NonUnitalNonAssocSemiring S]
      {F : Type u_1} [inst_2 : FunLike F R S] [inst_3 : NonUnitalRingHomClass F R S] {f : F} {y : S},
      y ∈ NonUnitalRingHom.srange f ↔ ∃ x, f x = y :=
  by sorry

The theorem `NonUnitalRingHom.mem_srange` states that for any types `R` and `S` that are instances of `NonUnitalNonAssocSemiring`, and any type `F` that is an instance of `FunLike F R S` and `NonUnitalRingHomClass F R S`, a value `y` of type `S` belongs to the range of a non-unital ring homomorphism `f : F` if and only if there exists a value `x` such that applying `f` to `x` yields `y`. In other words, the theorem establishes the exact condition under which a value can be said to be in the range of a non-unital ring homomorphism.

A value in `S` is in the range of a non-unital ring homomorphism from `R` to `S` if and only if it is the image of some element in `R`.


theorem Ordinal.derivFamily_limit :
    ∀ {ι : Type u} (f : ι → Ordinal.{max u v} → Ordinal.{max u v}) {o : Ordinal.{max u v}},
      Ordinal.IsLimit o → Ordinal.derivFamily f o = Ordinal.bsup o fun a x => Ordinal.derivFamily f a :=
  by sorry

The theorem `Ordinal.derivFamily_limit` states that for any type `ι` and any function `f` from `ι` and `Ordinal.{max u v}` to `Ordinal.{max u v}`, and for any limit ordinal `o`, the derivative of the family of normal functions at `o` is equal to the supremum of the family of ordinals indexed by the set of ordinals less than `o`, where each ordinal in this family is the derivative of the family of normal functions at that ordinal. In other words, this theorem describes a property of limit ordinals in the context of derivatives of families of normal functions.

The derivative of the family of normal functions at a limit ordinal is the supremum of the derivatives of the family at all ordinals less than it.


theorem Fintype.card_eq_zero : ∀ {α : Type u_1} [inst : Fintype α] [inst_1 : IsEmpty α], Fintype.card α = 0 := by sorry

The theorem `Fintype.card_eq_zero` states that for any finite type `α`, given that `α` is empty (i.e., there are no instances of `α`), then the cardinality of `α` (the number of elements in `α`) is `0`. This theorem is essentially saying that the size of an empty finite set is `0`.

The theorem asserts that the cardinality of a finite empty type is equal to zero.


theorem Finsupp.liftAddHom_apply_single :
    ∀ {α : Type u_1} {M : Type u_8} {N : Type u_10} [inst : AddCommMonoid M] [inst_1 : AddCommMonoid N] (f : α → M →+ N)
      (a : α) (b : M), ((Finsupp.liftAddHom f) fun₀ | a => b) = (f a) b :=
  by sorry

This theorem states that for any types `α`, `M`, and `N`, given an additive commutative monoid structure on `M` and `N`, and a function `f` from `α` to the additive monoid homomorphisms from `M` to `N`, for any `a` of type `α` and any `b` of type `M`, applying `Finsupp.liftAddHom` on `f` and then applying this to a function `fun₀` (which is a function from `α` to `M` that is zero for all inputs except for `a` where it returns `b`) is equal to applying `f` at `a` and then applying this to `b`. The `Finsupp.liftAddHom` function is a way of lifting a function to operate on finitely supported functions, which are functions that are zero except at finitely many points.

For any additive commutative monoids M and N, and any function f from type α to additive monoid homomorphisms from M to N, the application of Finsupp.liftAddHom(f) to the function fun₀ from α to M, which is zero everywhere except for mapping a to b, is equal to the composition of applying f to a and then applying it to b.


/-- If `b` semiconjugates `x` to `y` and `a` semiconjugates `y` to `z`, then `a * b`
semiconjugates `x` to `z`.  -/
theorem SemiconjBy.mul_left :
    ∀ {S : Type u_1} [inst : Semigroup S] {a b x y z : S},
      SemiconjBy a y z → SemiconjBy b x y → SemiconjBy (a * b) x z :=
  by sorry

The theorem `SemiconjBy.mul_left` states that in a semigroup `S`, if `b` semiconjugates `x` to `y` and `a` semiconjugates `y` to `z`, then the product of `a` and `b` semiconjugates `x` to `z`. In other words, if `b * x = y * b` and `a * y = z * a`, then `(a * b) * x = z * (a * b)`. This asserts a sort of transitivity property for the semiconjugation relation in the context of semigroups.

In a semigroup, if elements `x`, `y`, `z`, `a`, and `b` satisfy `b * x = y * b` and `a * y = z * a`, then `(a * b) * x = z * (a * b)`.


/-- An isometry preserves non-negative distances.  -/
theorem Isometry.nndist_eq :
    ∀ {α : Type u} {β : Type v} [inst : PseudoMetricSpace α] [inst_1 : PseudoMetricSpace β] {f : α → β},
      Isometry f → ∀ (x y : α), nndist (f x) (f y) = nndist x y :=
  by sorry

The theorem `Isometry.nndist_eq` states that an isometry preserves non-negative distances. More formally, for any types `α` and `β` that are pseudo metric spaces, if `f` is an isometry, then for any elements `x` and `y` of type `α`, the non-negative distance `nndist` between the images `f x` and `f y` in `β` is equal to the original non-negative distance between `x` and `y` in `α`.

An isometry preserves non-negative distances between elements in pseudo metric spaces, i.e., `nndist(f x, f y) = nndist(x, y)` for any isometry `f` and elements `x` and `y` in pseudo metric spaces `α` and `β`, respectively.


theorem Set.subset_preimage_univ : ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {s : Set α}, s ⊆ f ⁻¹' Set.univ := by
  sorry

The theorem `Set.subset_preimage_univ` states that for any types `α` and `β`, any function `f` from `α` to `β`, and any set `s` of `α`, the set `s` is a subset of the preimage of the universal set `Set.univ` under the function `f`. In other words, every element of `s` is mapped to some element in the universal set `Set.univ` by the function `f`.

For any types α and β, function f from α to β, and set s of α, s ⊆ f⁁¹(Set.univ).


theorem Set.range_prod_map :
    ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {δ : Type u_4} {m₁ : α → γ} {m₂ : β → δ},
      Set.range (Prod.map m₁ m₂) = Set.range m₁ ×ˢ Set.range m₂ :=
  by sorry

This theorem, `Set.range_prod_map`, states that for any two functions `m₁` mapping from type `α` to `γ` and `m₂` mapping from type `β` to `δ`, the range of the function produced by mapping `m₁` and `m₂` across a pair, that is `Prod.map m₁ m₂`, is equal to the cartesian product of the range of `m₁` and the range of `m₂`. In mathematical terms, if we denote the range of a function `f` as `Range(f)`, then `Range(Prod.map m₁ m₂) = Range(m₁) × Range(m₂)`. This result illustrates how the range of a function that operates on pairs relates to the ranges of its component functions.

The range of the function `Prod.map m₁ m₂` over the product type `α × β` is equal to the cartesian product of the ranges of `m₁` over `α` and `m₂` over `β`.


theorem descPochhammer_succ_left :
    ∀ (R : Type u) [inst : Ring R] (n : ℕ),
      descPochhammer R (n + 1) = Polynomial.X * Polynomial.comp (descPochhammer R n) (Polynomial.X - 1) :=
  by sorry

This theorem, `descPochhammer_succ_left`, states that for any natural number `n` and any type `R` that is a ring, the `descPochhammer` polynomial of `R` at `n + 1` is equal to the product of the polynomial `X` and the composition of the `descPochhammer` polynomial of `R` at `n` with the polynomial `X - 1`.

In other words, it expresses the computation of the `descPochhammer` polynomial at `n + 1` as an operation on the `descPochhammer` polynomial at `n`, using polynomial multiplication and composition. This allows us to inductively build up higher `descPochhammer` polynomials from lower ones.

For any ring type R and natural number n, the descPochhammer polynomial of R at n+1 is equal to the product of X and the composition of the descPochhammer polynomial of R at n with the polynomial X - 1.


theorem CategoryTheory.Arrow.cechConerve.proof_1 :
    ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] (f : CategoryTheory.Arrow C)
      [inst_1 : ∀ (n : ℕ), CategoryTheory.Limits.HasWidePushout f.left (fun x => f.right) fun x => f.hom]
      (n : SimplexCategory), CategoryTheory.Limits.HasWidePushout f.left (fun x => f.right) fun x => f.hom :=
  by sorry

This theorem states that for any category `C`, and for any arrow `f` in the arrow category of `C`, if for each natural number `n`, the wide pushout of `f.left`, `f.right` and `f.hom` exists, then for any object `n` in the simplex category (which is a natural number), the wide pushout of `f.left`, `f.right` and `f.hom` also exists. In the context of category theory, a wide pushout (also known as a coproduct or an amalgamated sum) is a colimit of a diagram which is a shape of "cospan", i.e., a diagram with two objects mapping to a third one. In this theorem, the wide pushout is obtained from the diagram specified by `f.left`, `f.right` and `f.hom`.

If, for every natural number `n`, the wide pushout of `f.left`, `f.right`, and `f.hom` exists in a category `C`, then the wide pushout of `f.left`, `f.right`, and `f.hom` exists in the simplex category for any object `n` (represented as an arrow from the terminal object to itself).


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

This theorem, `imp_iff_right`, states that for all propositions `a` and `b`, if `a` is true, then `a` implies `b` is equivalent to `b`. In other words, given that `a` is true, if `b` is true whenever `a` is true (i.e., `a` implies `b`), then `b` must be true; conversely, if `b` is true, then `a` implies `b` must also be true.

For all propositions `a` and `b`, `a` implies `b` is logically equivalent to `(a → b) ≡ b`.


theorem Ordinal.div_le : ∀ {a b c : Ordinal.{u_4}}, b ≠ 0 → (a / b ≤ c ↔ a < b * Order.succ c) := by sorry

This theorem, `Ordinal.div_le`, states that for any three ordinals `a`, `b`, and `c`, as long as `b` is not zero, the proposition that `a` divided by `b` is less than or equal to `c` is equivalent to the proposition that `a` is strictly less than the product of `b` and the successor of `c`. The successor of an ordinal is the next greater ordinal, except when the ordinal is maximal, in which case its successor is itself.

For ordinals `a`, `b` with `b ≠ 0`, `a / b ≤ c` is equivalent to `a < b * (c + 1)`.


theorem Nat.gcd_add_mul_right_right : ∀ (m n k : ℕ), Nat.gcd m (n + k * m) = Nat.gcd m n := by sorry

The theorem `Nat.gcd_add_mul_right_right` states that for all natural numbers `m`, `n`, and `k`, the greatest common divisor (gcd) of `m` and `n + k * m` is the same as the gcd of `m` and `n`. In other words, multiplying `m` by `k` and adding the result to `n` does not change the gcd of `m` and `n`. This property is crucial in many number theoretic algorithms and proofs involving greatest common divisors.

The theorem `Nat.gcd_add_mul_right_right` asserts that adding the product of a natural number `k` with another natural number `m` to another natural number `n` does not alter the greatest common divisor of `m` and `n`. In other words, gcd(`m`, `n`) = gcd(`m`, `n` + `k` * `m`).


theorem Mathlib.Topology.FiberBundle.Basic._auxLemma.6 :
    ∀ {α : Type u} {β : Type v} {f : α → β} {s : Set β} {a : α}, (a ∈ f ⁻¹' s) = (f a ∈ s) := by sorry

This theorem, known as `Mathlib.Topology.FiberBundle.Basic._auxLemma.6`, states that for any types `α` and `β`, any function `f` from `α` to `β`, any set `s` of `β` and any element `a` of `α`, the element `a` is in the preimage of set `s` under function `f` if and only if the image of `a` under `f` is in the set `s`. In more mathematical terms, for all `a` in `α`, `a` is in `f^-1(s)` if and only if `f(a)` is in `s`.

For any functions $f: \alpha \to \beta$ and sets $s \subseteq \beta$, the preimage $f^{-1}(s) \subseteq \alpha$ contains an element $a \in \alpha$ if and only if the image $f(a) \in s$.


IsConj.symm

theorem IsConj.symm : ∀ {α : Type u} [inst : Monoid α] {a b : α}, IsConj a b → IsConj b a := by sorry

The theorem `IsConj.symm` states that for any type `α` that forms a monoid, if an element `a` is conjugate to another element `b` (i.e., there exists a unit `c` such that `c * a * c⁻¹ = b`), then `b` is also conjugate to `a`. This means that conjugacy is a symmetrical relationship in the context of a monoid.

If `a` is conjugate to `b` in a monoid, then `b` is conjugate to `a`.


theorem Complex.abs_im_le_abs : ∀ (z : ℂ), |z.im| ≤ Complex.abs z := by sorry

The theorem `Complex.abs_im_le_abs` states that for any complex number `z`, the absolute value of the imaginary part of `z`, denoted as `|z.im|`, is less than or equal to the absolute value of `z` itself. In mathematical terms, this is saying that for any complex number `z`, the modulus of its imaginary part is always less than or equal to the modulus of the complex number.


theorem ack_strictMono_left : ∀ (n : ℕ), StrictMono fun m => ack m n := by sorry

This theorem states that for every natural number `n`, the Ackermann function `ack` is strictly monotone when considered as a function of its first argument `m`. This means that for all pairs of natural numbers `(m1, m2)` where `m1 < m2`, it holds that `ack m1 n < ack m2 n`. In other words, increasing the first argument of the Ackermann function (while keeping the second argument fixed) results in a larger output value.

For all natural numbers `n` and `m1` < `m2`, `ack (m1) n` < `ack (m2) n` holds for the Ackermann function.


theorem Quiver.Hom.unop_op : ∀ {C : Type u₁} [inst : Quiver C] {X Y : C} (f : X ⟶ Y), f.op.unop = f := by sorry

This theorem states that for any type `C` which has a quiver (directed graph) structure, and any two objects `X` and `Y` in `C`, if we have a morphism `f` from `X` to `Y`, then operating on `f` with the `op` function and then undoing the operation with the `unop` function returns the original morphism `f`. In other words, the `unop` function is the inverse of the `op` function on the set of morphisms from `X` to `Y` in the category `C`. This result is independent of the specific objects `X` and `Y` and the morphism `f`.

For any category `C` with objects `X` and `Y` and a morphism `f` from `X` to `Y`, the inverse of the operation `op(f)` on morphisms is given by `unop(op(f)) = f`.


theorem Set.Nonempty.bddAbove_lowerBounds :
    ∀ {α : Type u} [inst : Preorder α] {s : Set α}, Set.Nonempty s → BddAbove (lowerBounds s) := by sorry

This theorem states that for any nonempty set `s` of a type `α` equipped with a preorder relation, the set of lower bounds of `s` is bounded above. In other words, if we have at least one element in set `s`, there exists an upper bound for all the lower bounds of `s`. This could be seen as there is a maximum lower bound for `s`.

For any nonempty set `s` in type `α` with a preorder relation, the set of lower bounds of `s` has a supremum.


theorem Function.Surjective.iUnion_comp :
    ∀ {α : Type u_1} {ι : Sort u_4} {ι₂ : Sort u_6} {f : ι → ι₂},
      Function.Surjective f → ∀ (g : ι₂ → Set α), ⋃ x, g (f x) = ⋃ y, g y :=
  by sorry

The theorem `Function.Surjective.iUnion_comp` states that for any type `α`, sorts `ι` and `ι₂`, and a function `f` that maps from `ι` to `ι₂`, if `f` is surjective, then for any function `g` that maps from `ι₂` to a set of `α`, the union over all `x` of `g(f(x))` is equal to the union over all `y` of `g(y)`. In other words, it states that under a surjective function, the union of the images of a set-function remains unchanged.

If `f: ι → ι₂` is a surjective function and `g: ι₂ → Å(α)` is any function, then `⋃(x ∈ ι) g(f x) = ⋃(y ∈ ι₂) g(y)`.


theorem Finset.min_le : ∀ {α : Type u_2} [inst : LinearOrder α] {a : α} {s : Finset α}, a ∈ s → Finset.min s ≤ ↑a := by
  sorry

The theorem `Finset.min_le` states that for any type `α` with a linear order and for any element `a` of type `α` and finite set `s` of type `α`, if `a` is an element of `s`, then the minimum element of `s` is less than or equal to `a`. This minimum element is represented within the `WithTop α` type, which includes all elements of `α` together with a top element. Here, `↑a` is the lift of `a` to `WithTop α`.

For any type `α` with a linear order, if `a` is an element of a finite set `s` in `α`, then the minimum element of `s` (including the top element) is less than or equal to `a` (lifted to `WithTop α`).


theorem Set.singleton_ne_empty : ∀ {α : Type u} (a : α), {a} ≠ ∅ := by sorry

This theorem declares that a set containing a single element is not equal to an empty set. For any type `α` and any element `a` of that type, the singleton set `{a}` cannot be equal to an empty set `∅`. In essence, a set with at least one element is always distinct from an empty set.

For any type `α` and any element `a` of type `α`, the singleton set `{a}` is not equal to the empty set `∅`.


theorem CategoryTheory.Limits.Types.limit_ext :
    ∀ {J : Type v} [inst : CategoryTheory.Category.{w, v} J] (F : CategoryTheory.Functor J (Type u))
      [inst_1 : CategoryTheory.Limits.HasLimit F] (x y : CategoryTheory.Limits.limit F),
      (∀ (j : J), CategoryTheory.Limits.limit.π F j x = CategoryTheory.Limits.limit.π F j y) → x = y :=
  by sorry

The theorem `CategoryTheory.Limits.Types.limit_ext` states that for any category `J` and any functor `F` from `J` to the category of types, which has a limit, if `x` and `y` are objects in the limit of `F`, and for every object `j` in `J`, the projection from `x` to `F(j)` is the same as the projection from `y` to `F(j)`, then `x` and `y` must be equal. This theorem basically asserts the uniqueness property of limit objects in a category: any two limit objects that behave identically with respect to the morphisms defined by the functor must actually be the same object.

In any category, if two objects in the limit of a functor have identical projections to the images of all objects in the category under the functor, then they are equal.


theorem Set.uIoc_of_lt : ∀ {α : Type u_1} [inst : LinearOrder α] {a b : α}, b < a → Ι a b = Set.Ioc b a := by sorry

This theorem states that for any type `α` that has a linear order and for any two elements `a` and `b` of this type, if `b` is less than `a` then `Ι a b` equals the left-open right-closed interval from `b` to `a`. In other words, the set `Ι a b` includes all elements `x` such that `b` is less than `x` and `x` is less than or equal to `a`.

For any type `α` with a linear order and any `a` and `b` in `α` with `b < a`, the interval `Ι a b` is the set of elements `x` such that `b < x <= a`.


theorem SimpleGraph.chromaticNumber_ne_top_iff_exists :
    ∀ {V : Type u} {G : SimpleGraph V}, SimpleGraph.chromaticNumber G ≠ ⊤ ↔ ∃ n, SimpleGraph.Colorable G n := by sorry

This theorem states that for any given type `V` and a simple graph `G` of type `V`, the chromatic number of `G` is not infinite if and only if there exists some natural number `n` such that the graph `G` can be colored with at most `n` colors. In other words, a graph has a finite chromatic number if it can be colored with a finite number of colors, and vice versa.

The chromatic number of a simple graph is finite if and only if the graph can be colored using a finite number of colors.


theorem Traversable.foldMap_map :
    ∀ {α β γ : Type u} {t : Type u → Type u} [inst : Traversable t] [inst_1 : LawfulTraversable t] [inst_2 : Monoid γ]
      (f : α → β) (g : β → γ) (xs : t α), Traversable.foldMap g (f <$> xs) = Traversable.foldMap (g ∘ f) xs :=
  by sorry

The theorem `Traversable.foldMap_map` states that for any types `α`, `β`, and `γ`, and any traversable structure `t` of type `Type u → Type u`, if we have a lawful traversable instance for `t` and a monoid structure for `γ`, then for any functions `f : α → β` and `g : β → γ`, and any traversable structure `xs` of type `t α`, applying `f` to `xs` (denoted as `f <$> xs`), then folding with function `g` (i.e., `Traversable.foldMap g (f <$> xs)`) is the same as folding with the composition of `g` and `f` (i.e., `Traversable.foldMap (g ∘ f) xs`). In other words, the theorem expresses a kind of distributivity of the `foldMap` operation over the function application, which is a fundamental property in the area of functional programming and type theory.

For any traversable type `t`, monoid `γ`, and functions `f : α → β` and `g : β → γ`, given lawful traversable instances for `t` and `γ`, `Traversable.foldMap (g ∘ f) xs` equals `Traversable.foldMap g (f <$> xs)` for any traversable structure `xs` of type `t α`.


theorem Filter.eventually_iff : ∀ {α : Type u} {f : Filter α} {P : α → Prop}, (∀ᶠ (x : α) in f, P x) ↔ {x | P x} ∈ f :=
  by sorry

This theorem states that, for any type 'α', any filter 'f' on 'α', and any proposition 'P' about elements of 'α', the proposition 'P' holds eventually for some element 'x' in the filter 'f' if and only if the set of elements 'x' for which 'P' holds is in the filter 'f'. In other words, 'P' happens eventually in 'f' means the set of all values satisfying 'P' belongs to 'f'.

For any filter $f$ on a type $\alpha$ and proposition $P$ about elements of $\alpha$, $P$ holds eventually for some $x$ in $f$ if and only if the set of $x$ with $P(x)$ is in $f$.


theorem covariant_lt_iff_contravariant_le :
    ∀ (M : Type u_1) (N : Type u_2) (μ : M → N → N) [inst : LinearOrder N],
      (Covariant M N μ fun x x_1 => x < x_1) ↔ Contravariant M N μ fun x x_1 => x ≤ x_1 :=
  by sorry

The theorem `covariant_lt_iff_contravariant_le` asserts that for any two types `M` and `N`, and a function `μ` mapping from `M` and `N` to `N`, given a linear order on `N`, the property that `μ` is covariant with respect to the "less than" relation, i.e., `μ m n₁ < μ m n₂` whenever `n₁ < n₂` for any `m`, is equivalent to the property that `μ` is contravariant with respect to the "less than or equal to" relation, i.e., if `μ m n₁ ≤ μ m n₂` then `n₁ ≤ n₂` for any `m`. This is a statement about the preservation of order relations under the action of a function from some type onto another type.

For any function `μ` from type `M` to type `N` and linear order on `N`, `μ` is covariant with respect to the "less than" relation if and only if it is contravariant with respect to the "less than or equal to" relation, i.e., `μ m n₁ < μ m n₂` if and only if `n₁ ≤ n₂` for all `m`.


theorem lt_of_nsmul_lt_nsmul_right :
    ∀ {M : Type u_3} [inst : AddMonoid M] [inst_1 : LinearOrder M]
      [inst_2 : CovariantClass M M (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1]
      [inst_3 : CovariantClass M M (Function.swap fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] {a b : M} (n : ℕ),
      n • a < n • b → a < b :=
  by sorry

The theorem `lt_of_nsmul_lt_nsmul_right` states that for any type `M` that is an additive monoid and a linearly ordered set, where both the normal addition operation and its swapped version are covariant i.e., if `x ≤ y` then `x + z ≤ y + z` and `z + x ≤ z + y` for all `x, y, z` in `M`, then whenever the `n`-fold sum of `a` (denoted `n • a`) is less than the `n`-fold sum of `b` (denoted `n • b`), it follows that `a` is less than `b`. This is for any natural number `n` and any `a, b` in `M`. In other words, if the repeated sum of `a` is less than the repeated sum of `b`, then `a` itself must be less than `b`.

If `M` is an additive monoid and a linearly ordered set where the normal and swapped addition operations are covariant, then for all natural numbers `n` and elements `a, b` in `M`, if `n • a` is strictly less than `n • b`, then `a` is strictly less than `b`.


theorem OrderIso.bddAbove_image :
    ∀ {α : Type u} {β : Type v} [inst : Preorder α] [inst_1 : Preorder β] (e : α ≃o β) {s : Set α},
      BddAbove (⇑e '' s) ↔ BddAbove s :=
  by sorry

The theorem `OrderIso.bddAbove_image` states that for any two types `α` and `β`, both equipped with a preorder, and an order isomorphism `e` from `α` to `β`, a set `s` of type `α` is bounded above if and only if the image of `s` under the isomorphism `e` is also bounded above. This theorem basically shows that the property of being bounded above is preserved under an order isomorphism.

For any preorders on types `α` and `β`, and an order isomorphism `e` from `α` to `β`, if a subset `s` of `α` is bounded above, then the image of `s` under `e` is also bounded above.


theorem Nat.bit1_eq_succ_bit0 : ∀ (n : ℕ), bit1 n = Nat.succ (bit0 n) := by sorry

The theorem `Nat.bit1_eq_succ_bit0` states that for all natural numbers `n`, the operation `bit1 n` is equivalent to the successor of `bit0 n`. Here, `bit1 n` represents the operation of doubling a number and adding one, while `bit0 n` simply doubles the number. The `Nat.succ` function increments a natural number by one, thus `Nat.succ (bit0 n)` doubles a number and then increments it by one. Therefore, the theorem shows that these two operations are fundamentally the same.

The theorem asserts that for all natural numbers `n`, the operation `bit1 n` equal `Nat.succ (bit0 n)`, where `bit0 n` doubles `n` and `bit1 n` doubles `n` and adds one.


Not.imp

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

This theorem states that for any two propositions `a` and `b`, if `b` is not true (denoted by `¬b`), and if `a` implies `b` (denoted by `a → b`), then `a` is also not true (denoted by `¬a`). This is a fundamental result in logic, expressing the idea that if a proposition's truth implies the truth of a falsehood, then the original proposition itself must be false.

If `a` implies `b` and `¬b` holds, then `¬a` holds. (This is known as the contrapositive of the implication "if `a`, then `b`," and is logically equivalent to it.)


theorem AddSubgroup.mem_top : ∀ {G : Type u_1} [inst : AddGroup G] (x : G), x ∈ ⊤ := by sorry

This theorem states that for all types `G`, given that `G` has an `AddGroup` instance, any element `x` of `G` belongs to the top additive subgroup. In other words, every element of an additive group is a member of the group's top (universal) subgroup.

For any additive group G, every element x of G belongs to its top additive subgroup.


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

The theorem `MeasureTheory.integral_sub'` states that for any measurable space `α`, normed additively commutative group `G`, normed space over reals `ℝ` and `G`, measure `μ` on the measurable space `α`, and two functions `f` and `g` from `α` to `G`, if both `f` and `g` are integrable with respect to measure `μ`, then the integral of the difference function `(f - g)` with respect to measure `μ` is equal to the difference of the integrals of `f` and `g` with respect to measure `μ`. In mathematical terms, this is stating that ∫ (f - g) dμ = ∫ f dμ - ∫ g dμ, given that both `f` and `g` are integrable.

If measurable functions `f` and `g` from a measurable space to a normed additively commutative group, integrable with respect to a measure `μ`, then ∫(f - g) dμ = ∫fdμ - ∫gdμ.


theorem uniformity_hasBasis_closed :
    ∀ {α : Type ua} [inst : UniformSpace α],
      Filter.HasBasis (uniformity α) (fun V => V ∈ uniformity α ∧ IsClosed V) id :=
  by sorry

This theorem states that for any type `α` which has a `UniformSpace` structure, the uniformity on `α` has a basis given by a certain property. Specifically, the basis sets for the uniformity are those sets `V` that belong to the uniformity and are also closed. Here, `Filter.HasBasis` is a concept from filter theory in topology, which describes when a filter is generated by a certain collection of sets. The `id` function in the theorem signifies that the sets themselves are used as a basis, not some function of the sets.

For any uniform space `(α, U)` with type `α`, the basis of its uniformity `U` is given by the closed sets belonging to `U`.


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

This theorem, `Mathlib.Order.Lattice._auxLemma.6`, is a statement about semilattice structures in order theory. Specifically, it says that for any type `α` that has a semilattice structure (denoted by `SemilatticeSup α`), for any two elements `a` and `b` of `α`, the supremum (join or least upper bound) of `a` and `b` being equal to `b` is equivalent to `a` being less than or equal to `b`. In mathematical terms, this is saying that $a \vee b = b \iff a \leq b$ where $\vee$ represents the supremum operation.

For any semilattice `α`, `a ≤ b` if and only if `a ⨝ b = b`, where `⨝` denotes the supremum (join) operation.


theorem IsRelPrime.of_add_mul_left_left :
    ∀ {R : Type u} [inst : CommSemiring R] {x y z : R}, IsRelPrime (x + y * z) y → IsRelPrime x y := by sorry

The theorem `IsRelPrime.of_add_mul_left_left` states that for any commutative semiring `R`, and for any elements `x`, `y`, and `z` of `R`, if `x + y * z` and `y` are relatively prime, then `x` and `y` are also relatively prime. In this context, two elements being relatively prime means that any common divisor of the two is a unit.

If `x`, `y` are elements of a commutative semiring `R` such that `y` is a common divisor of `x` and `x + y*z` for some `z` in `R`, then `y` is a unit in `R` if and only if `x` and `y` are relatively prime.