theorem Set.Finite.exists_finset_coe : ∀ {α : Type u} {s : Set α}, Set.Finite s → ∃ s', ↑s' = s := by sorry

This theorem states that for every set `s` of any type `α`, if `s` is a finite set (`Set.Finite s`), then there exists a finset `s'` such that the conversion of `s'` to a set is equal to `s`. In other words, any finite set can be represented as a finset in Lean.

Given any finite set `s` of type `α` in Lean, there exists a finset `s'` such that `s'` is equal to `s` as sets.


theorem maximals_subset : ∀ {α : Type u_1} (r : α → α → Prop) (s : Set α), maximals r s ⊆ s := by sorry

The theorem `maximals_subset` states that for any type `α`, any binary relation `r` on `α`, and any set `s` of type `α`, the set of maximal elements in `s` (with respect to `r`) is a subset of `s`. Here, a maximal element of `s` is an element `a` in `s` such that for any other element `b` in `s`, if `r` holds between `a` and `b`, then `r` also holds between `b` and `a`.

For any type `α`, relation `r` on `α`, and set `s` of `α`, the set of maximal elements in `s` (with respect to `r`) is a subset of `s`. (A maximal element `a` in `s` is an element such that for all `b` in `s`, if `a` `r` `b`, then `b` `r` `a`.)


theorem MeasureTheory.Measure.map_inv_eq_self :
    ∀ {G : Type u_2} [inst : MeasurableSpace G] [inst_1 : Inv G] (μ : MeasureTheory.Measure G)
      [inst_2 : MeasureTheory.Measure.IsInvInvariant μ], MeasureTheory.Measure.map Inv.inv μ = μ :=
  by sorry

This theorem states that for any type `G` that has a measurable space structure and an inversion operation (`Inv`), and for any measure `μ` on `G` that is invariant under inversion (`MeasureTheory.Measure.IsInvInvariant`), the pushforward of the measure `μ` under the inversion map is equal to `μ` itself. In simpler terms, it says that if a measure doesn't change when you 'flip' all the elements in the space it's defined on, then applying the 'flipping' transformation itself to the measure doesn't change the measure.

For any measurable space `(G, Σ)` with an inversion operation `Inv` and a measure `μ` that is invariant under `Inv`, the pushforward measure `μ ∘ Inv` equals `μ`.


theorem Cardinal.derivFamily_lt_ord_lift :
    ∀ {ι : Type u} {f : ι → Ordinal.{max u v} → Ordinal.{max u v}} {c : Cardinal.{max u v}},
      Cardinal.IsRegular c →
        Cardinal.lift.{v, u} (Cardinal.mk ι) < c →
          c ≠ Cardinal.aleph0 →
            (∀ (i : ι), ∀ b < Cardinal.ord c, f i b < Cardinal.ord c) →
              ∀ {a : Ordinal.{max u v}}, a < Cardinal.ord c → Ordinal.derivFamily f a < Cardinal.ord c :=
  by sorry

The theorem `Cardinal.derivFamily_lt_ord_lift` states that for any regular cardinal number `c` which is not equal to `ℵ₀` (the smallest infinite cardinal), if the lift of the cardinal number of a type `ι` is less than `c`, and for all function `f : ι → Ordinal → Ordinal` that for all `i` in `ι` and any ordinal `b` less than the ordinal of `c` the value `f i b` is less than the ordinal of `c`. Then for any ordinal `a` less than the ordinal of `c`, the derivative of the family `f` evaluated at `a` is also less than the ordinal of `c`. In simpler terms, this theorem is about certain properties and bounds of ordinal functions and regular cardinals.

For any regular cardinal `c` different from `ℵ₀` and any function `f : ι → Ordinal → Ordinal` such that the lift of the cardinality of `ι` is less than `c` and `f i b` is less than the ordinal of `c` for all `i` in `ι` and ordinal `b` less than the ordinal of `c`, the derivative of `f` at any ordinal `a` less than the ordinal of `c` is also less than the ordinal of `c`.


theorem Finset.card_Ioo_eq_card_Ico_sub_one :
    ∀ {α : Type u_2} [inst : PartialOrder α] [inst_1 : LocallyFiniteOrder α] (a b : α),
      (Finset.Ioo a b).card = (Finset.Ico a b).card - 1 :=
  by sorry

This theorem states that for any partially ordered, locally finite type `α` and any two elements `a` and `b` of that type, the cardinality (or size) of the set of elements `x` such that `a < x` and `x < b` (represented as `Finset.Ioo a b` in Lean 4) is equal to the cardinality of the set of elements `x` such that `a ≤ x` and `x < b` (represented as `Finset.Ico a b` in Lean 4) minus 1. In other words, the set of strictly between elements is always one element less than the set of elements inclusive of the lower bound.

The cardinality of the set of strictly between elements in a partially ordered, locally finite type is one less than the cardinality of the set of elements with the lower bound included and the upper bound excluded.


theorem Real.cosh_zero : Real.cosh 0 = 1 := by sorry

This theorem states that the value of the real hyperbolic cosine function, `Real.cosh`, at the point zero is equal to one. In other words, in mathematical terms $\cosh(0) = 1$.

The real hyperbolic cosine function evaluates to 1 at 0: `Real.cosh 0 = 1`.


theorem ext_inner_right :
    ∀ (𝕜 : Type u_1) {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
      {x y : E}, (∀ (v : E), ⟪x, v⟫_𝕜 = ⟪y, v⟫_𝕜) → x = y :=
  by sorry

The theorem `ext_inner_right` states that in any inner product space `E` over a field `𝕜`, if two vectors `x` and `y` have the same inner product with every other vector `v` in the space, then `x` and `y` are equal. This essentially means that a vector is uniquely defined by its inner products with all other vectors in the space.

If two vectors in an inner product space have the same inner product with every other vector, then they are equal.


theorem MeasureTheory.le_hitting :
    ∀ {Ω : Type u_1} {β : Type u_2} {ι : Type u_3} [inst : ConditionallyCompleteLinearOrder ι] {u : ι → Ω → β}
      {s : Set β} {n m : ι}, n ≤ m → ∀ (ω : Ω), n ≤ MeasureTheory.hitting u s n m ω :=
  by sorry

The theorem `MeasureTheory.le_hitting` states that for any types `Ω`, `β`, and `ι`, and given a conditionally complete linear order on `ι`, a function `u` from `ι` and `Ω` to `β`, a set `s` of elements of type `β`, and two elements `n` and `m` of type `ι` such that `n` is less than or equal to `m`, then for any element `ω` of type `Ω`, `n` is less than or equal to the hitting measure of `u`, `s`, `n`, `m`, and `ω`. In mathematical terms, this theorem asserts that the hitting measure of a function on a set is a non-decreasing function of its input parameters.

For any conditionally complete linear order `ι`, function `u` from `ι × Ω` to `β`, set `s ⊆ β`, and elements `n ≤ m` of `ι`, if `ω` is an element of `Ω`, then `u(n, ω) ≤ u(m, ω)` holds in the hitting measure.


theorem QuadraticForm.toQuadraticForm_associated :
    ∀ (S : Type u_1) {R : Type u_3} {M : Type u_4} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M]
      [inst_3 : CommSemiring S] [inst_4 : Algebra S R] [inst_5 : Invertible 2] (Q : QuadraticForm R M),
      LinearMap.BilinForm.toQuadraticForm ((QuadraticForm.associatedHom S) Q) = Q :=
  by sorry

The theorem `QuadraticForm.toQuadraticForm_associated` states that for any Quadratic Form `Q` over a Module `M` with coefficients in a Commutative Ring `R`, and any type `S` with a Commutative Semiring structure and an Algebra structure over `R`, when `Q` is converted to a Linear Map BilinForm through the associatedHom function and then converted back to a Quadratic Form using the `LinearMap.BilinForm.toQuadraticForm` function, the resulting Quadratic Form is equivalent to the original Quadratic Form `Q`. This is under the assumption that the number 2 is invertible in the setting.

For any Quadratic Form `Q` over a module `M` with coefficients in a commutative ring `R`, and any commutative semiring `S` with an algebra structure over `R`, if `2` is invertible, then `QuadraticForm.toQuadraticForm_associated Q` is equal to `Q`.


theorem Set.LeftInvOn.map_nhdsWithin_eq :
    ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] {f : α → β} {g : β → α}
      {x : β} {s : Set β},
      Set.LeftInvOn f g s →
        f (g x) = x →
          ContinuousWithinAt f (g '' s) (g x) →
            ContinuousWithinAt g s x → Filter.map g (nhdsWithin x s) = nhdsWithin (g x) (g '' s) :=
  by sorry

The theorem `Set.LeftInvOn.map_nhdsWithin_eq` states that for any types `α` and `β` that are topological spaces, given two functions `f : α → β` and `g : β → α`, a point `x` of type `β`, and a set `s` of type `β`, if `f` is a left inverse to `g` on `s`, `f (g x)` equals `x`, `f` is continuous at `g x` within the image of `s` under `g`, and `g` is continuous at `x` within `s`, then the forward map of the "neighbourhood within" filter of `x` in `s` under `g` equals the "neighbourhood within" filter of `g x` in the image of `s` under `g`. In simpler terms, it says that if `f` and `g` satisfy certain conditions relating to continuity and being inverses, then applying `g` to the "close" elements to `x` in `s` gives the same result as looking at the "close" elements to `g x` in the image of `s` under `g`.

If functions `f : α → β` and `g : β → α` satisfy `f ∘ g = id_β` on a set `s ⊆ β`, `f` is continuous at `g x` in the image of `s` under `g`, and `g` is continuous at `x` in `s`, then the forward image of the neighborhood filter of `x` in `s` under `g` equals the neighborhood filter of `g x` in the image of `s` under `g`.


theorem le_tsum :
    ∀ {ι : Type u_1} {α : Type u_3} [inst : OrderedAddCommMonoid α] [inst_1 : TopologicalSpace α]
      [inst_2 : OrderClosedTopology α] {f : ι → α},
      Summable f → ∀ (i : ι), (∀ (j : ι), j ≠ i → 0 ≤ f j) → f i ≤ ∑' (i : ι), f i :=
  by sorry

The theorem `le_tsum` states that for any given types `ι` and `α`, where `α` is an ordered additive commutative monoid with a topological space structure and its order is closed, and given a function `f` from `ι` to `α`, if `f` is summable, then for any element `i` in `ι`, if for all `j` in `ι` where `j` is not equal to `i`, `f j` is nonnegative, then the value of `f i` is less than or equal to the infinite sum of the values of `f`. In other words, any individual term in an infinite summation of nonnegative terms is less than or equal to the entire sum.

If `f` is a summable function from a type `ι` to an ordered additive commutative monoid `α` with a topological space structure and closed order, then for any `i` in `ι` where `f` is nonnegative at all other indices, we have `f i ≤ ∑ j ∈ ι f j`.


TopologicalAddGroup.ext

theorem TopologicalAddGroup.ext :
    ∀ {G : Type u_1} [inst : AddGroup G] {t t' : TopologicalSpace G},
      TopologicalAddGroup G → TopologicalAddGroup G → nhds 0 = nhds 0 → t = t' :=
  by sorry

This theorem states that for any type `G` equipped with an additive group structure, and two topological structures `t` and `t'` on `G`, if `G` is a topological additive group under both `t` and `t'` and the neighborhood filters at zero for both `t` and `t'` coincide, then these two topological structures `t` and `t'` must be the same. In other words, the topological structure on a topological additive group is uniquely determined by the neighborhood filter at zero.

Given a topological additive group `G` with two topologies `t` and `t'` having identical zero-neighborhood filters, `t` equals `t'`.


theorem toIocMod_add_toIocDiv_zsmul :
    ∀ {α : Type u_1} [inst : LinearOrderedAddCommGroup α] [hα : Archimedean α] {p : α} (hp : 0 < p) (a b : α),
      toIocMod hp a b + toIocDiv hp a b • p = b :=
  by sorry

The theorem `toIocMod_add_toIocDiv_zsmul` states that for any type `α` that is a linearly ordered additive commutative group with the Archimedean property, and for any positive `p` in `α` and any elements `a` and `b` in `α`, the sum of the result of reducing `b` to the interval `(a, a + p)` and the integer multiple of `p` that is the unique integer such that this multiple of `p`, subtracted from `b`, is in the interval `(a, a + p)` is equal to `b`. In other words, `b` can be decomposed into a part that lies in the interval `(a, a + p)` (given by `toIocMod hp a b`) and the rest, which is an integer multiple of `p` (given by `toIocDiv hp a b • p`).

For any Archimedean linearly ordered additive commutative group `α` and positive `p` in `α`, for all `a, b` in `α`, there exists an integer `n` such that `b = toIocMod p a b + n*p`, where `toIocMod` is the operation of reducing an element to the interval `(a, a+p)`.


theorem balancedCore_mem_nhds_zero :
    ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : NontriviallyNormedField 𝕜] [inst_1 : AddCommGroup E] [inst_2 : Module 𝕜 E]
      [inst_3 : TopologicalSpace E] [inst_4 : ContinuousSMul 𝕜 E] {U : Set E}, U ∈ nhds 0 → balancedCore 𝕜 U ∈ nhds 0 :=
  by sorry

This theorem states that for any non-trivial normed field `𝕜` and an additive commutative group `E` over which `𝕜` is a module, if `U` is a set in `E` that belongs to the neighborhood of zero in the topological space of `E`, then the largest balanced subset of `U` also belongs to the neighborhood of zero. Here, a balanced set is one that is stable under scalar multiplication. The theorem assumes that the action of `𝕜` on `E` is continuous.

If `U` is a neighborhood of zero in a normed vector space `(𝕜, E)` over a non-trivial normed field `𝕜`, where the `𝕜`-module action on `E` is continuous, then the largest balanced subset of `U` is also a neighborhood of zero.


MeasurableEmbedding.id

theorem MeasurableEmbedding.id : ∀ {α : Type u_1} {mα : MeasurableSpace α}, MeasurableEmbedding id := by sorry

This theorem states that, for any type `α` and any measurable space `mα` over `α`, the identity function is a measurable embedding. In other words, it ensures that the identity function, which leaves every input unchanged, preserves the measurable structure of a space. This means that it maps measurable sets to measurable sets and is injective, which is a property required for measurable embeddings.

The identity function is a measurable embedding for any measurable space.


theorem tendsto_iff_norm_sub_tendsto_zero :
    ∀ {α : Type u_3} {E : Type u_6} [inst : SeminormedAddGroup E] {f : α → E} {a : Filter α} {b : E},
      Filter.Tendsto f a (nhds b) ↔ Filter.Tendsto (fun e => ‖f e - b‖) a (nhds 0) :=
  by sorry

This theorem, `tendsto_iff_norm_sub_tendsto_zero`, establishes an equivalence between two conditions for a function `f` from an arbitrary type `α` into a seminormed add group `E`. The function `f` is said to tend towards a value `b` with respect to a filter `a` if and only if the norm of the difference between `f(e)` and `b` tends towards zero with respect to the same filter `a`. Here, tending towards a value is defined in terms of the `Filter.Tendsto` function, which says that for every neighborhood of the targeted value, the preimage under `f` of that neighborhood is a neighborhood with respect to the filter.

A function `f : α → E` from type `α` to a seminormed add group `E` tends towards `b` with respect to a filter `a` if and only if the norm of `f(e) - b` tends towards 0 with respect to `a`.


theorem Set.indicator_apply_nonneg :
    ∀ {α : Type u_2} {M : Type u_4} [inst : Preorder M] [inst_1 : Zero M] {s : Set α} {f : α → M} {a : α},
      (a ∈ s → 0 ≤ f a) → 0 ≤ Set.indicator s f a :=
  by sorry

The theorem `Set.indicator_apply_nonneg` states that for any type `α` and any preorder `M` with zero, given a set `s` of type `α`, a function `f` from `α` to `M`, and an element `a` of type `α`, if `a` is in the set `s` implies that `f(a)` is greater than or equal to zero, then the indicator function of `s` and `f` at `a` is also greater than or equal to zero. In simpler words, this theorem guarantees that if a function `f` applied to an element produces non-negative results for all elements in a set `s`, then the indicator function of `s` and `f`, which gives `f(a)` if `a` is in `s` and `0` otherwise, also produces a non-negative result for any given element.

If `f: α → M` is a function with `M` a preorder having a zero, and `s ⊆ α` is a set such that `a ∈ s` implies `f(a) ≥ 0`, then `indicator s x ≥ 0` whenever `x ∈ α` and `x ∈ s`.


theorem Subalgebra.inv_mem_of_algebraic :
    ∀ {K : Type u_3} {L : Type u_4} [inst : Field K] [inst_1 : Field L] [inst_2 : Algebra K L] (A : Subalgebra K L)
      {x : ↥A}, IsAlgebraic K ↑x → (↑x)⁻¹ ∈ A :=
  by sorry

The theorem `Subalgebra.inv_mem_of_algebraic` states that for any two types `K` and `L` that are fields, with `L` being a `K`-algebra, and for any subalgebra `A` of `L` over `K`, if an element `x` of `A` is algebraic over `K`, then the multiplicative inverse of `x` (denoted `(↑x)⁻¹`) also belongs to `A`. Here, being algebraic means that `x` is a root of some non-zero polynomial with coefficients in `K`.

In the context of algebra, this theorem guarantees that if we have an element in a subalgebra that is algebraic over the base field, then its inverse also remains in the subalgebra, ensuring that subalgebras are closed under inversion for algebraic elements.

If `A` is a subalgebra of a `K`-algebra `L`, and `x` is an algebraic element of `A` over `K`, then `(↑x)⁻¹` is also in `A`.


theorem ZMod.natAbs_valMinAbs_le : ∀ {n : ℕ} [inst : NeZero n] (x : ZMod n), Int.natAbs (ZMod.valMinAbs x) ≤ n / 2 := by
  sorry

This theorem states that for any non-zero natural number `n` and any element `x` from the integers modulo `n`, the absolute value of the minimum absolute value representation of `x` is less than or equal to `n / 2`. In other words, the absolute value of the integer within the same equivalence class as `x` (from the integers modulo `n`) that is closest to `0` is always less than or equal to `n/2`. This ensures that the representative chosen for each equivalence class in modulo `n` arithmetic is as close as possible to zero.

For any non-zero integer `x` modulo `n`, the absolute value of its minimum representative is bounded by `n/2`.


Computation.LiftRel.imp

theorem Computation.LiftRel.imp :
    ∀ {α : Type u} {β : Type v} {R S : α → β → Prop},
      (∀ {a : α} {b : β}, R a b → S a b) →
        ∀ (s : Computation α) (t : Computation β), Computation.LiftRel R s t → Computation.LiftRel S s t :=
  by sorry

This theorem states that for any types `α` and `β`, and any relations `R` and `S` between `α` and `β`, if `R` implies `S` for every pair of elements `(a, b)` from `α` and `β` respectively, then for any computations `s` of type `α` and `t` of type `β`, if the computation relation `LiftRel` holds for `R`, `s`, and `t`, then it also holds for `S`, `s`, and `t`. In other words, if a relation `R` between the results of two computations implies another relation `S`, and `R` holds according to the `LiftRel` definition, then `S` also holds according to the `LiftRel` definition.

If relation R implies relation S between types α and β, and LiftRel(R) holds for computations s : α and t : β, then LiftRel(S) also holds for s and t.


theorem Uncountable.of_equiv : ∀ {β : Sort v} (α : Sort u_1) [inst : Uncountable α], α ≃ β → Uncountable β := by sorry

This theorem is stating that if there is an equivalence (bijective mapping) between two types, `α` and `β`, and `α` is uncountable, then `β` must also be uncountable. In other words, uncountability is preserved under equivalence relations. This is similar to saying that if you have an uncountable set in the mathematical sense (like the set of real numbers) and you can establish a one-to-one correspondence between this set and another set, the other set is also uncountable.

If `α` is an uncountable type and there exists an equivalence relation between `α` and `β`, then `β` is also an uncountable type.


theorem MeasurableEmbedding.aemeasurable_map_iff :
    ∀ {α : Type u_2} {β : Type u_3} {γ : Type u_4} {m0 : MeasurableSpace α} [inst : MeasurableSpace β]
      [inst_1 : MeasurableSpace γ] {f : α → β} {μ : MeasureTheory.Measure α} {g : β → γ},
      MeasurableEmbedding f → (AEMeasurable g (MeasureTheory.Measure.map f μ) ↔ AEMeasurable (g ∘ f) μ) :=
  by sorry

This theorem states that for any three types `α`, `β` and `γ` that have corresponding measurable spaces `m0`, `inst` and `inst_1`, and functions `f : α → β` and `g : β → γ`, and a measure `μ` on `α`, then if `f` is a measurable embedding, it follows that `g` is almost everywhere measurable with respect to the push-forward measure `f` applied to `μ` if and only if the composition `g ∘ f` is almost everywhere measurable with respect to `μ`. Here, a function is defined to be almost everywhere measurable if it is equal almost everywhere to a measurable function, while a measurable embedding is a function that is both injective and measurable, and the push-forward of a measure via a function `f` is a new measure on the target space of `f`.

A measurable embedding `f : α → β` makes `g : β → γ` almost everywhere measurable with respect to the pushforward measure if and only if the composition `g ∘ f` is almost everywhere measurable with respect to the original measure.


theorem ArithmeticFunction.mul_apply :
    ∀ {R : Type u_1} [inst : Semiring R] {f g : ArithmeticFunction R} {n : ℕ},
      (f * g) n = Finset.sum (Nat.divisorsAntidiagonal n) fun x => f x.1 * g x.2 :=
  by sorry

The theorem `ArithmeticFunction.mul_apply` states that for any semiring `R` and any two arithmetic functions `f` and `g` from natural numbers into `R`, the value of the product of `f` and `g` at any natural number `n` is equal to the sum over the divisor antidiagonal of `n` of the products of the values of `f` at the first element of the pair and `g` at the second element of the pair. Here, the divisor antidiagonal of `n` is the set of pairs of natural numbers whose product is `n`.

For any semiring R and arithmetic functions f and g from natural numbers to R, the product of f and g at a natural number n equals the sum, over the divisor antidiagonal of n, of the products of f at the first element and g at the second element of each pair.


theorem List.nodupKeys_cons :
    ∀ {α : Type u} {β : α → Type v} {s : Sigma β} {l : List (Sigma β)},
      List.NodupKeys (s :: l) ↔ s.fst ∉ List.keys l ∧ List.NodupKeys l :=
  by sorry

This theorem states that for any type `α`, a type `β` that is a function of `α`, a `Sigma β` object `s`, and a list of `Sigma β` objects `l`, the list has no duplicate keys (`List.NodupKeys`) when `s` is added to the front of `l` (`s :: l`) if and only if the first component of `s` (`s.fst`) is not in the list of keys of `l` (`List.keys l`) and `l` itself has no duplicate keys (`List.NodupKeys l`). In other words, a list of key-value pairs has distinct keys if each key is unique and none of them repeats in the remaining list.

For any type `α` and lists `l` and `[s]` of `Σβα` pairs, `l` has no duplicate keys when `s` is prepended if and only if the first component of `s` is not in the keys of `l` and `l` is itself key-unique.


theorem CategoryTheory.GrothendieckTopology.Cover.ext :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X : C} {J : CategoryTheory.GrothendieckTopology C}
      (S T : CategoryTheory.GrothendieckTopology.Cover J X),
      (∀ ⦃Y : C⦄ (f : Y ⟶ X),
          (CategoryTheory.GrothendieckTopology.Cover.sieve S).arrows f ↔
            (CategoryTheory.GrothendieckTopology.Cover.sieve T).arrows f) →
        S = T :=
  by sorry

This theorem states that for any category `C`, any object `X` in `C`, and any Grothendieck topology `J` on `C`, two covers `S` and `T` of `X` with respect to `J` are equal if and only if for every object `Y` in `C` and every morphism `f` from `Y` to `X`, `f` is an arrow in the sieve associated to `S` if and only if `f` is an arrow in the sieve associated to `T`. In other words, the covers `S` and `T` are determined by the arrows in their associated sieves.

For any category `C`, object `X`, and Grothendieck topology `J`, covers `S` and `T` of `X` with respect to `J` are equal if and only if their associated sieves have the same collections of morphisms to `X`.


theorem Int.le_sub_one_iff : ∀ {a b : ℤ}, a ≤ b - 1 ↔ a < b := by sorry

This theorem states that for any two integers `a` and `b`, the condition `a` being less than or equal to `b - 1` is equivalent to `a` being strictly less than `b`. This can be seen as a way of expressing strict inequality (`<`) in terms of a non-strict inequality (`≤`) with an offset of `-1` on one side.

For any integers `a` and `b`, `a ≤ b - 1` if and only if `a < b`.


theorem Nat.dvd_of_mem_divisors : ∀ {n m : ℕ}, n ∈ Nat.divisors m → n ∣ m := by sorry

This theorem states that for any two natural numbers `n` and `m`, if `n` is an element of the set of divisors of `m` (i.e., `n` is in `Nat.divisors m`), then `n` divides `m`. The set of divisors of a number, as defined above, is a set of numbers that can divide that number without leaving a remainder. In mathematical terms, this theorem is saying that if `n` is a divisor of `m`, then `m` is a multiple of `n`.

For any natural numbers `n` and `m`, if `n` is a divisor of `m` then `m` is a multiple of `n`.


theorem Filter.disjoint_comap_iff :
    ∀ {α : Type u} {β : Type v} {g₁ g₂ : Filter β} {m : α → β},
      Function.Surjective m → (Disjoint (Filter.comap m g₁) (Filter.comap m g₂) ↔ Disjoint g₁ g₂) :=
  by sorry

The theorem `Filter.disjoint_comap_iff` states that for any types `α` and `β`, filters `g₁` and `g₂` on `β`, and a surjective function `m` from `α` to `β`, the preimage filters of `g₁` and `g₂` under `m` are disjoint if and only if `g₁` and `g₂` themselves are disjoint. Here, two elements of a lattice (in this case, the lattice of filters) are said to be disjoint if their infimum is the bottom element. A function is surjective if every element of the codomain is the image of some element of the domain under the function.

For filters $g\_1$ and $g\_2$ on type $\beta$, and a surjective function $m$ from type $\alpha$ to $\beta$, the preimages of $g\_1$ and $g\_2$ under $m$ are disjoint if and only if $g\_1$ and $g\_2$ themselves are disjoint in the lattice of filters.


theorem leftLim_eq_of_eq_bot :
    ∀ {α : Type u_1} {β : Type u_2} [inst : LinearOrder α] [inst_1 : TopologicalSpace β] [hα : TopologicalSpace α]
      [h'α : OrderTopology α] (f : α → β) {a : α}, nhdsWithin a (Set.Iio a) = ⊥ → Function.leftLim f a = f a :=
  by sorry

The theorem `leftLim_eq_of_eq_bot` states that for any two types `α` and `β` such that `α` has a linear order and both `α` and `β` have topological spaces, with `α` also possessing an order topology, and for any function `f` from `α` to `β` and any element `a` of `α`, if the intersection of the set of all elements less than `a` (represented by `Set.Iio a`) and a neighborhood of `a` (represented by `nhdsWithin a (Set.Iio a)`) is the empty set (represented by `⊥`), then the left limit of the function `f` at `a` is equal to the value of the function `f` at `a`. In other words, if `a` has no points immediately to its left, the left limit of `f` at `a` is just `f(a)`.

If the set of elements strictly less than a in a linearly ordered type α with an order topology intersects no neighborhood of a in this topology, then the left limit of a function from α to a topological space β at a is equal to f(a).


theorem AddConstMapClass.map_add_nat' :
    ∀ {F : Type u_1} {G : Type u_2} {H : Type u_3} {b : H} [inst : AddMonoidWithOne G] [inst_1 : AddMonoid H]
      [inst_2 : AddConstMapClass F G H 1 b] (f : F) (x : G) (n : ℕ), f (x + ↑n) = f x + n • b :=
  by sorry

This theorem states that for any types `F`, `G`, and `H`, given an element `b` of type `H`, an `AddMonoidWithOne` instance for `G`, an `AddMonoid` instance for `H`, and an `AddConstMapClass` instance for `F`, `G`, `H` with `1` and `b`, for any function `f` from `F` to `G`, any element `x` of `G`, and any natural number `n`, the function `f` applied to the sum of `x` and the natural number `n` (coerced to `G`) is equal to the sum of `f` applied to `x` and `n` multiplied by `b` (using scalar multiplication).

For any types `F`, `G`, and `H`, given an `AddMonoidWithOne` `b` in `H`, `AddMonoid` structures on `G` and `H`, and an `AddConstMapClass` for `F`, `G`, `H` with `1` and `b`, for any function `f` from `F` to `G`, `x` in `G`, and natural number `n`, we have `f(x + n) = f(x) + n * b`.


theorem Complex.normSq_eq_zero : ∀ {z : ℂ}, Complex.normSq z = 0 ↔ z = 0 := by sorry

This theorem states that for any complex number `z`, the norm-squared function `Complex.normSq z` equals zero if and only if `z` itself is zero. The norm-squared function for a complex number is defined as the square of the real part plus the square of the imaginary part. Hence, both parts must be zero for the norm-squared to be zero, which implies that the complex number itself is zero.

The theorem asserts that the norm-squared of a complex number equals zero if and only if the complex number is the zero.


theorem AddSubmonoid.neg_le : ∀ {G : Type u_2} [inst : AddGroup G] (S T : AddSubmonoid G), -S ≤ T ↔ S ≤ -T := by sorry

This theorem states that for any given type `G` that has an addition group structure, and for any two additive submonoids `S` and `T` of `G`, the negation (taking additive inverses) of `S` is a subset of `T` if and only if `S` is a subset of the negation of `T`. In other words, it's saying that the inverse of `S` being contained in `T` and `S` being contained in the inverse of `T` are equivalent conditions.

For any additive submonoids `S` and `T` of an additive group `G`, `-S` is a subset of `T` if and only if `S` is a subset of `-T`.


theorem MeasureTheory.prob_le_one :
    ∀ {α : Type u_1} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} {s : Set α}
      [inst : MeasureTheory.IsProbabilityMeasure μ], ↑↑μ s ≤ 1 :=
  by sorry

This theorem states that for any type `α`, any measurable space `m0` of type `α`, any measure `μ` of the measurable space `α`, and any set `s` of type `α`, if `μ` is a probability measure, then the measure `μ(s)` of the set `s` is less than or equal to one. In mathematical terms, if `μ` is a probability measure on a measurable space, then for any set `s` in that space, the measure of `s` (denoted as `μ(s)`) is bounded by 1.

For any probability measure `μ` on a measurable space `(α, m0)`, the measure of any set `s` in `α` satisfies `μ(s) ≤ 1`.


CategoryTheory.IsSeparating.isDetecting

theorem CategoryTheory.IsSeparating.isDetecting :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.Balanced C] {𝒢 : Set C},
      CategoryTheory.IsSeparating 𝒢 → CategoryTheory.IsDetecting 𝒢 :=
  by sorry

This theorem states that for any category `C` that is balanced (meaning that every morphism that factors through an isomorphism is itself an isomorphism), if a set of objects `𝒢` in `C` is separating (meaning the functors `C(G, -)` for `G ∈ 𝒢` are collectively faithful, i.e., if `h ≫ f = h ≫ g` for all `h` with domain in `𝒢`, then `f = g`), then `𝒢` is also detecting (meaning the functors `C(G, -)` collectively reflect isomorphisms, i.e., if any `h` with domain in `𝒢` uniquely factors through `f`, then `f` is an isomorphism). In simple terms, in a balanced category, a separating set of objects is also a detecting set.

In a balanced category, a separating set of objects is also a detecting set.


theorem Subgroup.relindex_eq_zero_of_le_right :
    ∀ {G : Type u_1} [inst : Group G] {H K L : Subgroup G},
      K ≤ L → Subgroup.relindex H K = 0 → Subgroup.relindex H L = 0 :=
  by sorry

This theorem states that for any type `G` that forms a group, and for any three subgroups `H`, `K`, and `L` of `G`, if `K` is a subset of `L` and the relative index of `H` and `K` is zero, then the relative index of `H` and `L` is also zero. The relative index of two subgroups `H` and `K` is defined as the index of the subgroup formed by `H` and `K`, and is zero if this index is infinite.

For any groups `G`, `H`, `K`, and `L` where `K` is a subset of `L` and the index of `H` in `K` is finite and equal to 1, the index of `H` in `L` is also equal to 1. (Or, if the index is infinite, then it is zero.)


theorem Mathlib.MeasureTheory.Constructions.BorelSpace.Basic._auxLemma.2 :
    ∀ {α : Type u} {ι : Sort v} {x : α} {s : ι → Set α}, (x ∈ ⋃ i, s i) = ∃ i, x ∈ s i := by sorry

This theorem states that for any type `α`, any `ι` indexed collection of sets `s` of type `α`, and any element `x` of type `α`, the proposition that `x` belongs to the union over `ι` of the sets `s` is equivalent to the existence of an index `i` in `ι` such that `x` belongs to the set `s i`. In other words, an element is in the union of a collection of sets if and only if it is in at least one of the sets in the collection.

For any type `α`, any `ι`-indexed collection `s` of sets of type `α`, and any `x : α`, `x ∈ ⋃i, s i` if and only if there exists `i : ι`, such that `x ∈ s i`.


theorem AkraBazziRecurrence.GrowsPolynomially.rpow :
    ∀ {f : ℝ → ℝ} (p : ℝ),
      AkraBazziRecurrence.GrowsPolynomially f →
        (∀ᶠ (x : ℝ) in Filter.atTop, 0 ≤ f x) → AkraBazziRecurrence.GrowsPolynomially fun x => f x ^ p :=
  by sorry

The theorem `AkraBazziRecurrence.GrowsPolynomially.rpow` states that for any real-valued function `f` and any real number `p`, if `f` satisfies the growth condition required by the Akra-Bazzi theorem (i.e., there exists constants `c₁` and `c₂` such that `c₁ f(n) ≤ f(u) ≤ c₂ f(n)` for any `u` in the range from `b*n` to `n`, where `b` is any constant in the open interval from 0 to 1), and if `f(x)` is nonnegative for sufficiently large `x`, then the function `g` defined by `g(x) = f(x) ^ p` also satisfies the Akra-Bazzi growth condition. This theorem allows us to apply the Akra-Bazzi method not only to `f` itself but also to any positive real power of `f`.

If `f` is a real-valued function satisfying the Akra-Bazzi growth condition and is nonnegative for large `x`, then `g(x) = f(x) ^ p` also satisfies the Akra-Bazzi growth condition for any real number `p`.


theorem HasDerivAt.const_add :
    ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {F : Type v} [inst_1 : NormedAddCommGroup F]
      [inst_2 : NormedSpace 𝕜 F] {f : 𝕜 → F} {f' : F} {x : 𝕜} (c : F),
      HasDerivAt f f' x → HasDerivAt (fun x => c + f x) f' x :=
  by sorry

The theorem `HasDerivAt.const_add` asserts that if a function `f` has a derivative `f'` at a point `x` in a nontrivial normed field `𝕜` with values in a normed add commutative group `F`, then the function defined by adding a constant `c` to `f` at each point also has the same derivative `f'` at the point `x`. In other words, the derivative of a function remains unchanged even if a constant is added to the function. This is a formalization of the mathematical principle that the derivative of a constant added to a function is just the derivative of the function itself.

If `f` is differentiable at `x` in a normed field `𝕜` with values in a normed additive commutative group `F`, then the function `g(x) = f(x) + c` is also differentiable at `x` with derivative `f'(x)`, where `c` is a constant.


theorem Mathlib.Data.ENNReal.Inv._auxLemma.1 : ∀ {r : NNReal}, r ≠ 0 → (↑r)⁻¹ = ↑r⁻¹ := by sorry

This theorem states that for any nonnegative real number `r` (denoted as `NNReal` in Lean 4), if `r` is not equal to 0, then the inverse of the coerced `r` (i.e., interpreting `r` as a real number) is equal to the coercion of the inverse of `r`. In mathematical terms, if we denote the operation of coercion as ↑, this theorem can be written as: for all `r` in nonnegative real numbers, if `r` is not equal to 0, then (↑r)⁻¹ = ↑(r⁻¹).

For any non-zero non-negative real number `r`, the coerced inverse of `r` equals the inverse of the coerced `r`. In Lean notation: `(NNReal.coerce r).inv = NNReal.coerce (0 < r → r⁻¹)` where `⁻¹` denotes the inverse operation on real numbers.


theorem MeasurableSpace.DynkinSystem.has_iUnion :
    ∀ {α : Type u_1} (d : MeasurableSpace.DynkinSystem α) {β : Type u_2} [inst : Countable β] {f : β → Set α},
      Pairwise (Disjoint on f) → (∀ (i : β), d.Has (f i)) → d.Has (⋃ i, f i) :=
  by sorry

This theorem states that for any type `α` with a measurable space's dynkin system `d`, and any countable type `β`, if we have a function `f` from `β` to sets of `α` such that the sets `f i` are pairwise disjoint, and each set `f i` is in the dynkin system `d`, then the union of all sets `f i` (over all `i` in `β`) is also in the dynkin system `d`. This essentially says that a dynkin system is closed under countable disjoint unions, provided that each set in the union is also in the dynkin system.

If `d` is a measurable space's dynkin system, and `f : β → α` is a function with pairwise disjoint, `d`-measurable sets `fi`, then `⋃i ∈ β fi` is also `d`-measurable.


theorem Finsupp.sum_mapDomain_index :
    ∀ {α : Type u_1} {β : Type u_2} {M : Type u_5} {N : Type u_7} [inst : AddCommMonoid M] [inst_1 : AddCommMonoid N]
      {f : α → β} {s : α →₀ M} {h : β → M → N},
      (∀ (b : β), h b 0 = 0) →
        (∀ (b : β) (m₁ m₂ : M), h b (m₁ + m₂) = h b m₁ + h b m₂) →
          Finsupp.sum (Finsupp.mapDomain f s) h = Finsupp.sum s fun a m => h (f a) m :=
  by sorry

The theorem `Finsupp.sum_mapDomain_index` states that for any types `α`, `β`, `M`, and `N`, and given an addition-commutative monoid structure on `M` and `N`, a function `f` from `α` to `β`, a finitely supported function `s` from `α` to `M`, and a function `h` from `β` and `M` to `N` satisfying two properties - `h` of `b` and `0` equals `0` for all `b` in `β`, and `h` of `b` and the sum of `m₁` and `m₂` equals the sum of `h` of `b` and `m₁`, and `h` of `b` and `m₂`, for any `b` in `β` and `m₁`, `m₂` in `M`, then the sum of `h` over the map domain of `f` and `s` is equal to the sum of the function taking `a` and `m` to `h` of `f` of `a` and `m`, over the support of `s`.

In simpler terms, this theorem relates the summation of a function `h` over the elements of a finitely supported function `s`, transformed by `f`, to the direct summation of a function over the elements of `s`. The properties of `h` ensure that it interacts well with the addition in `M` and `N`, making the equality hold.

For any addition-commutative monoids M and N, function f : α → β, finitely supported function s : α → M, and function h : β × M → N satisfying h(b, 0) = 0 and h(b, m₁ + m₂) = h(b, m₁) + h(b, m₂) for all b and m₁, m₂ in M, the sum of h over the image of s under f equals the sum of the function taking (a, m) to h(f a, m) over the support of s.


theorem Complex.arg_of_re_neg_of_im_neg :
    ∀ {x : ℂ}, x.re < 0 → x.im < 0 → Complex.arg x = Real.arcsin ((-x).im / Complex.abs x) - Real.pi := by sorry

This theorem states that for any complex number `x`, if both the real part (`x.re`) and the imaginary part (`x.im`) of `x` are less than zero, then the argument of `x` (the angle in polar coordinates) is equal to the arcsine of the negative of the imaginary part of `x` divided by the absolute value of `x`, minus pi (`π`). This essentially gives a rule for determining the angle of a complex number in the lower-left quadrant of the complex plane (where both real and imaginary parts are negative).

For complex numbers `x` with negative real and imaginary parts, the argument is given by `Arg(x) = Arcsin(neg (x.im) / abs x) - π`.


theorem Mathlib.AlgebraicGeometry.EllipticCurve.Affine._auxLemma.1 :
    ∀ {R : Type u} [inst : Semiring R], 0 = Polynomial.C 0 := by sorry

The theorem `Mathlib.AlgebraicGeometry.EllipticCurve.Affine._auxLemma.1` states that for any type `R` that is a semiring, the constant polynomial with value `0` (denoted as `Polynomial.C 0`) is equal to `0`. In mathematical terms, it expresses that the constant polynomial mapping that assigns to every `0` in `R` the zero polynomial, is equivalent to the zero element in the ring of polynomials over `R`.

For any semiring `R`, the constant polynomial `Polynomial.C 0` equals the zero element in the ring of polynomials over `R`.


theorem Nat.mul_self_lt_mul_self : ∀ {m n : ℕ}, m < n → m * m < n * n := by sorry

This theorem states that for any two natural numbers 'm' and 'n', if 'm' is less than 'n', then the square of 'm' is also less than the square of 'n'. Specifically, the theorem is applicable to all pairs of natural numbers where the first is strictly less than the second.

For all natural numbers m and n, if m < n then m^2 < n^2.


StructureGroupoid.compatible

/-- Reformulate in the `StructureGroupoid` namespace the compatibility condition of charts in a
charted space admitting a structure groupoid, to make it more easily accessible with dot
notation.  -/
theorem StructureGroupoid.compatible :
    ∀ {H : Type u_5} [inst : TopologicalSpace H] (G : StructureGroupoid H) {M : Type u_6} [inst_1 : TopologicalSpace M]
      [inst_2 : ChartedSpace H M] [inst_3 : HasGroupoid M G] {e e' : PartialHomeomorph M H},
      e ∈ atlas H M → e' ∈ atlas H M → PartialHomeomorph.trans (PartialHomeomorph.symm e) e' ∈ G :=
  by sorry

The theorem `StructureGroupoid.compatible` states that for any topological space `H` and `M`, where `M` is a charted space modeled on `H` with a structure groupoid `G`, and for any two partial homeomorphisms `e` and `e'` from the atlas of `M` to `H`, the transformation from `e'` to the inverse of `e` belongs to the groupoid `G`. This is essentially a compatibility condition of charts in a charted space admitting a structure groupoid, reformulated within the `StructureGroupoid` namespace.

Given a charted space `M` modeled on a topological space `H` with a structure groupoid `G`, any two compatible partial homeomorphisms `e` and `e'` from `M` to `H` have inverses related by an element in `G`.


theorem Int.natAbs_sq : ∀ (x : ℤ), ↑(Int.natAbs x) ^ 2 = x ^ 2 := by sorry

The theorem `Int.natAbs_sq` states that for every integer `x`, the square of the absolute value of `x` (expressed as a natural number) is equal to the square of `x` itself. In other words, squaring the absolute value of an integer gives the same result as squaring the integer itself. This is a formalization of the mathematical fact that squaring a negative number yields the same result as squaring its positive counterpart, as squaring involves multiplication of the number by itself, rendering the sign irrelevant.


theorem List.zipWith_map_left :
    ∀ {α : Type u_1} {β : Type u_2} {α' : Type u_3} {γ : Type u_4} (l₁ : List α) (l₂ : List β) (f : α → α')
      (g : α' → β → γ), List.zipWith g (List.map f l₁) l₂ = List.zipWith (fun a b => g (f a) b) l₁ l₂ :=
  by sorry

The theorem `List.zipWith_map_left` states that for any two lists `l₁` of type `α` and `l₂` of type `β`, a function `f` that maps from `α` to `α'`, and a function `g` that maps from `α'` and `β` to `γ`, applying `List.zipWith` to the result of mapping `f` over `l₁` and `l₂` using `g` is the same as applying `List.zipWith` to `l₁` and `l₂` where the function applied for each pair is `g` composed with `f` on the element from `l₁`. In other words, it states the property that mapping a function over the first list before zipping is equivalent to zipping with the function composed with the mapping function.

For lists `l₁` of type `α` and `l₂` of type `β`, functions `f : α → α'` and `g : α' × β → γ`, `List.zipWith (g ∘ (f × id)) (f <$> l₁) l₂` is equivalent to `List.zipWith g l₁ l₂`.


theorem Set.Icc_bot_top : ∀ {α : Type u_1} [inst : PartialOrder α] [inst_1 : BoundedOrder α], Set.Icc ⊥ ⊤ = Set.univ :=
  by sorry

This theorem states that for any type `α` equipped with a partial order and a bounded order, the closed interval from the bottom element `⊥` to the top element `⊥` is equal to the universal set. In other words, every element of the type `α` lies in the interval `[⊥, ⊤]`, where `⊥` and `⊤` are the least and greatest elements of `α`, respectively. This makes sense as the bounded order guarantees the existence of such least and greatest elements, and the closed interval `[⊥, ⊤]` includes all the elements between and including `⊥` and `⊤`, which covers the entire set.

For any type `α` equipped with a bounded order, every element lies in the closed interval `[⊥, ⊤]` where `⊥` and `⊤` are the least and greatest elements of `α`.


theorem CategoryTheory.ShortComplex.Exact.lift_f :
    ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_3, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
      {S : CategoryTheory.ShortComplex C} [inst_2 : CategoryTheory.Balanced C]
      (hS : CategoryTheory.ShortComplex.Exact S) {A : C} (k : A ⟶ S.X₂)
      (hk : CategoryTheory.CategoryStruct.comp k S.g = 0) [inst_3 : CategoryTheory.Mono S.f],
      CategoryTheory.CategoryStruct.comp (CategoryTheory.ShortComplex.Exact.lift hS k hk) S.f = k :=
  by sorry

This theorem, `CategoryTheory.ShortComplex.Exact.lift_f`, states that for any Category `C` (which is preadditive and balanced), given a Short Complex `S` that is exact, and a morphism `k` from an object `A` to `S.X₂` such that the composition of `k` with `S.g` is zero, if morphism `S.f` is monic (or injective), then the composition of `CategoryTheory.ShortComplex.Exact.lift` applied to `hS`, `k`, and `hk` with `S.f` is equal to `k`. In simpler terms, this theorem establishes a property of lifting morphisms in the context of exact sequences in category theory, specifically within short complexes.

Given a preadditive and balanced category `C`, an exact short complex `S` in `C`, and a morphism `k` from an object to `S.X₂` with `S.g * k = 0` and monic `S.f`, the morphism `CategoryTheory.ShortComplex.Exact.lift(hS, k, hk) * S.f = k` holds.


theorem Set.ssubset_iff_of_subset : ∀ {α : Type u} {s t : Set α}, s ⊆ t → (s ⊂ t ↔ ∃ x ∈ t, x ∉ s) := by sorry

This theorem states that for any two sets `s` and `t` of some type `α`, if `s` is a subset of `t` (expressed as `s ⊆ t`), then the condition for `s` to be a proper subset of `t` (expressed as `s ⊂ t`) is equivalent to the existence of an element `x` that belongs to `t` but does not belong to `s` (expressed as `∃ x ∈ t, x ∉ s`). In other words, a set `s` is a proper subset of another set `t`, given that `s` is already a subset of `t`, if and only if there is at least one element in `t` that is not included in `s`.

A set is a proper subset of another set if and only if it is a subset and there exists an element in the larger set not in the smaller set.


theorem antitone_iff_forall_lt :
    ∀ {α : Type u} {β : Type v} [inst : PartialOrder α] [inst_1 : Preorder β] {f : α → β},
      Antitone f ↔ ∀ ⦃a b : α⦄, a < b → f b ≤ f a :=
  by sorry

The theorem `antitone_iff_forall_lt` establishes an equivalence between two properties of a function `f` that maps elements from an ordered type `α` to another ordered type `β`. The first property is `Antitone`, which means that `f` is an antitone function (i.e., for all `a` and `b` in `α` where `a ≤ b`, `f b ≤ f a`). The second property is that for every pair of distinct elements `a` and `b` in `α` where `a` is strictly less than `b`, the image of `b` under `f` is less than or equal to the image of `a`. In other words, this theorem states that a function is antitone if and only if its value decreases or stays the same whenever its argument increases strictly.

A function between ordered types is antitone if and only if for all distinct elements `a` and `b` with `a < b`, we have `f(b) ≤ f(a)`.


theorem Mathlib.Data.List.Chain._auxLemma.3 : ∀ (p : Prop), (p ∧ True) = p := by sorry

This theorem, `Mathlib.Data.List.Chain._auxLemma.3`, states that for any proposition `p`, the logical conjunction of `p` and the boolean `True` is equivalent to `p` itself. Symbolically, this is expressed as `p ∧ True = p`. This is a basic property of logical conjunction with the `True` statement in propositional logic.

The theorem `Mathlib.Data.List.Chain._auxLemma.3` in Lean 4 states that `p ∧ True = p` for any proposition `p`. In other words, the conjunction of a proposition with `True` is logically equivalent to the proposition itself.


theorem Mathlib.Data.List.Chain._auxLemma.2 : ∀ {α : Type u_1} {R : α → α → Prop} {a : α}, List.Chain R a [] = True :=
  by sorry

This theorem states that for any type `α`, any binary relation `R` on `α`, and any element `a` of type `α`, the property of `a` being related by `R` to every element in an empty list (denoted by `List.Chain R a []`) is always true. Essentially, it's saying that an empty list trivially satisfies the chaining condition with respect to any element and relation.

For any type `α` and binary relation `R` on `α`, the element `a` of type `α` is related by `R` to every element in the empty list `[]`. That is, `R a []` holds.


theorem Mathlib.Data.List.Chain._auxLemma.1 :
    ∀ {α : Type u_1} {R : α → α → Prop} {a b : α} {l : List α}, List.Chain R a (b :: l) = (R a b ∧ List.Chain R b l) :=
  by sorry

This theorem states that, for any type `α` and a relation `R` on `α`, and for any elements `a` and `b` of type `α` and list `l` of type `α`, the property that `a` is related to every element of the list `b :: l` (i.e., `b` followed by `l`) by the relation `R` (expressed as `List.Chain R a (b :: l)`) is equivalent to the conjunction of the following two conditions: `a` is related to `b` by `R` and `b` is related to every element of `l` by `R` (expressed as `R a b` and `List.Chain R b l`).

For any type `α` and relation `R` on `α`, the element `a` is related to every element of the list `b :: l` by `R` if and only if `a` is related to `b` by `R` and `b` is related to every element of `l` by `R`. In other words, `List.Chain R a (b :: l)` is equivalent to `R a b ∧ List.Chain R b l`.


theorem sSup_insert : ∀ {α : Type u_1} [inst : CompleteLattice α] {a : α} {s : Set α}, sSup (insert a s) = a ⊔ sSup s :=
  by sorry

The theorem `sSup_insert` states that for any type `α` which forms a complete lattice, and any element `a` of `α` and any set `s` of elements of `α`, the supremum of the set obtained by inserting `a` into `s` is equal to the supremum of `a` and the supremum of `s`. In other words, considering the set with an additional element, its least upper bound is the same as the least upper bound of the original set and the new element.

For any complete lattice `α`, the supremum of an element `a` in `α` and a set `s` of elements from `α` is equal to the supremum of `a` and the supremum of `s`.


theorem nhds_basis_abs_sub_lt :
    ∀ {α : Type u} [inst : TopologicalSpace α] [inst_1 : LinearOrderedAddCommGroup α] [inst_2 : OrderTopology α]
      [inst_3 : NoMaxOrder α] (a : α), Filter.HasBasis (nhds a) (fun ε => 0 < ε) fun ε => {b | |b - a| < ε} :=
  by sorry

This theorem, named `nhds_basis_abs_sub_lt`, states that for any type `α` that is a topological space, a linear ordered additive commutative group, an order topology, and has no maximum order, and for any element `a` of type `α`, the neighborhood filter of `a` (`nhds a`) has a basis consisting of sets `{b | |b - a| < ε}` where `ε` is a positive real number. In simpler terms, every neighborhood of `a` contains an open set of points `b` whose absolute difference from `a` is less than some positive number `ε`.

For any topological space `α` that is a linear ordered additive commutative group without a maximum order, the neighborhood filter of any element `a` in `α` has a basis consisting of open sets `{b : α | |b - a| < ε}` for some positive real number `ε`.


/-- The range of a surjective monoid hom is the whole of the codomain.  -/
theorem MonoidHom.mrange_top_of_surjective :
    ∀ {M : Type u_1} {N : Type u_2} [inst : MulOneClass M] [inst_1 : MulOneClass N] {F : Type u_5}
      [inst_2 : FunLike F M N] [mc : MonoidHomClass F M N] (f : F), Function.Surjective ⇑f → MonoidHom.mrange f = ⊤ :=
  by sorry

The theorem `MonoidHom.mrange_top_of_surjective` states that for any two types `M` and `N` with `MulOneClass` instances (i.e., they have multiplicative identity and multiplication defined), and for any type `F` which has a `FunLike` instance from `M` to `N`, and `MonoidHomClass` instance, if `f` is a function from `F`, and the function is surjective (meaning that for every element of `N` there's an element of `M` such that `f` of that element equals the given element), then the range of the monoid homomorphism `f` is the entire codomain `N`. In other words, `f` maps `M` onto `N` under the monoid operation.

If `M` and `N` are types with multiplicative identities and `F:` `M` → `N` is a surjective monoid homomorphism, then the range of `F` is the entire codomain `N` under the monoid operation.


theorem Multiset.eq_zero_of_subset_zero : ∀ {α : Type u_1} {s : Multiset α}, s ⊆ 0 → s = 0 := by sorry

This theorem states that for any type `α` and any multiset `s` of type `α`, if `s` is a subset of the empty multiset (denoted by `0`), then `s` must be equal to the empty multiset. In other words, the only subset of the empty multiset is the empty multiset itself.

A multiset `s` of type `α` is equal to the empty multiset `0` if and only if `s` is a subset of `0`.


theorem TopologicalSpace.Opens.map_obj :
    ∀ {X Y : TopCat} (f : X ⟶ Y) (U : Set ↑Y) (p : IsOpen U),
      (TopologicalSpace.Opens.map f).obj { carrier := U, is_open' := p } = { carrier := ⇑f ⁻¹' U, is_open' := ⋯ } :=
  by sorry

The theorem `TopologicalSpace.Opens.map_obj` states that for any topological spaces `X` and `Y`, and for any continuous map `f` from `X` to `Y`, if `U` is an open set in `Y`, then the object of the functor `Opens.map f` applied to `U` is the set of preimages of `U` under `f` which is an open set in `X`. This essentially indicates that the preimage of an open set under a continuous map is also open, reflecting one of the key properties of continuous functions in topology.

For any continuous function $f$ between topological spaces $X$ and $Y$, and any open set $U$ in $Y$, the preimage $f^{-1}(U)$ is an open set in $X$.


theorem Complex.le_def : ∀ {z w : ℂ}, z ≤ w ↔ z.re ≤ w.re ∧ z.im = w.im := by sorry

This theorem states that for any two complex numbers `z` and `w`, `z` is less than or equal to `w` if and only if the real part of `z` is less than or equal to the real part of `w` and the imaginary part of `z` is equal to the imaginary part of `w`. In other words, in the context of complex numbers, the inequality `z ≤ w` is defined by comparing their real parts and checking for equality of their imaginary parts.

For complex numbers z and w, z <= w if and only if Re(z) <= Re(w) and Im(z) = Im(w).


theorem IsPrimitiveRoot.zpowers_eq :
    ∀ {R : Type u_4} [inst : CommRing R] [inst_1 : IsDomain R] {k : ℕ+} {ζ : Rˣ},
      IsPrimitiveRoot ζ ↑k → Subgroup.zpowers ζ = rootsOfUnity k R :=
  by sorry

This theorem states that for any commutative ring `R` that is also an integral domain, and for any positive natural number `k` and unit `ζ` of `R`, if `ζ` is a primitive root of `k` (i.e., `ζ` to the power of `k` equals `1` and `ζ` is not a root of any smaller natural number), then the subgroup generated by the powers of `ζ` is equal to the subgroup of `R`'s units that are roots of unity of order `k` (i.e., elements `m` of the multiplicative group `Mˣ` such that `m` to the power `k` equals `1`).

For any commutative ring R that is an integral domain, if positive natural number k has a primitive root ζ in R, then the subgroup of R generated by {ζ^n | n ∈ ℕ} equals the subgroup of R's units that are roots of unity of order k.


theorem CliffordAlgebra.reverse.map_mul :
    ∀ {R : Type u_1} [inst : CommRing R] {M : Type u_2} [inst_1 : AddCommGroup M] [inst_2 : Module R M]
      {Q : QuadraticForm R M} (a b : CliffordAlgebra Q),
      CliffordAlgebra.reverse (a * b) = CliffordAlgebra.reverse b * CliffordAlgebra.reverse a :=
  by sorry

The theorem `CliffordAlgebra.reverse.map_mul` states that for any commutative ring `R`, any additive commutative group `M` which is also a module over `R`, and any quadratic form `Q` on `M`, the operation of grade reversion (or reversing the multiplication order of basis vectors) in the Clifford algebra of `M` under `Q` over `R` has the property that the grade reversion of the product of two elements `a` and `b` in this Clifford algebra is equal to the product of the grade reversions of `b` and `a`, in that order. In other words, the grade reversion operation reverses the order of multiplication in the Clifford algebra.

In the Clifford algebra of a commutative ring `R` over an additive commutative group `M` with quadratic form `Q`, the grade reversal of the product of two elements is equal to the product of their grade reversals in reverse order.


theorem AlgHom.comp_id :
    ∀ {R : Type u} {A : Type v} {B : Type w} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Semiring B]
      [inst_3 : Algebra R A] [inst_4 : Algebra R B] (φ : A →ₐ[R] B), AlgHom.comp φ (AlgHom.id R A) = φ :=
  by sorry

The theorem `AlgHom.comp_id` states that for any commutative semiring `R`, any semirings `A` and `B`, and any algebra structure over `A` and `B` with respect to `R`, if we have an algebra homomorphism `φ` from `A` to `B`, then the composition of `φ` with the identity map on `A` (using the function `AlgHom.comp`) is equal to `φ` itself. In other words, this expresses the mathematical idea that composing any map with the identity map leaves the map unchanged, in the context of algebra homomorphisms.

For any commutative semiring `R`, any algebra homomorphisms `φ: A → B` over `R` from semirings `A` and `B`, `AlgHom.comp φ id_A = φ`.


theorem bernoulli'_one : bernoulli' 1 = 1 / 2 := by sorry

The theorem `bernoulli'_one` states that the first Bernoulli number, denoted by `bernoulli' 1`, is equal to one-half. In other words, when we calculate the Bernoulli number for the case where `n` is `1` using the defined recursive function, the result is `1/2`.


theorem Submodule.map_comap_eq :
    ∀ {R : Type u_1} {R₂ : Type u_3} {M : Type u_9} {M₂ : Type u_12} [inst : Semiring R] [inst_1 : Semiring R₂]
      [inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid M₂] [inst_4 : Module R M] [inst_5 : Module R₂ M₂]
      {τ₁₂ : R →+* R₂} {F : Type u_20} [inst_6 : FunLike F M M₂] [inst_7 : SemilinearMapClass F τ₁₂ M M₂]
      [inst_8 : RingHomSurjective τ₁₂] (f : F) (q : Submodule R₂ M₂),
      Submodule.map f (Submodule.comap f q) = LinearMap.range f ⊓ q :=
  by sorry

This theorem, `Submodule.map_comap_eq`, states that for any semiring `R` and `R₂`, any additive commutative monoid `M` and `M₂`, any module `M` over `R`, any module `M₂` over `R₂`, a ring homomorphism `τ₁₂` from `R` to `R₂`, a function `F` that is `FunLike` from `M` to `M₂`, a semilinear map from `M` to `M₂` that preserves the action of `τ₁₂`, a ring homomorphism `τ₁₂`, a module homomorphism `f` from `M` to `M₂`, and a submodule `q` of `M₂`, the image under `f` of the preimage of `q` under `f` equals the intersection of the range of `f` and `q`.

In simpler terms, if you take a submodule `q` of `M₂`, map it back to `M` using `f`, and then map it forward to `M₂` using the same `f`, you end up precisely with the intersection of the original submodule `q` and the range of `f`.

For any ring homomorphism τ₁₂ from semiring R to R₂, module M over R, module M₂ over R₂, FunLike function F from M to M₂, semilinear map g from M to M₂ preserving the action of τ₁₂, module homomorphism f from M to M₂, and submodule q of M₂, the image under f of the preimage of q under f equals the intersection of the range of f and q.


theorem CircleDeg1Lift.map_map_zero_le : ∀ (f g : CircleDeg1Lift), f (g 0) ≤ f 0 + ↑⌈g 0⌉ := by sorry

This theorem states that for any two Circle Degree 1 Lift functions `f` and `g`, the value of function `f` at the point `g 0` is less than or equal to the sum of the value of function `f` at 0 and the ceiling of the value of `g` at 0. In mathematical terms, for all `f` and `g`, we have `f(g(0)) ≤ f(0) + ⌈g(0)⌉`. The Circle Degree 1 Lift is a mathematical concept often used in complex analysis and dynamical systems.

For any Circle Degree 1 Lift functions f and g, the value of f at g(0) is less than or equal to the sum of f(0) and the ceiling of g(0).


theorem ModelWithCorners.map_nhds_eq :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {H : Type u_3} [inst_3 : TopologicalSpace H] (I : ModelWithCorners 𝕜 E H) (x : H),
      Filter.map (↑I) (nhds x) = nhdsWithin (↑I x) (Set.range ↑I) :=
  by sorry

This theorem, `ModelWithCorners.map_nhds_eq`, states that for any non-trivially normed field `𝕜`, a normed add commutative group `E` that is also a normed space over `𝕜`, a topological space `H` and a model `I` with corners relating the field `𝕜`, the group `E` and the space `H`, the filter generated by mapping the model `I` to the neighborhood filter of any point `x` in `H` is equal to the "neighborhood within" filter at the point `I x` in the range of the model `I`. In other words, it asserts a relationship between the forward map of a filter and the neighborhood filter within a set, in the context of a mathematical model with corners.

For any non-trivially normed field `𝕜`, normed add commutative group `E` over `𝕜`, topological space `H`, and model `I` with corners relating `𝕜`, `E`, and `H`, the filter generated by mapping `I` to the neighborhood filter of any point `x` in `H` equals the "neighborhood within" filter at `I x` in the range of `I`.


theorem MvPolynomial.comap_comp_apply :
    ∀ {σ : Type u_1} {τ : Type u_2} {υ : Type u_3} {R : Type u_4} [inst : CommSemiring R]
      (f : MvPolynomial σ R →ₐ[R] MvPolynomial τ R) (g : MvPolynomial τ R →ₐ[R] MvPolynomial υ R) (x : υ → R),
      MvPolynomial.comap (AlgHom.comp g f) x = MvPolynomial.comap f (MvPolynomial.comap g x) :=
  by sorry

The theorem `MvPolynomial.comap_comp_apply` states that for any three types `σ`, `τ`, and `υ`, and for any type `R` equipped with a commutative semiring structure, given two algebra homomorphisms `f` from multivariate polynomials over `σ` and `R` to multivariate polynomials over `τ` and `R`, and `g` from multivariate polynomials over `τ` and `R` to multivariate polynomials over `υ` and `R`, and a variable evaluation `x : υ → R`, then the comap of the composition of `g` and `f`, evaluated at `x`, is equal to the comap of `f` evaluated at the comap of `g` evaluated at `x`. In other words, the operation of taking the comap (preimage under a function) of a composition of two functions is the same as composing the comaps of the two functions, an instance of the principle that "the preimage of a composition is the composition of the preimages".

For any commutative semirings R, and multivariate polynomial homomorphisms f : R[σ] -> R[τ] and g : R[τ] -> R[υ], the composition of their comaps (preimages under the functions) evaluated at an evaluation map x : υ -> R is equal to the comap of their composition evaluated at x.


Substring.ValidFor.str

theorem Substring.ValidFor.str :
    ∀ {l m r : List Char} {s : Substring}, Substring.ValidFor l m r s → s.str = { data := l ++ m ++ r } := by sorry

This theorem states that for any lists of characters `l`, `m`, and `r`, and any substring `s`, if `s` is a valid substring for `l`, `m`, and `r`, then the string value of `s` is equal to the list formed by concatenating `l`, `m`, and `r` in that order. Essentially, it asserts that a valid substring represents the concatenation of its list parameters.

For any lists of characters `l`, `m`, and `r`, and substring `s` that is a valid substring of the concatenation of `l`, `m`, and `r`, the string value of `s` equals the concatenation of `l`, `m`, and `r`.


theorem Real.inv_one_add_tan_sq : ∀ {x : ℝ}, Real.cos x ≠ 0 → (1 + Real.tan x ^ 2)⁻¹ = Real.cos x ^ 2 := by sorry

This theorem states that for any real number `x`, as long as the cosine of `x` is not zero, the reciprocal of the quantity `(1 + tangent of x squared)` is equal to the square of the cosine of `x`. In mathematical terms, it asserts that for any $x \in \mathbb{R}$ with $\cos(x) \neq 0$, we have $(1 + \tan^2(x))^{-1} = \cos^2(x)$.

For any real number $x$ with non-zero cosine, the reciprocal of $(1 + \tan^2(x))$ equals the square of the cosine: $(1 + \tan^2(x))^{-1} = \cos^2(x)$.


theorem Module.preReflection_apply :
    ∀ {R : Type u_1} {M : Type u_2} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] (x : M)
      (f : Module.Dual R M) (y : M), (Module.preReflection x f) y = y - f y • x :=
  by sorry

This theorem states that for any commutative ring `R`, any additive commutative group `M`, and any `R`-module structure on `M`, and for any element `x` in `M`, any linear map `f` from `M` to `R`, and any element `y` in `M`, the application of the pre-reflection endomorphism (defined by `x` and `f`) to `y` results in `y - f y • x`. In other words, if we imagine executing the pre-reflection transformation on `y`, it would shift `y` by a scalar multiple of `x`, where the scalar is given by the linear map `f` applied to `y`.

For any commutative ring `R`, additive commutative group `M`, and `R`-module structure on `M`, and for any `x` in `M`, linear map `f` from `M` to `R`, and element `y` in `M`, the pre-reflection endomorphism of `y` by `x` and `f` equals `y - f(y) * x`.


theorem Int.dvd_sub : ∀ {a b c : ℤ}, a ∣ b → a ∣ c → a ∣ b - c := by sorry

This theorem states that for any three integers `a`, `b`, and `c`, if `a` divides `b` and `a` also divides `c`, then `a` divides the difference `b - c`. This is a property of divisibility in the set of integers. In mathematical notation, this would be written as: if $a|b$ and $a|c$, then $a|(b-c)$.

If `a` divides `b` and `c`, then `a` divides the difference `b - c` (in the set of integers). Alternatively, mathematically: if $a|b$ and $a|c$, then $a|(b-c)$.


theorem ProbabilityTheory.kernel.iIndepFun.indepFun_finset_prod_of_not_mem :
    ∀ {α : Type u_1} {Ω : Type u_2} {ι : Type u_3} {_mα : MeasurableSpace α} {_mΩ : MeasurableSpace Ω}
      {κ : ↥(ProbabilityTheory.kernel α Ω)} {μ : MeasureTheory.Measure α} {β : Type u_8} {m : MeasurableSpace β}
      [inst : CommMonoid β] [inst_1 : MeasurableMul₂ β] {f : ι → Ω → β} [inst_2 : ProbabilityTheory.IsMarkovKernel κ],
      ProbabilityTheory.kernel.iIndepFun (fun x => m) f κ μ →
        (∀ (i : ι), Measurable (f i)) →
          ∀ {s : Finset ι} {i : ι}, i ∉ s → ProbabilityTheory.kernel.IndepFun (Finset.prod s fun j => f j) (f i) κ μ :=
  by sorry

The theorem `ProbabilityTheory.kernel.iIndepFun.indepFun_finset_prod_of_not_mem` states that, given a probability kernel `κ` on measurable spaces `α` and `Ω`, a measure `μ` on `α`, a measurable space `β` with a commutative monoid structure and a measurable multiplication, a function `f` from `ι` to `Ω` to `β`, and a finset `s` of `ι`, if `κ` is a Markov kernel, `f` is measurable for every `ι`, and `f` is independent for every `x` in the measure space, then for every `i` in `ι` not in `s`, the function `f` at `i` is independent from the product of `f` at elements of `s`. This implies that the process defined by `f` has independent increments.

If `κ` is a Markov kernel on measurable spaces `α` and `Ω`, `μ` is a measure on `α`, `β` is a commutative monoid with measurable multiplication, `f` is a measurable function from `ι` to `Ω` to `β`, `s` is a finset of `ι` such that `f(i)` is independent of the product of `f(j)` for all `j` in `s` and `i` not in `s`, then `f(i)` is independent of the product of `f(j)` for all `i` not in `s` and every choice of `j` in `s`.


/-- The following statements are equivalent:

0. `s` is a neighborhood of `a` within `[a, +∞)`;
1. `s` is a neighborhood of `a` within `[a, b]`;
2. `s` is a neighborhood of `a` within `[a, b)`;
3. `s` includes `[a, u)` for some `u ∈ (a, b]`;
4. `s` includes `[a, u)` for some `u > a`.
 -/
theorem TFAE_mem_nhdsWithin_Ici :
    ∀ {α : Type u} [inst : TopologicalSpace α] [inst_1 : LinearOrder α] [inst_2 : OrderTopology α] {a b : α},
      a < b →
        ∀ (s : Set α),
          List.TFAE
            [s ∈ nhdsWithin a (Set.Ici a), s ∈ nhdsWithin a (Set.Icc a b), s ∈ nhdsWithin a (Set.Ico a b),
              ∃ u ∈ Set.Ioc a b, Set.Ico a u ⊆ s, ∃ u ∈ Set.Ioi a, Set.Ico a u ⊆ s] :=
  by sorry

This theorem states that for any topological space with a linear order and order topology, and given two elements 'a' and 'b' of this space with 'a' less than 'b', the following statements are equivalent for any set 's':

0. 's' is a neighborhood of 'a' within the interval from 'a' to positive infinity.
1. 's' is a neighborhood of 'a' within the closed interval from 'a' to 'b'.
2. 's' is a neighborhood of 'a' within the half-open interval from 'a' to 'b'.
3. 's' includes the half-open interval from 'a' to some 'u' in the open-closed interval from 'a' to 'b'.
4. 's' includes the half-open interval from 'a' to some 'u' greater than 'a'.

A neighborhood of 'a' within a set is a set containing the intersection of a neighborhood of 'a' and the set. In this context, intervals are sets of elements depending on the relation between the element and the endpoints 'a' and 'b'.

In a topological space with a linear order and order topology, for any element 'a' less than 'b', the sets that are neighborhoods of 'a' within the interval from 'a' to positive infinity, the closed interval from 'a' to 'b', the half-open interval from 'a' to 'b', and the half-open interval from 'a' to some 'u' in the open-closed interval from 'a' to 'b' are equivalent.


theorem PartialEquiv.IsImage.symm_iff :
    ∀ {α : Type u_1} {β : Type u_2} {e : PartialEquiv α β} {s : Set α} {t : Set β},
      PartialEquiv.IsImage (PartialEquiv.symm e) t s ↔ PartialEquiv.IsImage e s t :=
  by sorry

This is a theorem about the notion of an image in the context of a partial equivalence between two sets. It states that for any types `α` and `β`, any partial equivalence `e` between `α` and `β`, and any sets `s` of `α` and `t` of `β`, the set `t` is an image of `s` under the inverse of `e` if and only if `s` is an image of `t` under `e`. This means that the concept of an image is preserved under the inversion of a partial equivalence.

For any partial equivalences $e$ between types $\alpha$ and $\beta$, and sets $s \subseteq \alpha$ and $t \subseteq \beta$, $t$ is the image of $s$ under the inverse of $e$ if and only if $s$ is the image of $t$ under $e$.


theorem AlgebraicGeometry.RingedSpace.basicOpen_le :
    ∀ (X : AlgebraicGeometry.RingedSpace) {U : TopologicalSpace.Opens ↑↑X.toPresheafedSpace}
      (f : ↑(X.presheaf.obj (Opposite.op U))), AlgebraicGeometry.RingedSpace.basicOpen X f ≤ U :=
  by sorry

This theorem states that for any Ringed Space `X` and any open subset `U` of the underlying topological space of `X`, given a section `f` in the presheaf of `X` over `U`, the basic open set generated by `f` is a subset of `U`. In other words, the basic open set is the set of all points where the germ of `f` (i.e., its localization at a point) is a unit in the ring of all germs, and this set of points is guaranteed to be contained within `U`.

Given a Ringed Space `X`, an open subset `U` of its underlying topological space, and a section `f` in the presheaf of `X` over `U`, the basic open set of `f` is contained in `U`.


theorem Doset.mem_doset :
    ∀ {α : Type u_2} [inst : Mul α] {s t : Set α} {a b : α}, b ∈ Doset.doset a s t ↔ ∃ x ∈ s, ∃ y ∈ t, b = x * a * y :=
  by sorry

This theorem, `Doset.mem_doset`, states that for any given type `α` that supports multiplication, sets `s` and `t` of type `α`, and elements `a` and `b` of type `α`, `b` is an element of the double coset `Doset.doset a s t` if and only if there exist elements `x` in set `s` and `y` in set `t` such that `b` is equal to the product of `x`, `a`, and `y` (denoted as `b = x * a * y`). In essence, the theorem formalizes the condition for an element to belong to a double coset in terms of the element being a specific product of elements from the original sets and a fixed element.

A element b belongs to the double coset Doset.doset a s t if and only if there exist x in s and y in t such that b = x * a * y.


/-- **Bézout's lemma**  -/
theorem Int.gcd_eq_gcd_ab : ∀ (x y : ℤ), ↑(Int.gcd x y) = x * Int.gcdA x y + y * Int.gcdB x y := by sorry

This is a statement of **Bézout's lemma** for integers. The theorem states that for any two integers `x` and `y`, the greatest common divisor of `x` and `y`, when converted to an integer (as indicated by `↑`), is equivalent to `x` multiplied by the "a" value in the extended GCD computation (as computed by `Int.gcdA`) plus `y` multiplied by the "b" value in the extended GCD computation (as computed by `Int.gcdB`). In mathematical terms, for any integers `x` and `y`, `gcd(x, y) = x * a + y * b`, where `a` and `b` are the coefficients returned by the extended GCD algorithm.

The greatest common divisor of integers `x` and `y` is equal to `x * Int.gcdA x y + y * Int.gcdB x y`.


theorem Int.sub_left_lt_of_lt_add : ∀ {a b c : ℤ}, a < b + c → a - b < c := by sorry

This theorem states that for any three integers `a`, `b`, and `c`, if `a` is less than the sum of `b` and `c` (`a < b + c`), then `a` minus `b` is less than `c` (`a - b < c`). This theorem can be used to move terms around inequalities involving integer addition and subtraction.

If `a` is less than the sum of `b` and `c` (`a < b + c`), then `a - b` is less than `c` (`a - b < c`).


theorem CategoryTheory.Bicategory.inv_hom_whiskerRight :
    ∀ {B : Type u} [inst : CategoryTheory.Bicategory B] {a b c : B} {f g : a ⟶ b} (η : f ≅ g) (h : b ⟶ c),
      CategoryTheory.CategoryStruct.comp (CategoryTheory.Bicategory.whiskerRight η.inv h)
          (CategoryTheory.Bicategory.whiskerRight η.hom h) =
        CategoryTheory.CategoryStruct.id (CategoryTheory.CategoryStruct.comp g h) :=
  by sorry

This theorem is in the field of category theory and it expresses a property of bicategories. Specifically, it states that for any bicategory `B` and any three objects `a`, `b`, and `c` in `B`, and any two morphisms `f` and `g` from `a` to `b` that are inverses of each other (denoted `η : f ≅ g`), and any morphism `h` from `b` to `c`, the composition of "whiskering" `η.inv` and `η.hom` on the right with `h` (i.e., `CategoryTheory.Bicategory.whiskerRight η.inv h` and `CategoryTheory.Bicategory.whiskerRight η.hom h`) is the identity on the composition of `g` and `h` (i.e., `CategoryTheory.CategoryStruct.id (CategoryTheory.CategoryStruct.comp g h)`).

"Whiskering" in this context is a specific type of operation in category theory that involves the composition of morphisms. And the identity on a composition signifies that the composition operation doesn't change the involved morphisms. Therefore, this theorem essentially says that in a bicategory, if you whisker the inverse of a morphism and the morphism itself on the right with another morphism, you get back the original pair of morphisms.

For any bicategory `B`, given objects `a`, `b`, `c`, morphisms `f : a -> b`, `g : a -> b` with `f ≅ g`, and morphism `h : b -> c`, we have `CategoryTheory.CategoryStruct.id (CategoryTheory.Bicategory.whiskerRight η.inv h) * CategoryTheory.Bicategory.whiskerRight η.hom h = (g * h)`.


theorem Set.iUnion_mono' :
    ∀ {α : Type u_1} {ι : Sort u_4} {ι₂ : Sort u_6} {s : ι → Set α} {t : ι₂ → Set α},
      (∀ (i : ι), ∃ j, s i ⊆ t j) → ⋃ i, s i ⊆ ⋃ i, t i :=
  by sorry

The theorem `Set.iUnion_mono'` states that for all types `α`, `ι`, and `ι₂`, and given two functions `s` and `t` that map from `ι` and `ι₂` to a set of `α` respectively, if for every element `i` of type `ι`, there exists an element `j` such that the set `s i` is a subset of the set `t j`, then the union over all `i` of the sets `s i` is a subset of the union over all `i` of the sets `t i`. In mathematical terms, this theorem asserts that if every set in a collection `{s_i}` is contained in some set in another collection `{t_j}`, then the union of the collection `{s_i}` is contained in the union of the collection `{t_j}`.

If for each element `i` in `ι`, there exists `j` in `ι₂` such that `s i ⊆ t j`, then `⋃i.s i ⊆ ⋃j.t j`.


theorem mem_upperBounds_image2_of_mem_upperBounds_of_mem_upperBounds :
    ∀ {α : Type u} {β : Type v} {γ : Type w} [inst : Preorder α] [inst_1 : Preorder β] [inst_2 : Preorder γ]
      {f : α → β → γ} {s : Set α} {t : Set β} {a : α} {b : β},
      (∀ (b : β), Antitone (Function.swap f b)) →
        (∀ (a : α), Monotone (f a)) → a ∈ lowerBounds s → b ∈ upperBounds t → f a b ∈ upperBounds (Set.image2 f s t) :=
  by sorry

This theorem states that for all types `α`, `β`, and `γ` that have a `Preorder` relation, and for any function `f` from `α` and `β` to `γ`, given a set `s` of type `α` and a set `t` of type `β`, if the function `f` is antitone with respect to `b` when its arguments are swapped, and is monotone with respect to `a`, and if `a` is a lower bound of set `s` and `b` is an upper bound of set `t`, then the value `f a b` is an upper bound of the image of function `f` over the Cartesian product of sets `s` and `t`. In other words, `f a b` is greater than or equal to all elements in the image of `f` over all pairs `(x, y)` where `x` is from set `s` and `y` is from set `t`.

For any antitone and monotone function `f` between two preordered sets `α × β` with `α`'s lowest element `a` as a lower bound of set `s` and `β`'s upper bound `b` as an upper bound of set `t`, `f a b` is an upper bound of `f(s × t)`.


theorem IsLocalization.mk'_surjective :
    ∀ {R : Type u_1} [inst : CommSemiring R] (M : Submonoid R) {S : Type u_2} [inst_1 : CommSemiring S]
      [inst_2 : Algebra R S] [inst_3 : IsLocalization M S] (z : S), ∃ x y, IsLocalization.mk' S x y = z :=
  by sorry

The theorem `IsLocalization.mk'_surjective` states that for any commutative semiring `R`, any submonoid `M` of `R`, and any commutative semiring `S` that is a localization of `R` at `M`, and for any element `z` of `S`, there exist an element `x` in `R` and an element `y` in `M` such that the image of `(x, y)` under the surjection `IsLocalization.mk'` is `z`. In other words, every element of `S` can be written as "a (image of `x` under the canonical map) times the inverse of (an image of `y` under the canonical map)", where `x` comes from `R` and `y` comes from `M`.

For any commutative semirings R, any submonoid M of R, and any localization S of R at M, every element z in S can be written as x/y for some x in R and y in M, where the division is performed in S using the canonical maps.


theorem Multiset.sum_zero : ∀ {α : Type u_2} [inst : AddCommMonoid α], Multiset.sum 0 = 0 := by sorry

The theorem `Multiset.sum_zero` states that for any type `α` that has an additive commutative monoid structure, the sum of an empty multiset in `α` is the identity element of the addition operation in the monoid, which is zero. In other words, when we sum up all elements in an empty multiset, the result is always zero, no matter what the type `α` is, as long as it is an additive commutative monoid.

For any additive commutative monoid type `α`, the sum of an empty multiset in `α` equals its additive identity (zero).


theorem Nat.le_of_ble_eq_true : ∀ {n m : ℕ}, Nat.ble n m = true → n ≤ m := by sorry

This theorem states that for all natural numbers `n` and `m`, if the function `Nat.ble n m` returns `true`, then `n` is less than or equal to `m`. The function `Nat.ble` checks if `n` is less than or equal to `m` using Boolean logic, returning a Boolean value. Therefore, this theorem connects the Boolean logic of `Nat.ble` with the mathematical property of less than or equal to (`≤`).

For all natural numbers n and m, if Nat.ble n m holds, then n ≤ m.


theorem SimpleGraph.Walk.transfer.proof_4 :
    ∀ {V : Type u_1} {G : SimpleGraph V} (H : SimpleGraph V) (u w v : V) (h : G.Adj u v) (p : SimpleGraph.Walk G v w),
      (∀ e ∈ SimpleGraph.Walk.edges (SimpleGraph.Walk.cons' u v w h p), e ∈ SimpleGraph.edgeSet H) →
        ∀ e ∈ SimpleGraph.Walk.edges p, e ∈ SimpleGraph.edgeSet H :=
  by sorry

The theorem `SimpleGraph.Walk.transfer.proof_4` states that for any type `V` and any simple graphs `G` and `H` with vertices `u`, `w`, and `v`, if `u` is adjacent to `v` in `G` and there is a walk `p` from `v` to `w` in `G`, then if all edges in the walk from `u` to `w` (which is made by concatenating the edge from `u` to `v` and the walk `p`) are in the edge set of `H`, then all edges in the walk `p` must also be in the edge set of `H`. In other words, if every edge in the extended walk is in `H`, then every edge in the original walk is also in `H`.

If a simple graph `H` contains every edge in the path connecting vertices `u` and `w` in a simple graph `G`, then every edge in the path between `u` and `w` in `G` is also in `H`.


theorem Submodule.map_mul :
    ∀ {R : Type u} [inst : CommSemiring R] {A : Type v} [inst_1 : Semiring A] [inst_2 : Algebra R A]
      (M N : Submodule R A) {A' : Type u_1} [inst_3 : Semiring A'] [inst_4 : Algebra R A'] (f : A →ₐ[R] A'),
      Submodule.map (AlgHom.toLinearMap f) (M * N) =
        Submodule.map (AlgHom.toLinearMap f) M * Submodule.map (AlgHom.toLinearMap f) N :=
  by sorry

The theorem `Submodule.map_mul` states that for any commutative semiring `R`, semirings `A` and `A'`, algebraic structures over `R` on `A` and `A'`, two submodules `M` and `N` of `A`, and an algebra homomorphism `f` from `A` to `A'`, the image under `f` of the product of `M` and `N` (i.e., `Submodule.map (AlgHom.toLinearMap f) (M * N)`) is equal to the product of the image under `f` of `M` and `N` (i.e., `Submodule.map (AlgHom.toLinearMap f) M * Submodule.map (AlgHom.toLinearMap f) N`). This is analogous to the property of a homomorphism in algebra that the image of a product is the product of the images.

The theorem asserts that for any commutative semiring `R`, algebraic structures `A` and `A'`, submodules `M` and `N` of `A`, and an algebra homomorphism `f` from `A` to `A'`, we have `Submodule.map (AlgHom.toLinearMap f) (M * N) = Submodule.map (AlgHom.toLinearMap f) M * Submodule.map (AlgHom.toLinearMap f) N`.


theorem fderivWithin_add_const :
    ∀ {𝕜 : 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 → F}
      {x : E} {s : Set E},
      UniqueDiffWithinAt 𝕜 s x → ∀ (c : F), fderivWithin 𝕜 (fun y => f y + c) s x = fderivWithin 𝕜 f s x :=
  by sorry

The theorem `fderivWithin_add_const` states that for a nontrivially normed field `𝕜`, a function `f` mapping from a normed additive commutative group `E` to another normed additive commutative group `F` (both `E` and `F` being normed spaces over `𝕜`), a set `s` of elements of type `E`, and an element `x` of type `E`, if `x` is uniquely differentiable within `s`, then the derivative within `s` at `x` of the function `f` added to a constant `c` is the same as the derivative within `s` at `x` of the function `f` itself. This essentially means that adding a constant to a function does not affect its derivative within a set at a point, if the point is uniquely differentiable within the set.

If `f : E → F` is a function between normed additive commutative groups over a nontrivially normed field, `x ∈ E` is uniquely differentiable within a set `s ∈ E`, then `(DF at x : E → F) (x + c) = DF at x` for all `c ∈ 𝕜`.


theorem CategoryTheory.ShortComplex.leftHomologyMap_id :
    ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
      (S : CategoryTheory.ShortComplex C) [inst_2 : CategoryTheory.ShortComplex.HasLeftHomology S],
      CategoryTheory.ShortComplex.leftHomologyMap (CategoryTheory.CategoryStruct.id S) =
        CategoryTheory.CategoryStruct.id (CategoryTheory.ShortComplex.leftHomology S) :=
  by sorry

The theorem `CategoryTheory.ShortComplex.leftHomologyMap_id` states that for any category `C` with zero morphisms and any short complex `S` in `C` that has a left homology, the left homology map of the identity morphism on `S` is equal to the identity morphism on the left homology of `S`. In other words, this theorem is asserting that the left homology map respects the identity morphism, a fundamental property expected from maps in category theory.

For any short complex S in a category C with zero morphisms, the left homology map of the identity morphism on S equals the identity morphism on the left homology of S.


theorem Nat.le_antisymm_iff : ∀ {a b : ℕ}, a = b ↔ a ≤ b ∧ b ≤ a := by sorry

This theorem states that for any two natural numbers `a` and `b`, `a` is equal to `b` if and only if `a` is less than or equal to `b` and `b` is less than or equal to `a`. In other words, if `a` is not greater than `b` and `b` is not greater than `a`, then they must be the same number. This is a formalization of the antisymmetry property of the less than or equal to relation on natural numbers.

For all natural numbers `a` and `b`, `a = b` if and only if `a <= b` and `b <= a`.


theorem IsSeqCompact.subseq_of_frequently_in :
    ∀ {X : Type u_1} [inst : TopologicalSpace X] {s : Set X},
      IsSeqCompact s →
        ∀ {x : ℕ → X},
          (∃ᶠ (n : ℕ) in Filter.atTop, x n ∈ s) →
            ∃ a ∈ s, ∃ φ, StrictMono φ ∧ Filter.Tendsto (x ∘ φ) Filter.atTop (nhds a) :=
  by sorry

This theorem states that for any given topological space `X` and any set `s` in `X`, if `s` is sequentially compact, then for any sequence `x` of elements in `X` where every element `x(n)` for `n` in natural numbers is frequently in `s` (meaning the set of `n` for which `x(n)` is in `s` is dense in the natural numbers), there exists an element `a` in `s` and a strictly monotone sequence `φ` of natural numbers such that the subsequence of `x` defined by `φ` converges to `a`. In other words, if `s` is sequentially compact and a sequence `x` is frequently in `s`, then `x` has a subsequence which converges to some point in `s`.

If a sequentially compact subset `s` of a topological space `X` and a sequence `x` in `X` have density one in `s`, then `x` has a convergent subsequence with limit in `s`.


theorem isClosed_of_mem_irreducibleComponents :
    ∀ {X : Type u_1} [inst : TopologicalSpace X], ∀ s ∈ irreducibleComponents X, IsClosed s := by sorry

This theorem states that for any given type `X` that has a topology associated with it (denoted by `[inst : TopologicalSpace X]`), all elements `s` in the set of irreducible components of `X` (`irreducibleComponents X`) are closed sets. In other words, if a subset `s` of a topological space `X` is an irreducible component of `X`, then `s` is a closed set in that topology.

For any topological space `X` and each of its irreducible components `s`, `s` is a closed subset of `X`.


theorem SzemerediRegularity.a_add_one_le_four_pow_parts_card :
    ∀ {α : Type u_1} [inst : DecidableEq α] [inst_1 : Fintype α] {P : Finpartition Finset.univ},
      Fintype.card α / P.parts.card - Fintype.card α / SzemerediRegularity.stepBound P.parts.card * 4 ^ P.parts.card +
          1 ≤
        4 ^ P.parts.card :=
  by sorry

The theorem `SzemerediRegularity.a_add_one_le_four_pow_parts_card` states that for any type `α` with decidable equality and finite number of elements, and for any given finite partition `P` of the universal set of `α`, the integer division of the card of `α` by the card of `P.parts` minus the quantity of the product of the integer division of the card of `α` by the `stepBound` of P.parts.card and 4 to the power of card of P.parts, increased by 1, is less than or equal to 4 to the power of the card of P.parts. This theorem is an auxiliary result used in the context of Szemeredi's Regularity Lemma.

For any finite type `α` with decidable equality and given finite partition `P` of `α`, the quotient of `α`'s cardinality by the number of parts in `P` minus the product of their cardinalities raised to the power of 4 and divided by the step bound of `P.parts.card`, plus one, is bounded by 4 raised to the power of the number of parts in `P`.


theorem Irrational.of_int_add : ∀ {x : ℝ} (m : ℤ), Irrational (↑m + x) → Irrational x := by sorry

The theorem `Irrational.of_int_add` states that for all real numbers `x` and integers `m`, if the sum of `m` and `x` (where `m` is cast to a real number) is irrational, then `x` is also irrational. In other words, adding an integer to an irrational number results in another irrational number.

If the sum of an irrational real number and an integer is irrational, then the original irrational number is also irrational.


/-- The following statements are equivalent:

0. `s` is a neighborhood of `a` within `(a, +∞)`;
1. `s` is a neighborhood of `a` within `(a, b]`;
2. `s` is a neighborhood of `a` within `(a, b)`;
3. `s` includes `(a, u)` for some `u ∈ (a, b]`;
4. `s` includes `(a, u)` for some `u > a`.
 -/
theorem TFAE_mem_nhdsWithin_Ioi :
    ∀ {α : Type u} [inst : TopologicalSpace α] [inst_1 : LinearOrder α] [inst_2 : OrderTopology α] {a b : α},
      a < b →
        ∀ (s : Set α),
          List.TFAE
            [s ∈ nhdsWithin a (Set.Ioi a), s ∈ nhdsWithin a (Set.Ioc a b), s ∈ nhdsWithin a (Set.Ioo a b),
              ∃ u ∈ Set.Ioc a b, Set.Ioo a u ⊆ s, ∃ u ∈ Set.Ioi a, Set.Ioo a u ⊆ s] :=
  by sorry

This theorem states that for a given set `s` and two elements `a` and `b` such that `a < b` in a topological space `α` that also has a linear order and an order topology, the following statements are equivalent:

0. `s` is a neighborhood of `a` within the interval `(a, +∞)`.
1. `s` is a neighborhood of `a` within the closed interval `(a, b]`.
2. `s` is a neighborhood of `a` within the open interval `(a, b)`.
3. `s` includes the open interval `(a, u)` for some `u` in the interval `(a, b]`.
4. `s` includes the open interval `(a, u)` for some `u` that is greater than `a`.

In other words, these conditions can be used interchangeably in theorems involving neighborhoods within intervals.

In a topological space with a linear order and an order topology, the neighborhoods of an element `a` with strict inequality to another element `b` are equivalent: `(a < b) => { (a is a neighborhood of a in (a, +∞)), (a is a neighborhood of a in (a, b]), (a is a neighborhood of a in (a, b) and s includes some open interval (a, u) for some `u` in (a, b]) } => (a is a neighborhood of a in (a, b) and s includes some open interval (a, u) for some `u` > a)`.


theorem mul_mul_invOf_self_cancel' : ∀ {α : Type u} [inst : Monoid α] (a b : α) {x : Invertible b}, a * b * ⅟b = a := by
  sorry

This theorem, `mul_mul_invOf_self_cancel'`, states that for any type `α` that is a monoid (a set with an associative binary operation that has an identity element), and any two elements `a` and `b` of that monoid where `b` is invertible, the product of `a`, `b`, and the inverse of `b` (denoted `⅟b`) is equal to `a`. Essentially, it indicates that multiplying by an element and its inverse cancels out, leaving the other factor unchanged.

For all monoids types `α` and invertible elements `a` and `b` in `α`, `a * b * ⅟b = a`.


theorem Cardinal.add_lt_aleph0 :
    ∀ {a b : Cardinal.{u_1}}, a < Cardinal.aleph0 → b < Cardinal.aleph0 → a + b < Cardinal.aleph0 := by sorry

The theorem `Cardinal.add_lt_aleph0` states that for any two cardinal numbers `a` and `b` belonging to `Type u_1`, if both `a` and `b` are less than the smallest infinite cardinal (`ℵ₀`), then the sum of `a` and `b` is also less than `ℵ₀`. In other words, the sum of two cardinal numbers that are less than infinity (in this case represented by `ℵ₀`) remains less than infinity.

For any cardinal numbers `a` and `b`, if `a < ℵ₀` and `b < ℵ₀`, then `a + b < ℵ₀`.


theorem Fin.rev_succ : ∀ {n : ℕ} (k : Fin n), Fin.rev (Fin.succ k) = Fin.castSucc (Fin.rev k) := by sorry

The theorem `Fin.rev_succ` states that for all natural numbers `n` and for any `k` of type `Fin n` (which is a finite ordered list of length `n`), the reverse of the successively next element of `k` is equivalent to the casting of the reverse of `k` into a list of one longer length. In other words, first incrementing `k` and then reversing equals to first reversing `k` and then casting it into a list of length `n+1`.

For any finite list `k` of length `n` in `Fin`, the reversed successor of `k` is equivalent to appending `0` to the reversed list of length `n+1` obtained from `k`.


theorem Ordinal.enumOrd_surjective :
    ∀ {S : Set Ordinal.{u}}, Set.Unbounded (fun x x_1 => x < x_1) S → ∀ s ∈ S, ∃ a, Ordinal.enumOrd S a = s := by sorry

The theorem `Ordinal.enumOrd_surjective` states that for any unbounded set `S` of ordinals, where 'unbounded' is defined in terms of the strict less than relation (`<`), for every ordinal `s` in `S`, there exists an ordinal `a` such that when we apply the enumerator function `Ordinal.enumOrd` to the set `S` and ordinal `a`, we obtain the ordinal `s`. In other words, every ordinal in the unbounded set `S` is within the range of the enumerator function `Ordinal.enumOrd`.

For any unbounded set `S` of ordinals, the enumerator function `Ordinal.enumOrd` is surjective over `S`.


theorem Multiset.toFinset_sum_count_nsmul_eq :
    ∀ {α : Type u_3} [inst : DecidableEq α] (s : Multiset α),
      (Finset.sum (Multiset.toFinset s) fun a => Multiset.count a s • {a}) = s :=
  by sorry

This theorem states that for any multiset `s` of a type `α` that has decidable equality, the sum over the finset obtained from `s` through the function `Multiset.toFinset`, of the product of the count of each element `a` in `s` and the singleton set containing `a` (`Multiset.count a s • {a}`), is equal to the original multiset `s`.

In other words, if we convert a multiset to a finset, which removes any duplicate elements, and then for each element in the finset, we multiply the count of that element in the original multiset by a singleton set containing that element, and sum all these results, we get back the original multiset.

For any decidably equal multiset `s` of type `α`, the sum over its corresponding finset of the count of each element multiplied by the singleton set is equal to the multiset itself: `∑ x ∈ Multiset.toFinset s, Multiset.count x s • {x} = s`.


theorem isEmpty_sum : ∀ {α : Type u_4} {β : Type u_5}, IsEmpty (α ⊕ β) ↔ IsEmpty α ∧ IsEmpty β := by sorry

This theorem, `isEmpty_sum`, states that for any two types `α` and `β`, the type `α ⊕ β` (which denotes the sum type, or the disjoint union of `α` and `β`) is empty if and only if both `α` and `β` are empty. Here, `IsEmpty` is a predicate that checks whether a type has no values.

The sum type `α ⊕ β` is empty if and only if types `α` and `β` are both empty.


theorem DirichletCharacter.level_one :
    ∀ {R : Type u_1} [inst : CommMonoidWithZero R] (χ : DirichletCharacter R 1), χ = 1 := by sorry

This theorem states that for any type `R` that has an instance of the `CommMonoidWithZero` structure, any Dirichlet character of level `1` over `R` is actually equivalent to `1`. In other words, if you have a Dirichlet character defined over a commutative monoid with zero, and the level of this character is `1`, then this character is essentially the constant function that always returns `1`.

For any commutative monoid with zero `R`, every Dirichlet character of level 1 over `R` is the trivial character, i.e., maps all elements to 1.


theorem Basis.orientation.proof_2 :
    ∀ {R : Type u_1} [inst : StrictOrderedCommRing R] {M : Type u_2} [inst_1 : AddCommGroup M] [inst_2 : Module R M]
      {ι : Type u_3} [inst_3 : Fintype ι] [inst_4 : DecidableEq ι] (e : Basis ι R M), Basis.det e ≠ 0 :=
  by sorry

The theorem `Basis.orientation.proof_2` asserts that for a given basis `e` of a module `M` over a strictly ordered commutative ring `R` with a finite type `ι`, the determinant of the basis `e` is never zero. This theorem holds regardless of the decidable equality of the elements in the type `ι`. Essentially, this theorem is stating that the determinant of a basis in a module over a strictly ordered commutative ring is always non-zero.

For every finite type ι and a strictly ordered commutative ring R with a basis e of a module M over R, the determinant of e is non-zero.


theorem EReal.coe_mul_bot_of_pos : ∀ {x : ℝ}, 0 < x → ↑x * ⊥ = ⊥ := by sorry

The theorem `EReal.coe_mul_bot_of_pos` states that for all real numbers `x`, if `x` is greater than 0, then the product of the extended real number representation of `x` and negative infinity (`⊥`) is negative infinity (`⊥`).

For all real numbers `x` with `x > 0`, the product of `x` and negative infinity is negative infinity. (In mathematical notation: `(x : ℝ). 0 < x → x * ⊥ = ⊥`)


theorem Int.fract_zero : ∀ {α : Type u_2} [inst : LinearOrderedRing α] [inst_1 : FloorRing α], Int.fract 0 = 0 := by
  sorry

The theorem `Int.fract_zero` states that for any type `α` that is a linearly ordered ring and has a floor ring structure, the fractional part of the number 0 is 0. In other words, when you subtract the floor (or greatest integer less than or equal to a given number) of 0 from 0, you obtain 0.

For any linearly ordered ring with a floor ring structure, the fractional part of 0 is 0.


theorem Rat.cast_mk' :
    ∀ {K : Type u_3} [inst : DivisionRing K] (a : ℤ) (b : ℕ) (h1 : b ≠ 0) (h2 : Nat.Coprime (Int.natAbs a) b),
      ↑{ num := a, den := b, den_nz := h1, reduced := h2 } = ↑a * (↑b)⁻¹ :=
  by sorry

The theorem `Rat.cast_mk'` states that for any division ring `K`, given an integer `a`, a natural number `b` which is not zero, and assuming that the absolute value of `a` and `b` are coprime (i.e., their greatest common divisor is 1), then the rational number created with `a` as the numerator and `b` as the denominator, when cast as a member of `K`, is equivalent to `a` cast as a member of `K` multiplied by the inverse of `b` cast as a member of `K`. This theorem essentially describes a property of constructing and casting rational numbers in a division ring.

Given a division ring K, an integer a, a non-zero natural number b with gcd(a, b) = 1, the casting of the rational number (a / b) to K is equivalent to casting a to K multiplied by the multiplicative inverse of b in K.


theorem PrimeMultiset.prod_add :
    ∀ (u v : PrimeMultiset), PrimeMultiset.prod (u + v) = PrimeMultiset.prod u * PrimeMultiset.prod v := by sorry

The theorem `PrimeMultiset.prod_add` states that for any two prime multisets `u` and `v`, the product of the multiset obtained by adding `u` and `v` is equal to the product of the multiset `u` multiplied by the product of the multiset `v`. In other words, if you have two collections of prime numbers (represented as multisets), the product of all the primes in the combined collection is the same as the product of all the primes in the first collection multiplied by the product of all the primes in the second collection. This is a reflection of the fundamental property of multiplication being distributive over addition.

For any prime multisets u and v, (u ⊎ v) := {p : ℕ | p ∈ u ∨ p ∈ v} → ∏ (p : ℕ) in p = ∏ p in u * ∏ p in v, where ℕ is the set of natural numbers.