theorem sbtw_iff_btw_not_btw :
    ∀ {α : Type u_1} [inst : CircularPreorder α] {a b c : α}, sbtw a b c ↔ btw a b c ∧ ¬btw c b a := by sorry

This theorem states that for any type `α` that is equipped with a circular preorder, and for any three elements `a`, `b`, and `c` of this type, `a` is strictly between `b` and `c` if and only if `a` is between `b` and `c` and `c` is not between `b` and `a`. In other words, the condition for strict betweenness is that `a` is between `b` and `c`, but `c` can't be between `b` and `a`.

For any type `α` with a circular preorder, element `a` is strictly between `b` and `c` if and only if `a` is between `b` and `c` and there is no `d` such that `b` is between `a` and `d` and `d` is between `a` and `c`.


theorem dimH_le :
    ∀ {X : Type u_2} [inst : EMetricSpace X] [inst_1 : MeasurableSpace X] [inst_2 : BorelSpace X] {s : Set X}
      {d : ENNReal}, (∀ (d' : NNReal), ↑↑(MeasureTheory.Measure.hausdorffMeasure ↑d') s = ⊤ → ↑d' ≤ d) → dimH s ≤ d :=
  by sorry

The theorem `dimH_le` states that for any type `X` that is an eMetric space, a Measurable space, and a Borel space, and for any set `s` of type `X` and any extended nonnegative real number `d`, if for all nonnegative real numbers `d'` the Hausdorff measure of `s` with respect to `d'` is infinity implies `d'` is less than or equal to `d`, then the Hausdorff dimension of `s` is less than or equal to `d`. In other words, it sets an upper bound on the Hausdorff dimension of a set in terms of the Hausdorff measures of the set.

If a set in an eMetric, Measurable, and Borel space `X` has infinite Hausdorff measure for all `d' < d`, then its Hausdorff dimension is less than or equal to `d`.


theorem Multiset.mem_ndinter :
    ∀ {α : Type u_1} [inst : DecidableEq α] {s t : Multiset α} {a : α}, a ∈ Multiset.ndinter s t ↔ a ∈ s ∧ a ∈ t := by
  sorry

This theorem states that for any type `α` that has decidable equality, and for any multiset `s`, multiset `t`, and for an element `a` of type `α`, `a` is in the intersection of multisets `s` and `t` if and only if `a` is in `s` and `a` is in `t`. In other words, an element belongs to the intersection of two multisets if and only if it belongs to both of these multisets. The intersection here refers to the `ndinter` operation, which doesn't take into account the multiplicities of the elements.

For any type `α` with decidable equality and multisets `s` and `t` over `α`, `a` is in the intersection of `s` and `t` if and only if `a` is in both `s` and `t`.


theorem PartENat.lt_coe_iff : ∀ (x : PartENat) (n : ℕ), x < ↑n ↔ ∃ (h : x.Dom), x.get h < n := by sorry

This theorem states that for any partially defined natural number `x` and any natural number `n`, `x` is less than `n` if and only if there exists a proof `h` that `x` is defined (i.e., `x.Dom` is true) and the value of `x` obtained using this proof (i.e., `x.get h`) is less than `n`. In other words, a partially defined natural number is less than a given natural number if and only if it is defined and its value is less than that given number.

For any partially defined natural number `x` and natural number `n`, `x` is less than `n` if and only if `x` is defined and `x < n`.


theorem AddSubmonoid.closure_mul_closure :
    ∀ {R : Type u_4} [inst : NonUnitalNonAssocSemiring R] (S T : Set R),
      AddSubmonoid.closure S * AddSubmonoid.closure T = AddSubmonoid.closure (S * T) :=
  by sorry

The theorem `AddSubmonoid.closure_mul_closure` states that for any type `R` that forms a non-unital non-associative semiring, and for any two sets `S` and `T` of this type, the additive submonoid generated by the set `S` multiplied by the additive submonoid generated by the set `T` is exactly the same as the additive submonoid generated by the set obtained by multiplying `S` and `T`. Here multiplication of sets refers to the set of all products of an element from the first set and an element from the second set.

For any non-unital non-associative semiring type `R` and sets `S` and `T` of `R`, the additive submonoids generated by `S` and `T` respectively, are equal to the additive submonoid generated by their product `S ∩ T := {x * y | x ∈ S, y ∈ T}`.


Int.ModEq.refl

theorem Int.ModEq.refl : ∀ {n : ℤ} (a : ℤ), a ≡ a [ZMOD n] := by sorry

This theorem, `Int.ModEq.refl`, states that for any integer `n` and any integer `a`, `a` is congruent to itself modulo `n`. In more mathematical terms, for all integers `a` and `n`, it holds that `a` ≡ `a` (mod `n`), which means that the remainder of dividing `a` by `n` is the same as the remainder of dividing `a` by `n`. This is essentially an assertion of the reflexivity of congruence modulo `n`, a basic property in number theory.

For all integers `n` and `a`, `a` is congruent to `a` modulo `n`. (i.e., `a` ≡ `a` (mod `n`)) or equivalently, the remainder of `a` divided by `n` is equal to the remainder of `a` divided by `n` (i.e., `a % n = a % n`).


theorem Set.PairwiseDisjoint.elim_set :
    ∀ {α : Type u_1} {ι : Type u_4} {s : Set ι} {f : ι → Set α},
      Set.PairwiseDisjoint s f → ∀ {i j : ι}, i ∈ s → j ∈ s → ∀ a ∈ f i, a ∈ f j → i = j :=
  by sorry

This theorem states that if a given set `s` of elements of type `ι` is pairwise disjoint under a function `f` from `ι` to sets of type `α`, then for any two elements `i` and `j` in `s` and any element `a` that belongs to both `f(i)` and `f(j)`, it must be the case that `i` equals `j`. In other words, no two distinct elements of the set `s` map under `f` to overlapping sets of type `α`.

If `s` is a set of distinct elements from type `ι` with pairwise disjoint images under a function `f` from `ι` to sets of type `α`, then for any `i, j` in `s` and any `a` in `f(i) ∩ f(j)`, it follows that `i = j`.


theorem Fin.rev_le_rev : ∀ {n : ℕ} {i j : Fin n}, Fin.rev i ≤ Fin.rev j ↔ j ≤ i := by sorry

The theorem `Fin.rev_le_rev` states that for all natural numbers `n` and for all elements `i` and `j` of the finite ordered set of size `n`, the reverse of `i` is less than or equal to the reverse of `j` if and only if `j` is less than or equal to `i`. Here, the reverse of an element in the set is defined as `n - 1 - i` for each element `i` in the finite set.

For all natural numbers $n$ and elements $i, j$ of a finite set of size $n$, $i < j$ if and only if $(n-1)-i \leq (n-1)-j$.


UniformContinuous.neg

theorem UniformContinuous.neg :
    ∀ {α : Type u_1} {β : Type u_2} [inst : UniformSpace α] [inst_1 : AddGroup α] [inst_2 : UniformAddGroup α]
      [inst_3 : UniformSpace β] {f : β → α}, UniformContinuous f → UniformContinuous fun x => -f x :=
  by sorry

This theorem states that for any types `α` and `β`, given that `α` is a uniform space, an additive group, and a uniform additive group, and `β` is a uniform space, if a function `f` from `β` to `α` is uniformly continuous, then the function that takes `x` in `β` and maps it to the negative of `f(x)` in `α` is also uniformly continuous. In other words, the negation of a uniformly continuous function is also uniformly continuous.

If `f : β -> α` is uniformly continuous between uniform spaces `α` (a uniform space, additive group, and uniform additive group) and `β` (a uniform space), then the function `g : β -> α` defined as `g(x) := -f(x)` is also uniformly continuous.


theorem AEMeasurable.coe_nnreal_ennreal :
    ∀ {α : Type u_1} [inst : MeasurableSpace α] {f : α → NNReal} {μ : MeasureTheory.Measure α},
      AEMeasurable f μ → AEMeasurable (fun x => ↑(f x)) μ :=
  by sorry

The theorem `AEMeasurable.coe_nnreal_ennreal` states that for any type `α` with a measurable space structure, any function `f` from `α` to the nonnegative real numbers (`NNReal`), and any measure `μ` on `α`, if `f` is almost everywhere measurable with respect to `μ`, then the function obtained by applying the coercion (or embedding) from `NNReal` to the extended nonnegative real numbers (`ennreal`, represented by `↑(f x)`) is also almost everywhere measurable with respect to `μ`. In other words, measuring the function after it has been coerced doesn't lose the almost everywhere measurability property.

If `α` is a measurable space, `f : α → ℝ⁺` is almost everywhere measurable, and `μ` is a measure on `α`, then the function `x ↦ ↑(f x)` from `α` to the extended nonnegative reals (`ennreal`) is almost everywhere measurable.


theorem Function.leftInverse_of_surjective_of_rightInverse :
    ∀ {α : Sort u₁} {β : Sort u₂} {f : α → β} {g : β → α},
      Function.Surjective f → Function.RightInverse f g → Function.LeftInverse f g :=
  by sorry

This theorem states that for any two functions `f : α → β` and `g : β → α`, if `f` is surjective (that is, for every element `b` in `β` there exists an element `a` in `α` such that `f(a) = b`) and `g` is a right inverse to `f` (i.e., `f ∘ g = id`), then `g` is also a left inverse to `f` (meaning `g ∘ f = id`). In other words, if every element in the codomain is mapped from the domain by `f` and applying `f` after `g` gives you the same value, then applying `g` after `f` will also give you the original value.

If `f : α → β` is surjective and has a right inverse `g : β → α`, then `g` is a left inverse of `f`. That is, `f ∘ g = id_β` and `g ∘ f = id_α`.


theorem Prime.dvd_finset_prod_iff :
    ∀ {α : Type u_1} {M : Type u_5} [inst : CommMonoidWithZero M] {S : Finset α} {p : M},
      Prime p → ∀ (g : α → M), p ∣ Finset.prod S g ↔ ∃ a ∈ S, p ∣ g a :=
  by sorry

The theorem `Prime.dvd_finset_prod_iff` states that for any commutative monoid with zero `M` and any finite set `S` of elements from a type `α`, if `p` is a prime element of `M`, then `p` divides the product of a function `g` applied to each element of `S`, if and only if there exists an element `a` in `S` such that `p` divides `g(a)`. In other words, a prime divides the product of a set if and only if it divides at least one element in the set.

For a commutative monoid with zero M and a finite set S of elements from type α, a prime p of M divides the product of a function g applied to each element in S if and only if there exists an a in S such that p divides g(a).


theorem Num.to_nat_to_int : ∀ (n : Num), ↑↑n = ↑n := by sorry

This theorem states that for every numeral `n`, the process of first converting `n` to a natural number (`to_nat`) and then converting the result to an integer (`to_int`) is the same as directly converting `n` to an integer. In other words, the two conversions are equivalent for each numeral.

For every numeral `n`, the conversion of `n` to an integer is equivalent to first converting `n` to a natural number and then converting the result to an integer.


theorem Finset.union_val : ∀ {α : Type u_1} [inst : DecidableEq α] (s t : Finset α), (s ∪ t).val = s.val ∪ t.val := by
  sorry

The theorem `Finset.union_val` states that for any type `α` which has decidable equality, and for any two finite sets `s` and `t` of type `α`, the union of `s` and `t` (represented as `(s ∪ t).val`) is equal to the union of the values of `s` and `t` (represented as `s.val ∪ t.val`). In other words, the operation of taking the union of two finite sets in `α` corresponds exactly to the operation of taking the union of their underlying sets of values in `α`.

For any type `α` with decidable equality and finite sets `s` and `t` in `α`, `(s ∪ t).val = s.val ∪ t.val`.


theorem UniqueFactorizationMonoid.normalizedFactors_pow :
    ∀ {α : Type u_1} [inst : CancelCommMonoidWithZero α] [inst_1 : NormalizationMonoid α]
      [inst_2 : UniqueFactorizationMonoid α] {x : α} (n : ℕ),
      UniqueFactorizationMonoid.normalizedFactors (x ^ n) = n • UniqueFactorizationMonoid.normalizedFactors x :=
  by sorry

This theorem states that for any type `α` that has the structure of a cancel commutative monoid with zero, a normalization monoid, and a unique factorization monoid, and for any element `x` of type `α`, the multiset of normalized prime factors of `x` raised to the power of `n` (where `n` is a natural number) is equal to `n` times the multiset of normalized prime factors of `x`. In mathematical terms, this means that the prime factorization of `x^n` is simply the prime factorization of `x`, repeated `n` times.

For any element `x` of a type `α` with the structure of a cancel commutative monoid with zero, a normalization monoid, and a unique factorization monoid, the multiset of normalized prime factors of `x^n` is equal to the `n`-fold repetition of the multiset of normalized prime factors of `x`.


Dvd.dvd.antisymm

/-- **Alias** of `dvd_antisymm`. -/
theorem Dvd.dvd.antisymm :
    ∀ {α : Type u_1} [inst : CancelCommMonoidWithZero α] [inst_1 : Subsingleton αˣ] {a b : α}, a ∣ b → b ∣ a → a = b :=
  by sorry

This theorem, which is an alias of `dvd_antisymm`, states the principle of antisymmetry for the divisibility relation in the context of a cancellation commutative monoid with zero. In particular, for any types `α` that are cancellation commutative monoids with zero and have only one non-zero element (specified by the `Subsingleton αˣ` instance), if `a` divides `b` and `b` divides `a`, then `a` and `b` must be equal. In mathematical terms, if `a` and `b` are elements of such a type `α` and `a | b` and `b | a`, then `a = b`.

In a cancellation commutative monoid with zero and only one non-zero element, if `a` divides `b` and `b` divides `a`, then `a` equals `b`.


theorem ENNReal.toReal_smul : ∀ (r : NNReal) (s : ENNReal), (r • s).toReal = r • s.toReal := by sorry

The theorem `ENNReal.toReal_smul` states that for any nonnegative real number `r` and any extended nonnegative real number `s`, multiplying `r` and `s` in the extended nonnegative reals and then converting to a real number is the same as first converting `s` to a real number and then multiplying by `r`. In mathematical terms, this theorem states that for all `r` in the set of nonnegative real numbers and for all `s` in the extended set of nonnegative real numbers (which includes positive infinity), the real part of the product `r * s` is equal to `r` times the real part of `s`.

For all non-negative real numbers `r` and extended non-negative real numbers `s`, the real part of `r * s` equals `r` times the real part of `s`.


theorem iSup_comp_le :
    ∀ {α : Type u_1} {ι : Sort u_5} [inst : CompleteLattice α] {ι' : Sort u_9} (f : ι' → α) (g : ι → ι'),
      ⨆ x, f (g x) ≤ ⨆ y, f y :=
  by sorry

This theorem states that for any complete lattice `α` and any two functions `f: ι' → α` and `g: ι → ι'`, the supremum (least upper bound) of the composition `f(g(x))` over all `x` in `ι` is less than or equal to the supremum of `f(y)` over all `y` in `ι'`. Essentially, this means that taking the supremum over the image of `g` does not produce a greater value than taking the supremum over the entire codomain of `f`.

For any complete lattice `α` and functions `f: ι' → α` and `g: ι → ι'`, the supremum of `f(g(x))` over all `x` in `ι` is less than or equal to the supremum of `f(y)` over all `y` in `ι'`.


theorem HomologicalComplex.single_obj_X_self :
    ∀ {V : Type u} [inst : CategoryTheory.Category.{v, u} V] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms V]
      [inst_2 : CategoryTheory.Limits.HasZeroObject V] {ι : Type u_1} [inst_3 : DecidableEq ι] (c : ComplexShape ι)
      (j : ι) (A : V), ((HomologicalComplex.single V c j).obj A).X j = A :=
  by sorry

This theorem, `HomologicalComplex.single_obj_X_self`, states that for any type `V` equipped with a category structure, zero morphisms, and zero object, any type `ι` with decidable equality, a complex shape `c` of type `ι`, an element `j` of type `ι`, and an object `A` of the category `V`, the j-th object of the homological complex obtained by applying the functor `HomologicalComplex.single V c j` to `A` is equal to `A` itself. Here, `HomologicalComplex.single V c j` is a functor that constructs a homological complex with `j` as the only non-zero object.

For any category `V` with zero object and zero morphisms, type `ι` with decidable equality, complex shape `c` of type `ι`, and object `A` in `V`, the j-th object of the single-object homological complex `HomologicalComplex.single V c j A` equals `A`.


theorem Ordinal.mul_div_cancel : ∀ (a : Ordinal.{u_4}) {b : Ordinal.{u_4}}, b ≠ 0 → b * a / b = a := by sorry

The theorem `Ordinal.mul_div_cancel` states that for any ordinal 'a' and any non-zero ordinal 'b', the result of multiplying 'b' and 'a' and then dividing by 'b' is equal to 'a'. In other words, in the context of ordinal arithmetic, multiplication and division by a non-zero ordinal 'b' are inverse operations.

For any non-zero ordinal b, the multiplication and division operations are inverse on ordinals, i.e., a * b / b = a for all ordinals a.


theorem StieltjesFunction.measure_singleton :
    ∀ (f : StieltjesFunction) (a : ℝ),
      ↑↑(StieltjesFunction.measure f) {a} = ENNReal.ofReal (↑f a - Function.leftLim (↑f) a) :=
  by sorry

This theorem states that for any StieltjesFunction `f` and any real number `a`, the measure of the set containing only `a` according to the measure associated with `f` is equal to the extended non-negative real value of the difference between the value of `f` at `a` and the left limit of `f` at `a`. In other words, the Stieltjes measure of a singleton set `{a}` is the non-negative difference between the function value at a point `a` and its left limit at this point.

For any Stieltjes function `f` and real number `a`, the measure of the singleton set `{a}` according to `f` equals the non-negative difference between `f`'s value at `a` and its left limit at `a`.


theorem MeasureTheory.snorm_const :
    ∀ {α : Type u_1} {F : Type u_3} {m0 : MeasurableSpace α} {p : ENNReal} {μ : MeasureTheory.Measure α}
      [inst : NormedAddCommGroup F] (c : F),
      p ≠ 0 → μ ≠ 0 → MeasureTheory.snorm (fun x => c) p μ = ↑‖c‖₊ * ↑↑μ Set.univ ^ (1 / p.toReal) :=
  by sorry

The theorem `MeasureTheory.snorm_const` states that for any non-zero measure `μ` on a measurable space `α` and any non-zero extended nonnegative real number `p`, the `ℒp` seminorm of a constant function `c` (from `α` to a normed additive commutative group `F`) is equal to the norm of `c` multiplied by the measure of the universal set (which contains all the elements of `α`), raised to the power of `1 / p`. In mathematical terms, if `p ≠ 0` and `μ ≠ 0`, then we have `∥c∥₊ * μ(Ω)^(1/p)` where `Ω` represents the universal set.

For any non-zero measure μ on a measurable space α and non-zero extended real number p, the ℒp seminorm of a constant function c from α to a normed additive commutative group F is equal to the norm of c multiplied by the measure of the universal set Ω raised to the power of 1/p.


theorem CategoryTheory.IsPullback.of_isBilimit :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X Y : C}
      [inst_1 : CategoryTheory.Limits.HasZeroObject C] [inst_2 : CategoryTheory.Limits.HasZeroMorphisms C]
      {b : CategoryTheory.Limits.BinaryBicone X Y},
      CategoryTheory.Limits.BinaryBicone.IsBilimit b → CategoryTheory.IsPullback b.fst b.snd 0 0 :=
  by sorry

This theorem states that in a category `C` with zero object and zero morphisms, for any `BinaryBicone` `b` (consisting of two objects `X` and `Y`), if `b` is a bilimit in `C`, then the morphisms `b.fst` and `b.snd` form a pullback diagram in `C` with respect to the zero object and zero morphisms. In other words, if `b` is a bilimit, then `b.fst` and `b.snd` satisfy the universal property of the pullback, thus making them a pullback of 0 and 0.

In a category with zero object and zero morphisms, if a binary bicone is a bilimit, then its first and second projections form a pullback diagram with the zero object and morphisms.


MeasureTheory.Memℒp.neg

theorem MeasureTheory.Memℒp.neg :
    ∀ {α : Type u_1} {E : Type u_2} {m0 : MeasurableSpace α} {p : ENNReal} {μ : MeasureTheory.Measure α}
      [inst : NormedAddCommGroup E] {f : α → E}, MeasureTheory.Memℒp f p μ → MeasureTheory.Memℒp (-f) p μ :=
  by sorry

The theorem `MeasureTheory.Memℒp.neg` states that for any measurable space `α`, any type `E` that forms a normed additive commutative group, any extended nonnegative real number `p`, any measure `μ` on `α`, and any function `f` from `α` to `E`, if `f` satisfies the property `Memℒp` (i.e., `f` is almost everywhere strongly measurable and the L^p norm of `f` is finite if `p` is less than infinity or the essential supremum of `f` is finite if `p` equals infinity), then the negation of `f` (i.e., `-f`) also satisfies the property `Memℒp`. This theorem essentially asserts that the `Memℒp` property is preserved under taking negations.

If `f` is a measurable function from a measurable space to a normed additive commutative group with finite L^p norm or essential supremum, then the negation of `f` also satisfies the same property.


theorem analyticAt_id :
    ∀ (𝕜 : Type u_1) [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] (z : E), AnalyticAt 𝕜 id z :=
  by sorry

The theorem `analyticAt_id` states that for any nontrivial normed field `𝕜` and any normed add commutative group `E` that is also a normed space over `𝕜`, the identity function is analytic at any point `z` in `E`. In mathematical terms, this means the identity function has a convergent power series expansion around every point in its domain.

For any nontrivial normed field `𝕜` and normed add commutative group `E` that is also a normed space over `𝕜`, the identity function on `E` is analytic at every point in `E`.


theorem AddSemiconjBy.neg_symm_left_iff :
    ∀ {G : Type u_1} [inst : AddGroup G] {a x y : G}, AddSemiconjBy (-a) y x ↔ AddSemiconjBy a x y := by sorry

The theorem `AddSemiconjBy.neg_symm_left_iff` states that for any additively semiconjugate elements `x` and `y` in a given additive group `G` with a mediating element `a`, the negative of `a` is also the mediating element between `y` and `x`. In other words, if `a + x = y + a` then `-a + y = x - a`.

If `x` and `y` are additively semiconjugate in an additive group `G` with mediating element `a`, then `-a` is another mediating element between `y` and `x`, i.e., `y = a + x <=> x = a + y <=> a + x = y + a <=> a + y = x + a <=> -a + y = x - a <=> x - a = -a + y`.


Algebra.TensorProduct.ext

/-- A version of `TensorProduct.ext` for `AlgHom`.

Using this as the `@[ext]` lemma instead of `Algebra.TensorProduct.ext'` allows `ext` to apply
lemmas specific to `A →ₐ[S] _` and `B →ₐ[R] _`; notably this allows recursion into nested tensor
products of algebras.

See note [partially-applied ext lemmas].  -/
theorem Algebra.TensorProduct.ext :
    ∀ {R : Type uR} {S : Type uS} {A : Type uA} {B : Type uB} {C : Type uC} [inst : CommSemiring R]
      [inst_1 : Semiring A] [inst_2 : Algebra R A] [inst_3 : Semiring B] [inst_4 : Algebra R B] [inst_5 : Semiring C]
      [inst_6 : Algebra R C] [inst_7 : CommSemiring S] [inst_8 : Algebra S A] [inst_9 : Algebra R S]
      [inst_10 : Algebra S C] [inst_11 : IsScalarTower R S A] [inst_12 : IsScalarTower R S C]
      ⦃f g : TensorProduct R A B →ₐ[S] C⦄,
      AlgHom.comp f Algebra.TensorProduct.includeLeft = AlgHom.comp g Algebra.TensorProduct.includeLeft →
        AlgHom.comp (AlgHom.restrictScalars R f) Algebra.TensorProduct.includeRight =
            AlgHom.comp (AlgHom.restrictScalars R g) Algebra.TensorProduct.includeRight →
          f = g :=
  by sorry

This theorem, `Algebra.TensorProduct.ext`, states that for any two algebra homomorphisms `f` and `g` from the tensor product of two algebras `A` and `B` over a commutative semiring `R` into another algebra `C` over another commutative semiring `S`, if the composition of `f` and the inclusion of `A` into the tensor product is equal to the composition of `g` and the same inclusion, and also the composition of `f` restricted to scalars from `R` and the inclusion of `B` into the tensor product is equal to the composition of `g` restricted to scalars from `R` and the same inclusion, then `f` and `g` are equal.

In simpler words, this theorem is essentially a uniqueness condition for algebra homomorphisms between tensor products of algebras. It's particularly useful when dealing with nested tensor products, as it allows the `ext` tactic to apply specific lemmas for algebra homomorphisms.

Given commutative semirings R and S, if two algebra homomorphisms f and g from the tensor product of algebras A and B over R into algebra C over S satisfy the conditions f (a ⊗ b) = g (a ⊗ b) for all a in A and b in B, and f (r) = g (r) for all r in R, then f = g.


theorem sq_sub_sq : ∀ {R : Type u_1} [inst : CommRing R] (a b : R), a ^ 2 - b ^ 2 = (a + b) * (a - b) := by sorry

This theorem, `sq_sub_sq`, states that for any commutative ring `R` and any two elements `a` and `b` of `R`, the square of `a` minus the square of `b` equals the product of `a + b` and `a - b`. This is a generalization of the familiar algebraic identity $(a^2 - b^2) = (a + b)(a - b)$ to the context of commutative rings.

For any commutative ring R and elements a, b ∈ R, a^2 - b^2 = (a + b) * (a - b).


theorem linearIndependent_equiv' :
    ∀ {ι : Type u'} {ι' : Type u_1} {R : Type u_2} {M : Type u_4} [inst : Semiring R] [inst_1 : AddCommMonoid M]
      [inst_2 : Module R M] (e : ι ≃ ι') {f : ι' → M} {g : ι → M},
      f ∘ ⇑e = g → (LinearIndependent R g ↔ LinearIndependent R f) :=
  by sorry

The theorem `linearIndependent_equiv'` states that for any types `ι` and `ι'`, a semiring `R`, and an add commutative monoid `M` that is also an `R`-module, given a bijection `e` from `ι` to `ι'`, and any functions `f` from `ι'` to `M` and `g` from `ι` to `M`, if `f` composed with `e` equals `g`, then `g` is linearly independent over `R` if and only if `f` is linearly independent over `R`. This theorem shows that the property of linear independence is preserved under change of indices of the vector, where the change of indices is performed via the given bijection.

For any semiring R, add commutative monoid M as an R-module, bijection e between indices ι and ι', and functions f : ι' -> M and g : ι -> M with f ∘ e = g, the linear independence of f over R if and only if g is over R.


/-- Deprecated: use `DFunLike.congr_arg` instead.  -/
theorem MonoidHom.congr_arg :
    ∀ {M : Type u_4} {N : Type u_5} [inst : MulOneClass M] [inst_1 : MulOneClass N] (f : M →* N) {x y : M},
      x = y → f x = f y :=
  by sorry

This theorem, `MonoidHom.congr_arg`, states that for any two types `M` and `N`, both of which are instances of the `MulOneClass` (a class representing structures with a multiplication operation and a multiplicative identity), and a monoid homomorphism `f` from `M` to `N`, if two elements `x` and `y` of `M` are equal, then their images under `f` are also equal. Note however that this theorem is deprecated, and it's recommended to use `DFunLike.congr_arg` instead.

If `f` is a monoid homomorphism from a MulOneClass type `M` to a MulOneClass type `N`, then for all `x` and `y` in `M` with `x = y`, it follows that `f x = f y`.


theorem Mathlib.GroupTheory.MonoidLocalization._auxLemma.12 :
    ∀ {α : Type u_1} [inst : OrderedCancelCommMonoid α] {s : Submonoid α} {a₁ b₁ : α} {a₂ b₂ : ↥s},
      (Localization.mk a₁ a₂ ≤ Localization.mk b₁ b₂) = (↑b₂ * a₁ ≤ ↑a₂ * b₁) :=
  by sorry

This theorem, named `Mathlib.GroupTheory.MonoidLocalization._auxLemma.12`, expresses an important property relating to localizations of a commutative monoid. Specifically, for any ordered cancelable commutative monoid `α` and any submonoid `s` of `α`, it states that given any four elements `a₁`, `b₁` from `α` and `a₂`, `b₂` from `s`, the inequality `Localization.mk a₁ a₂ ≤ Localization.mk b₁ b₂` holds if and only if the inequality `↑b₂ * a₁ ≤ ↑a₂ * b₁` holds. Here, `Localization.mk` is a function that maps elements `x : M` and `y ∈ S` to the equivalence class `[x, y]` in the localization of `M` at `S`, and `↑x` denotes the embedding of an element `x` from the submonoid `s` into the monoid `α`.

For any ordered cancelable commutative monoid `α` and submonoid `s`, the localization `[a₁, a₂] ≤ [b₁, b₂]` in the quotient monoid of `α` at `s` if and only if `↑a₂ * a₁ ≤ ↑a₂ * b₁` in `α`.


theorem Submodule.isOrtho_comm :
    ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
      {U V : Submodule 𝕜 E}, U ⟂ V ↔ V ⟂ U :=
  by sorry

This theorem states that the orthogonality of submodules in an inner product space is commutative. In more detail, given any field `𝕜`, a normed additively commutative group `E`, and an inner product space structure over `E` with scalars from `𝕜`, for any two submodules `U` and `V` of `E`, `U` is orthogonal to `V` if and only if `V` is orthogonal to `U`. The orthogonal relationship between submodules is symmetric.

For any inner product spaces over a commutative field, the orthogonality of submodules is a symmetric relation.


theorem MeasureTheory.Measure.MutuallySingular.smul :
    ∀ {α : Type u_1} {m0 : MeasurableSpace α} {μ ν : MeasureTheory.Measure α} (r : ENNReal),
      MeasureTheory.Measure.MutuallySingular ν μ → MeasureTheory.Measure.MutuallySingular (r • ν) μ :=
  by sorry

This theorem states that for any measure space `α` with its measurable sets `m0`, any two measures `μ` and `ν`, and an extended nonnegative real number `r`, if the measures `ν` and `μ` are mutually singular, then the measures `r` times `ν` (denoted as `r • ν`) and `μ` are also mutually singular. In mathematical terms, this means that if there exists a measurable set `s` such that `ν(s) = 0` and `μ(sᶜ) = 0`, then there also exists a measurable set such that `(r • ν)(s) = 0` and `μ(sᶜ) = 0`, where `sᶜ` represents the complement of set `s`.

If measures `μ` and `ν` on measurable space `α` are mutually singular, then `r` times `ν` and `μ` are also mutually singular for any extended nonnegative real number `r`.


theorem Primrec.list_get? : ∀ {α : Type u_1} [inst : Primcodable α], Primrec₂ List.get? := by sorry

This theorem states that for all types `α` that have a `Primcodable` instance (meaning we can encode and decode values of type `α`), the binary function `List.get?` is a primitive recursive function. In simpler terms, the function `List.get?`, which takes a list and an index and returns the option of the element at that index (with `none` when the index is out of bounds), can be computed using only basic functions and recursion on nonnegative integers.

For all types `α` with a `Primcodable` instance, the function `List.get? : ∀ (l : List α) (i : ℕ), Option α` is a primitive recursive function.


theorem suffixLevenshtein.proof_2 : 0 < Nat.succ 0 := by sorry

This theorem, `suffixLevenshtein.proof_2`, states that the number 1 (represented as `Nat.succ 0`, the successor of 0) is greater than 0. This is a fundamental and self-evident concept in the natural number system, where 1 is indeed greater than 0.

The theorem `suffixLevenshtein.proof_2` asserts that `Nat.succ 0` is greater than `0` in Lean 4. In simpler terms, the statement is `1 > 0`.


Filter.Eventually.congr

theorem Filter.Eventually.congr :
    ∀ {α : Type u} {f : Filter α} {p q : α → Prop},
      (∀ᶠ (x : α) in f, p x) → (∀ᶠ (x : α) in f, p x ↔ q x) → ∀ᶠ (x : α) in f, q x :=
  by sorry

This theorem, `Filter.Eventually.congr`, states that for any type `α`, any filter `f` of `α`, and any propositions `p` and `q` that depend on `α`, if `p` holds for all elements of `f` eventually (`∀ᶠ (x : α) in f, p x`) and if it is also true that `p` eventually holds for all elements of `f` if and only if `q` does (`∀ᶠ (x : α) in f, p x ↔ q x`), then `q` also holds for all elements of `f` eventually (`∀ᶠ (x : α) in f, q x`). Basically, this theorem talks about the congruence of two propositions in the context of eventually in a filter.

If a filter `f` of type `α` satisfies `∀ᶠ (x : α) in f, p x` and `p x ↔ q x` for all `x : α`, then `∀ᶠ (x : α) in f, q x`.


theorem MeasureTheory.Measure.coe_zero : ∀ {α : Type u_1} {_m : MeasurableSpace α}, ↑↑0 = 0 := by sorry

This theorem states that for any type `α` and any measurable space `_m` over this type, the measure of the empty set (represented by `0` in Lean) is `0`. In more mathematical terms, given any measurable space, the measure of the empty set is always zero.

For any measurable space, the measure of the empty set is 0.


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

The theorem `Commute.geom_sum₂_mul` states that for any type `α` that forms a ring, given two elements `x` and `y` of this ring that commute (i.e., `x * y = y * x`), and a natural number `n`, the sum of the product of `x` raised to the `i`th power and `y` raised to the power `n - 1 - i` (where `i` ranges over natural numbers less than `n`), multiplied by the difference between `x` and `y`, is equal to `x` raised to the `n`th power minus `y` raised to the `n`th power. In mathematical notation, this is saying that:

∀ (x, y : α), (x * y = y * x) → ∀ (n : ℕ), (∑_{i=0}^{n-1} x^i * y^{n - 1 - i}) * (x - y) = x^n - y^n.

Here α is a ring, x and y are elements in α that commute, and n is a natural number.

For any commuting elements $x, y$ in a ring $\alpha$ and natural number $n$, the sum of the geometric series $\sum\_{i=0}^{n-1} x^i y^{n-1-i}$ multiplied by the difference $x-y$ equals $x^n-y^n$.


theorem Cardinal.succ_aleph0 : Order.succ Cardinal.aleph0 = Cardinal.aleph 1 := by sorry

The theorem `Cardinal.succ_aleph0` states that the successor of the smallest infinite cardinal (denoted as `ℵ₀`) is equal to the `aleph` function applied to 1. In other words, the cardinality immediately following `ℵ₀` in the sequence of infinite cardinals defined by the `aleph` function, is exactly `aleph 1`. This essentially means that `aleph 1` is the first uncountable cardinal following `ℵ₀`.

The smallest infinite cardinal `ℵ₀` has a successor equal to the first uncountable cardinal `aleph 1`.


theorem ModuleCat.epi_iff_surjective :
    ∀ {R : Type u} [inst : Ring R] {X Y : ModuleCat R} (f : X ⟶ Y), CategoryTheory.Epi f ↔ Function.Surjective ⇑f := by
  sorry

The theorem `ModuleCat.epi_iff_surjective` states that for any ring `R`, and any two modules `X` and `Y` over `R`, a morphism `f` from `X` to `Y` is an epimorphism in the category of modules over `R` if and only if the function induced by `f` is surjective. In other words, `f` is an epimorphism if and only if every element in `Y` is the image of some element in `X` under `f`.

A morphism of R-modules is an epimorphism if and only if its induced function is surjective.


theorem Set.IccExtend_of_mem :
    ∀ {α : Type u_1} {β : Type u_2} [inst : LinearOrder α] {a b : α} (h : a ≤ b) {x : α} (f : ↑(Set.Icc a b) → β)
      (hx : x ∈ Set.Icc a b), Set.IccExtend h f x = f { val := x, property := hx } :=
  by sorry

The theorem `Set.IccExtend_of_mem` states that for any types `α` and `β` where `α` has a linear order, any two values `a` and `b` from `α` with `a ≤ b`, any function `f` from the interval `[a, b]` to `β`, and any value `x` from `α` within the interval `[a, b]`, the value of the function `f` extended over all of `α` at `x` (`Set.IccExtend h f x`) is the same as the value of `f` at `x` (`f { val := x, property := hx }`). In other words, if you extend a function defined on a closed interval to all of `α`, the values on the original interval remain unchanged.

For any type with a linear order, any function defined on an interval is unchanged when extended to the entire type at points within the interval.


theorem Function.support_neg :
    ∀ {α : Type u_1} {G : Type u_10} [inst : SubtractionMonoid G] (f : α → G),
      (Function.support fun x => -f x) = Function.support f :=
  by sorry

The theorem `Function.support_neg` states that for every function `f` mapping from any type `α` to a type `G` that has a subtraction monoid structure, the support of the negated function, that is the set of points `x` in `α` where `-f(x)` is not zero, is the same as the support of the function `f` itself, i.e., the set of points `x` in `α` where `f(x)` is not zero. Essentially, this theorem indicates that negating a function does not change the set of points where the function is non-zero.

For a function `f` from type `α` to a subtraction monoid `G`, the sets of points `x` in `α` where `f(x)` and `-f(x)` are non-zero are equal.


theorem regularSpace_TFAE :
    ∀ (X : Type u) [inst : TopologicalSpace X],
      List.TFAE
        [RegularSpace X, ∀ (s : Set X), ∀ x ∉ closure s, Disjoint (nhdsSet s) (nhds x),
          ∀ (x : X) (s : Set X), Disjoint (nhdsSet s) (nhds x) ↔ x ∉ closure s,
          ∀ (x : X), ∀ s ∈ nhds x, ∃ t ∈ nhds x, IsClosed t ∧ t ⊆ s, ∀ (x : X), Filter.lift' (nhds x) closure ≤ nhds x,
          ∀ (x : X), Filter.lift' (nhds x) closure = nhds x] :=
  by sorry

This theorem states that for any type `X` and an associated topological space, the following propositions are equivalent:

1. `X` is a regular space. In topology, a regular space is a topological space that, intuitively, has enough room to distinguish points from closed sets, i.e., for any point and any closed set not containing that point, there are disjoint open sets containing the point and the closed set, respectively.

2. For any set `s` in `X` and any point `x` not in the closure of `s`, the filter of neighborhoods of `s` and the filter of neighborhoods of `x` are disjoint. The closure of a set is the smallest closed set containing the original set, and the filter of neighborhoods of a set is essentially the union of the neighborhoods of its points.

3. For any point `x` in `X` and any set `s` in `X`, the filter of neighborhoods of `s` and the filter of neighborhoods of `x` are disjoint if and only if `x` is not in the closure of `s`.

4. For any point `x` in `X` and any set `s` in the neighborhoods of `x`, there exists a closed set `t` in the neighborhoods of `x` such that `t` is a subset of `s`.

5. For any point `x` in `X`, the filter obtained by lifting the closure operation to the neighborhoods of `x` is less than or equal to the filter of neighborhoods of `x`.

6. For any point `x` in `X`, the filter obtained by lifting the closure operation to the neighborhoods of `x` is equal to the filter of neighborhoods of `x`.

These propositions are fundamental in the study of the topology of a space, and their equivalence implies that they could be used interchangeably in the topological analysis of a given space.

A topological space `X` is regular if and only if for any point `x` in `X` and any set `s` not containing `x`, the filters of neighborhoods of `s` and `x` are disjoint.


theorem CategoryTheory.Monad.ForgetCreatesLimits.newCone_π_app :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {T : CategoryTheory.Monad C} {J : Type u}
      [inst_1 : CategoryTheory.Category.{v, u} J] (D : CategoryTheory.Functor J (CategoryTheory.Monad.Algebra T))
      (c : CategoryTheory.Limits.Cone (CategoryTheory.Functor.comp D (CategoryTheory.Monad.forget T))) (X : J),
      (CategoryTheory.Monad.ForgetCreatesLimits.newCone D c).π.app X =
        CategoryTheory.CategoryStruct.comp (T.map (c.π.app X)) (D.obj X).a :=
  by sorry

This theorem states that for any category `C`, monad `T` on `C`, type `J`, functor `D` from `J` to the category of T-algebras, and a cone `c` over the composition of `D` and the forgetful functor from the category of T-algebras to `C`, the morphism given by the natural transformation component of the cone created by the forgetful functor at any object `X` of `J` is equal to the composition of the morphism given by `T` applied to the morphism given by the natural transformation component of cone `c` at `X`, and the morphism given by the algebra structure of the object of `D` at `X`. This theorem essentially describes a property of the new cone created by the forgetful functor in the context of monadic algebraic structures.

For any category `C`, monad `T` on `C`, functor `D` from a category `J` to the category of `T`-algebras, and a cone `c` over the composition of `D` and the forgetful functor from the category of `T`-algebras to `C`, the natural transformation component of the forgetful functor's cone at any object `X` of `J` equals the composition of `T` applied to this cone's component at `X` and the algebra structure morphism of `D(X)`.


theorem nndist_comm : ∀ {α : Type u} [inst : PseudoMetricSpace α] (x y : α), nndist x y = nndist y x := by sorry

This theorem states that in any pseudometric space (a mathematical space where distance between points is defined), the non-negative distance (`nndist`) between two points `x` and `y` is the same regardless of the order in which the points are considered. In other words, the non-negative distance from `x` to `y` is the same as the non-negative distance from `y` to `x`. This is a reflection of the commutative property of distance in pseudometric spaces.

In any pseudometric space, the non-negative distance between two points is commutative, i.e., `nndist x y = nndist y x`.


theorem CategoryTheory.Limits.pullbackRightPullbackFstIso.proof_2 :
    ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {W X Y Z : C} (f : X ⟶ Z) (g : Y ⟶ Z) (f' : W ⟶ X)
      [inst_1 : CategoryTheory.Limits.HasPullback f g]
      [inst_2 : CategoryTheory.Limits.HasPullback f' CategoryTheory.Limits.pullback.fst],
      CategoryTheory.CategoryStruct.comp CategoryTheory.Limits.pullback.fst f' =
        CategoryTheory.CategoryStruct.comp CategoryTheory.Limits.pullback.snd CategoryTheory.Limits.pullback.fst :=
  by sorry

This theorem states that in a category `C` with objects `W`, `X`, `Y`, `Z`, and morphisms `f: X ⟶ Z`, `g: Y ⟶ Z`, `f': W ⟶ X`, if `f` and `g` have a pullback and `f'` and the first projection of the pullback of `f` and `g` have a pullback, then the composition of the first projection of the pullback of `f` and `g` with `f'` is equal to the composition of the second projection of the pullback of `f` and `g` with the first projection of the pullback of `f` and `g`. This is a property of pullbacks in category theory which asserts the commutativity of a specific square diagram involving some pullbacks.

In a category with pullbacks, if morphisms `f: X ⟶ Z`, `g: Y ⟶ Z`, `f': W ⟶ X`, and their pullbacks exist, then the composition of the first projections of their pullbacks is equal to the composition of the second projection of `f` and `g` with the first projection of the pullback of `f` and `g`.


theorem CategoryTheory.Pretriangulated.Triangle.hom_ext :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.HasShift C ℤ]
      {A B : CategoryTheory.Pretriangulated.Triangle C} (f g : A ⟶ B),
      f.hom₁ = g.hom₁ → f.hom₂ = g.hom₂ → f.hom₃ = g.hom₃ → f = g :=
  by sorry

This theorem is about categories in mathematics and particularly about the pre-triangulated category. It states that for any given category `C` of type `u` (where `C` has a shifting operation defined on it), for any two pre-triangulated triangles `A` and `B` in `C`, and for any two morphisms `f` and `g` from `A` to `B`, if the first, second, and third morphisms of `f` and `g` are equal respectively, then `f` and `g` are the same. Basically, it establishes the uniqueness of a morphism in a pre-triangulated triangle, based on the equality of its constituent homomorphisms.

In a pre-triangulated category `C`, if two morphisms between pre-triangulated triangles have equal constituent homomorphisms, then they are equal.


/-- **Alias** of `Measurable.subtype_coe`. -/
theorem Measurable.subtype_val :
    ∀ {α : Type u_1} {β : Type u_2} {m : MeasurableSpace α} {mβ : MeasurableSpace β} {p : β → Prop} {f : α → Subtype p},
      Measurable f → Measurable fun a => ↑(f a) :=
  by sorry

The theorem `Measurable.subtype_val` states that for any types `α` and `β`, given a measurable space over `α`, a measurable space over `β`, a property `p` on `β`, and a function `f` mapping an element of `α` to a subtype of `β` satisfying the property `p`, if the function `f` is measurable, then the function that maps an element of `α` to the underlying element of `β` in the image of `f` is also measurable. In other words, if `f` is a measurable function from `α` to a subtype of `β`, then the function that takes an element in `α` and returns the corresponding element in `β` (ignoring the subtype structure) is also measurable.

If `f : α → β` is a measurable function mapping each `x in α` to a subtype of `β` satisfying property `p`, then the function `x ↦ ⨆ (f x)` is measurable, where `⨆` denotes the underlying element of a subtype.


theorem iInf_emptyset : ∀ {α : Type u_1} {β : Type u_2} [inst : CompleteLattice α] {f : β → α}, ⨅ x ∈ ∅, f x = ⊤ := by
  sorry

This theorem states that for any type `α` that forms a complete lattice and any function `f` from type `β` to `α`, the infimum (greatest lower bound) of `f x` for all `x` in the empty set is the top element (⊤) of the lattice. In other words, if we take the infimum of a function applied to no elements at all, we get the greatest possible value in the lattice.

For any complete lattice `α` and function `f` from type `β` to `α`, the infimum of `f x` over the empty set is the top element `⊤` of the lattice.


MonotoneOn.inter

theorem MonotoneOn.inter :
    ∀ {α : Type u_1} {β : Type u_2} [inst : Preorder β] {f g : β → Set α} {s : Set β},
      MonotoneOn f s → MonotoneOn g s → MonotoneOn (fun x => f x ∩ g x) s :=
  by sorry

The theorem `MonotoneOn.inter` states that for any types `α` and `β` with a preorder defined on `β`, and for any functions `f` and `g` from `β` to the set of `α`, along with a set `s` of type `β`, if both `f` and `g` are monotone on `s`, then the function that maps `x` to the intersection of `f x` and `g x` is also monotone on `s`. In other words, the intersection of two monotone functions over a set in a preordered type is again a monotone function over that set.

If `f` and `g` are monotone functions from a preordered set `β` to type `α`, then their intersection `x ↦ f x ∩ g x` is also a monotone function on `β`.


/-- The natural degree of `cyclotomic n` is `totient n`.  -/
theorem Polynomial.natDegree_cyclotomic :
    ∀ (n : ℕ) (R : Type u_1) [inst : Ring R] [inst_1 : Nontrivial R],
      Polynomial.natDegree (Polynomial.cyclotomic n R) = Nat.totient n :=
  by sorry

The theorem `Polynomial.natDegree_cyclotomic` states that for any natural number `n` and any type `R` which is a ring and nontrivial (i.e., `R` has at least two distinct elements), the natural degree of the `n`-th cyclotomic polynomial with coefficients in `R` is equal to the Euler's totient function for `n`. Here, the natural degree of a polynomial is a version of the degree of the polynomial that is defined to be a natural number, and the Euler's totient function of a natural number `n` counts the number of natural numbers less than `n` which are coprime with `n`.

For any natural number `n` and nontrivial ring `R`, the natural degree of the `n`-th cyclotomic polynomial over `R` equals the Euler's totient function of `n`.


theorem Real.exp_one_near_10 : |Real.exp 1 - 2244083 / 825552| ≤ 1 / 10 ^ 10 := by sorry

This theorem, `Real.exp_one_near_10`, states that the absolute value of the difference between the real exponential function evaluated at 1 and the ratio 2244083 / 825552 is less than or equal to 1 over 10 to the power of 10. In mathematical terms, it asserts that $|e - \frac{2244083}{825552}| \leq \frac{1}{10^{10}}$, where `e` is the base of the natural logarithm. This shows an approximation of `e` with a specific level of precision.

The absolute difference between the real exponential function evaluated at 1 and the constant 2244083 / 825552 is less than or equal to 1 / 10^10.


theorem Set.subset_diff_union : ∀ {α : Type u} (s t : Set α), s ⊆ s \ t ∪ t := by sorry

The theorem `Set.subset_diff_union` states that for any type `α` and for any two sets `s` and `t` of type `α`, `s` is a subset of the union of the difference of `s` and `t` and `t`. In other words, if we take away some elements from `s` to form a new set `s \ t`, and then form a union with `t`, the resulting set still contains `s` as a subset. In mathematical notation, for all sets `s` and `t`, `s` ⊆ `(s \ t) ∪ t`.

For all sets `s` and `t`, `s` is a subset of `(s \ t) ∪ t`.


theorem upperCentralSeries_one : ∀ (G : Type u_1) [inst : Group G], upperCentralSeries G 1 = Subgroup.center G := by
  sorry

This theorem states that for any group `G`, the first term in the upper central series of `G` is equal to the center of `G`. In other words, for any group, the set of elements that commute with everything in the group is the same as the first term in the upper central series of the group.

The first term of the upper central series of a group equals its center.


theorem Polynomial.degree_le_iff_coeff_zero :
    ∀ {R : Type u} [inst : Semiring R] (f : Polynomial R) (n : WithBot ℕ),
      Polynomial.degree f ≤ n ↔ ∀ (m : ℕ), n < ↑m → Polynomial.coeff f m = 0 :=
  by sorry

The theorem `Polynomial.degree_le_iff_coeff_zero` states that for any polynomial `f` over a semiring `R`, and any natural number `n` possibly extended with the bottom element `⊥`, the degree of `f` is less than or equal to `n` if and only if the coefficients of `f` for all powers `m` greater than `n` are zero. In other words, the degree of a polynomial is determined by the highest exponent with a non-zero coefficient.

The degree of a polynomial over a semiring is less than or equal to a given natural number if and only if all its coefficients for powers greater than that number are zero.


theorem Ordinal.log_zero_left : ∀ (b : Ordinal.{u_1}), Ordinal.log 0 b = 0 := by sorry

The theorem `Ordinal.log_zero_left` states that for any ordinal number `b`, the ordinal logarithm of `0` base `b` is always `0`. This is very similar to the rule in basic arithmetic that anything raised to the power of `0` is `1`, except that in the setting of ordinal numbers, the base `0` logarithm of any number is `0`.

For any ordinal number `b`, the ordinal logarithm of `0` base `b` equals `0`.


theorem Finset.fold_op_rel_iff_or :
    ∀ {α : Type u_1} {β : Type u_2} {op : β → β → β} [hc : Std.Commutative op] [ha : Std.Associative op] {f : α → β}
      {b : β} {s : Finset α} {r : β → β → Prop},
      (∀ {x y z : β}, r x (op y z) ↔ r x y ∨ r x z) →
        ∀ {c : β}, r c (Finset.fold op b f s) ↔ r c b ∨ ∃ x ∈ s, r c (f x) :=
  by sorry

The theorem `Finset.fold_op_rel_iff_or` states that for any types `α` and `β`, a binary operation `op` on `β` that is commutative and associative, a function `f` from `α` to `β`, a base value `b` of type `β`, a finite set `s` of type `α`, and a binary relation `r` on `β`, if the relation `r` satisfies the property that `r x (op y z)` is equivalent to `r x y` or `r x z` for all `x`, `y`, `z` of type `β`, then the relation `r c (Finset.fold op b f s)` is equivalent to `r c b` or there exists an `x` in `s` such that `r c (f x)` holds for any `c` of type `β`. In other words, the relationship `r` holds between `c` and the fold of `s` through `op` and `f` if and only if it holds between `c` and `b`, or there exists an element `x` in `s` for which the relationship `r` holds after applying `f` to `x`.

For any commutative and associative binary operation `op` on type `β`, function `f` from `α` to `β`, base value `b` of type `β`, binary relation `r` on `β`, and finite set `s` of type `α`, if `r` satisfies `r x (op y z) ↔ r x y ∨ r x z` for all `x, y, z` in `β`, then `r c (Finset.fold op b f s) ↔ r c b ∨ ∃x ∈ s, r c (f x)`.


theorem OrderHom.le_map_sup_fixedPoints :
    ∀ {α : Type u} [inst : CompleteLattice α] (f : α →o α) (x y : ↑(Function.fixedPoints ⇑f)), ↑x ⊔ ↑y ≤ f (↑x ⊔ ↑y) :=
  by sorry

The theorem `OrderHom.le_map_sup_fixedPoints` states that for any complete lattice `α`, an order-preserving function `f` mapping `α` to `α`, and any two elements `x` and `y` in the set of fixed points of `f`, the join (or supremum) of `x` and `y` is less than or equal to the image of their join under `f`. In other words, for fixed points in a complete lattice, `f` preserves the order when applied to their supremum.

For any complete lattice α and order-preserving function f: α → α, if x and y are fixed points, then f(sup x y) ≤ sup (fx) (fy).


/-- A relation is well founded iff its lift to a quotient is.  -/
theorem wellFounded_lift₂_iff :
    ∀ {α : Type u_1} [inst : Setoid α] {r : α → α → Prop}
      {H : ∀ (a₁ b₁ a₂ b₂ : α), a₁ ≈ a₂ → b₁ ≈ b₂ → r a₁ b₁ = r a₂ b₂},
      WellFounded (Quotient.lift₂ r H) ↔ WellFounded r :=
  by sorry

The theorem `wellFounded_lift₂_iff` states that, for all types `α` that have a setoid structure and for all binary relations `r` on `α`, the relation `r` is well-founded if and only if the relation `r` lifted to the quotient of `α` by this setoid relation is well-founded. This lifted relation is defined by the function `Quotient.lift₂`. Here, well-foundedness of a relation `r` means that there are no infinite descending chains in `r`, and equality of relations is defined by the setoid structure.

For any setoid type `α` and binary relation `r` on `α`, `r` is well-founded if and only if the relation `Quotient.lift₂ r` obtained by lifting `r` to the quotient of `α` by the setoid relation is well-founded.


UniformContinuous.inv

theorem UniformContinuous.inv :
    ∀ {α : Type u_1} {β : Type u_2} [inst : UniformSpace α] [inst_1 : Group α] [inst_2 : UniformGroup α]
      [inst_3 : UniformSpace β] {f : β → α}, UniformContinuous f → UniformContinuous fun x => (f x)⁻¹ :=
  by sorry

The theorem `UniformContinuous.inv` states that for any two types `α` and `β`, where `α` is equipped with an instance of `UniformSpace`, `Group`, and `UniformGroup`, and `β` is equipped with an instance of `UniformSpace`, if a function `f` from `β` to `α` is uniformly continuous, then the function that maps `x` in `β` to the inverse of `f(x)` in `α` is also uniformly continuous. In mathematical terms, if `(f x, f y)` tends to the diagonal as `(x, y)` tends to the diagonal, then so does `((f x)⁻¹, (f y)⁻¹)`. This means that if `x` is sufficiently close to `y`, then not only is `f x` close to `f y`, but also the inverse of `f x` is close to the inverse of `f y`, irrespective of where `x` and `y` are located in `β`.

If `f: β → α` is uniformly continuous with `α` and `β` being uniform spaces equipped with uniform groups, then the function `x mapsto (f x)⁻¹` is also uniformly continuous.


theorem Mathlib.Data.Finset.Lattice._auxLemma.2 : ∀ {a b c : Prop}, (a ∧ b → c) = (a → b → c) := by sorry

This theorem, `Mathlib.Data.Finset.Lattice._auxLemma.2`, states that for any three propositions `a`, `b`, and `c`, the implication `(a ∧ b → c)` is equivalent to `(a → b → c)`. That is to say, if we assume that `a` and `b` together imply `c`, this is the same as saying that if `a` is true, then `b` implies `c`. This captures the intuition that the truth of `c` follows from the combined truth of `a` and `b`, regardless of how those assumptions are structured.

The theorem `Mathlib.Data.Finset.Lattice._auxLemma.2` asserts that the logical implications `(a ∧ b → c)` and `(a → (b → c))` are equivalent for any propositions `a`, `b`, and `c`.


theorem LinearMap.coe_pow :
    ∀ {R : Type u_1} {M : Type u_5} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] (f : M →ₗ[R] M)
      (n : ℕ), ⇑(f ^ n) = (⇑f)^[n] :=
  by sorry

This theorem states that, for any semiring `R`, an additive commutative monoid `M`, and a module structure on `M` over `R`, given a linear map `f` from `M` to `M` and a natural number `n`, the nth power of the map `f` coincides with the nth iterate of `f`. In other words, applying the linear map `f` `n` times is the same as applying the nth power of `f` once.

For any semiring `R`, additive commutative monoid `M` with an `R`-module structure, linear map `f` from `M` to `M`, and natural number `n`, the `n`th power of `f` equals the `n` iterates of `f`: `(f ^ n) = f ^ (n-1) ∘ ... ∘ f`.


theorem Polynomial.expand_one :
    ∀ {R : Type u} [inst : CommSemiring R] (f : Polynomial R), (Polynomial.expand R 1) f = f := by sorry

The theorem `Polynomial.expand_one` states that for any commutative semiring `R` and any polynomial `f` with coefficients in `R`, expanding the polynomial `f` by a factor of 1 results in the same polynomial `f`. In other words, if you take each term of the polynomial `f` and raise its variable part to the power of 1 (which is the operation of the `Polynomial.expand` function when the first argument is 1), the polynomial remains unchanged. This is consistent with the mathematical property that any number (or variable) raised to the power of 1 is the number (or variable) itself.

For any commutative semiring R and polynomial f over R, expanding each term of f by 1 does not change the polynomial f.


theorem CategoryTheory.Iso.comp_hom_eq_id :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} (α : X ≅ Y) {f : Y ⟶ X},
      CategoryTheory.CategoryStruct.comp f α.hom = CategoryTheory.CategoryStruct.id Y ↔ f = α.inv :=
  by sorry

This theorem is about categories in category theory. It states that for any category 'C' and for any objects 'X' and 'Y' in 'C', given an isomorphism 'α' between 'X' and 'Y' and a morphism 'f' from 'Y' to 'X', the composition of the morphism 'f' with the homomorphism part of the isomorphism 'α' is equal to the identity morphism on 'Y' if and only if 'f' is equal to the inverse of the isomorphism 'α'. This is often a key property used in proofs involving isomorphisms in categories.

For any category 'C', object 'X' and 'Y' in 'C', isomorphism 'α' : X ↔ Y, and morphism 'f' : Y → X, the condition f ∘ α.rightInv = idY if and only if f = α.inv holds.


theorem Finset.filter_inter_distrib :
    ∀ {α : Type u_1} (p : α → Prop) [inst : DecidablePred p] [inst_1 : DecidableEq α] (s t : Finset α),
      Finset.filter p (s ∩ t) = Finset.filter p s ∩ Finset.filter p t :=
  by sorry

This theorem states that for any type `α`, a predicate `p` on `α` that is decidable for all elements of `α`, and two finite sets `s` and `t` of `α`, the operation of filtering the intersection of `s` and `t` by `p` (i.e., retaining only the elements of `s ∩ t` that satisfy `p`) is equivalent to the intersection of the sets obtained by filtering `s` and `t` individually by `p`. In other words, for decidable predicates and decidable equality on `α`, filtering distributes over set intersection.

For any type `α` with decidable equality and any decidable predicate `p` on `α`, the filtering of the intersection of two finite sets `s` and `t` by `p` equals the intersection of the filterings of `s` and `t` by `p`.


Language.ext

theorem Language.ext : ∀ {α : Type u_1} {l m : Language α}, (∀ (x : List α), x ∈ l ↔ x ∈ m) → l = m := by sorry

The theorem `Language.ext` states that for any type `α` and any two languages `l` and `m` over this type, if for every list of elements of type `α` the condition that this list is in language `l` is equivalent to the condition that this list is in language `m`, then the languages `l` and `m` are indeed the same. In other words, two languages are equal if and only if they contain exactly the same lists of elements.

Two languages over a type are equal if and only if they contain the same lists of elements.


theorem Set.diff_self_inter : ∀ {α : Type u} {s t : Set α}, s \ (s ∩ t) = s \ t := by sorry

This theorem states that for any type `α` and any two sets `s` and `t` of that type, the difference of `s` and the intersection of `s` and `t` is equal to the difference of `s` and `t`. In other words, removing the elements shared by `s` and `t` from `s` is equivalent to removing all the elements of `t` from `s`. This can be written in mathematical terms as $s \setminus (s \cap t) = s \setminus t$ for all sets `s` and `t` of elements of type `α`.

For all types `α` and sets `s` and `t` of type `α`, the set difference `s \ (s ∩ t)` equals `s \ t`.


theorem Nat.map_div_right_divisors :
    ∀ {n : ℕ}, Finset.map { toFun := fun d => (d, n / d), inj' := ⋯ } (Nat.divisors n) = Nat.divisorsAntidiagonal n :=
  by sorry

The theorem `Nat.map_div_right_divisors` states that for every natural number `n`, if we map each divisor `d` of `n` to a pair `(d, n / d)`, we get exactly the same set as the set of pairs `(x, y)` with `x * y = n`. This uses the function `Finset.map`, which takes an injective function and applies it to each element of a set without adding duplicates, and `Nat.divisors`, which gives the set of divisors of a number. The equality is between two sets of pairs of natural numbers, and it shows a relationship between the divisors of a number and the pairs of numbers that multiply to give that number.

The set of pairs (d, n/d) where d is a divisor of natural number n is equal to the set of pairs (x, y) with x * y = n.


theorem lipschitzWith_lipschitz_const_add_edist :
    ∀ {β : Type u_2} [inst : PseudoMetricSpace β] [inst_1 : AddMonoid β] [_i : LipschitzAdd β],
      LipschitzWith (LipschitzAdd.C β) fun p => p.1 + p.2 :=
  by sorry

The theorem `lipschitzWith_lipschitz_const_add_edist` states that for any type `β` that has a structure of a `PseudoMetricSpace`, an `AddMonoid`, and satisfies the `LipschitzAdd` condition, the function that takes a pair of elements and adds them is Lipschitz continuous with the Lipschitz constant given by `LipschitzAdd.C β`. In other words, the distance (as measured by the extended metric `edist`) between the sums of two pairs of elements in `β` is at most `LipschitzAdd.C β` times the distance between the pairs themselves.

For any type `β` with structures of a PseudoMetricSpace and an AddMonoid satisfying the LipschitzAdd condition, the function `β => λ (x y : β), x + y` is Lipschitz continuous with Lipschitz constant `LipschitzAdd.C β` with respect to the extended metric `edist`.


theorem MeasureTheory.aestronglyMeasurable_zero :
    ∀ {α : Type u_5} {β : Type u_6} {x : MeasurableSpace α} {μ : MeasureTheory.Measure α} [inst : TopologicalSpace β]
      [inst_1 : Zero β], MeasureTheory.AEStronglyMeasurable 0 μ :=
  by sorry

The theorem `MeasureTheory.aestronglyMeasurable_zero` states that for any types `α` and `β`, a measurable space `α`, a measure `μ` on `α`, and a topology on `β`, if `β` has a zero element, then the zero function from `α` to `β` is `AEStronglyMeasurable` with respect to the measure `μ`. In other words, the zero function is almost everywhere equal to the limit of a sequence of simple functions.

Given a measurable space `(α, Σ, μ)`, a topology on `β` with a zero element, the constant function `0 : α → β` is AES-measurable with respect to `μ`.


theorem AddMonoid.fg_def : ∀ {N : Type u_2} [inst : AddMonoid N], AddMonoid.FG N ↔ AddSubmonoid.FG ⊤ := by sorry

The theorem `AddMonoid.fg_def` states that for any type `N` that is an instance of `AddMonoid`, it is finitely generated (abbreviated as `FG`) if and only if its additive submonoid is also finitely generated. In other words, an additive monoid is finitely generated iff its top additive submonoid (denoted as `⊤`) is finitely generated. This theorem connects the concepts of a finitely generated monoid and a finitely generated submonoid in the context of additive monoids.

An additive monoid is finitely generated if and only if its top additive submonoid is finitely generated.


theorem Subgroup.orderOf_coe : ∀ {G : Type u_1} [inst : Group G] {H : Subgroup G} (a : ↥H), orderOf ↑a = orderOf a := by
  sorry

This theorem, `Subgroup.orderOf_coe`, states that for any group `G` and any subgroup `H` of `G`, the order of an element `a` in `H` (when viewed as an element of `G`, i.e., `↑a`) is the same as the order of `a` in `H`. In other words, it confirms that the order of an element doesn't change even if we consider it as part of a larger group. The order of an element `x` in a monoid is the smallest positive integer `n` such that `x^n = 1`, or `0` if such an `n` doesn't exist (i.e., `x` is of infinite order).

For any group `G` and subgroup `H` of `G`, the order of any element `a` in `H` is equal to its order in `G`.


theorem BoxIntegral.Prepartition.restrict_mono :
    ∀ {ι : Type u_1} {I J : BoxIntegral.Box ι} {π₁ π₂ : BoxIntegral.Prepartition I},
      π₁ ≤ π₂ → BoxIntegral.Prepartition.restrict π₁ J ≤ BoxIntegral.Prepartition.restrict π₂ J :=
  by sorry

The theorem `BoxIntegral.Prepartition.restrict_mono` states that for any type `ι`, and any three boxes `I`, `J`, and `π₂` of type `BoxIntegral.Box ι`, and any prepartition `π₁` of the box `I`, if `π₁` is a sub-prepartition of `π₂` (i.e., `π₁ ≤ π₂`), then the restriction of `π₁` to the box `J` is a sub-prepartition of the restriction of `π₂` to the box `J`. In other words, if you restrict a smaller prepartition and a larger prepartition to the same box, the restriction of the smaller prepartition is still smaller than or equal to the restriction of the larger prepartition.

For any boxes `I`, `J` of type `BoxIntegral.Box ι`, and prepartitions `π₁ ≤ π₂` of `I`, the restriction of `π₁` to `J` is a sub-prepartition of the restriction of `π₂` to `J`.


Asymptotics.IsBigO.pow

theorem Asymptotics.IsBigO.pow :
    ∀ {α : Type u_1} {R : Type u_13} {𝕜 : Type u_15} [inst : SeminormedRing R] [inst_1 : NormedDivisionRing 𝕜]
      {l : Filter α} {f : α → R} {g : α → 𝕜}, f =O[l] g → ∀ (n : ℕ), (fun x => f x ^ n) =O[l] fun x => g x ^ n :=
  by sorry

This theorem, `Asymptotics.IsBigO.pow`, states that for any types `α`, `R`, `𝕜`, with `R` being a seminormed ring and `𝕜` a normed division ring, and any filter `l` and functions `f : α → R` and `g : α → 𝕜`, if `f` is Big O of `g` at filter `l` (meaning the absolute value of `f` is eventually less than or equal to some constant multiple of `g`), then for any natural number `n`, the function that maps `x` to `f(x)^n` is also Big O of the function that maps `x` to `g(x)^n` at the same filter `l`. This essentially says that the Big O property is preserved under exponentiation.

For functions `f : α → R` and `g : α → 𝕜`, if `f` is Big O of `g` at filter `l` in the seminormed ring `R` and normed division ring `𝕜`, then `f^n` is Big O of `g^n` at `l` for any natural number `n`.


theorem Function.Bijective.of_comp_iff :
    ∀ {α : Sort u_1} {β : Sort u_2} {γ : Sort u_3} (f : α → β) {g : γ → α},
      Function.Bijective g → (Function.Bijective (f ∘ g) ↔ Function.Bijective f) :=
  by sorry

This theorem states that for all types `α`, `β`, and `γ` and for all functions `f : α → β` and `g : γ → α`, if `g` is bijective (i.e., it is both injective and surjective), then the composition of `f` and `g` (denoted as `f ∘ g`) is bijective if and only if `f` itself is bijective.

If `f : α → β` and `g : γ → α` are functions with `g` bijective, then `f ∘ g` is bijective if and only if `f` is bijective.


/-- If A is an R-algebra all of whose elements are integral over R,
and x is an element of an A-algebra that is integral over A, then x is integral over R. -/
theorem isIntegral_trans :
    ∀ {R : Type u_1} {A : Type u_2} {B : Type u_3} [inst : CommRing R] [inst_1 : CommRing A] [inst_2 : Ring B]
      [inst_3 : Algebra A B] [inst_4 : Algebra R B] [inst_5 : Algebra R A] [inst_6 : IsScalarTower R A B],
      Algebra.IsIntegral R A → ∀ (x : B), IsIntegral A x → IsIntegral R x :=
  by sorry

The theorem `isIntegral_trans` states that if `A` is an `R`-algebra in which all elements are integral over `R` (that is, each element of `A` is a root of some monic polynomial with coefficients in `R`), and if `x` is an element of an `A`-algebra that is integral over `A` (meaning `x` is a root of some monic polynomial with coefficients in `A`), then `x` is also integral over `R`. In simpler terms, if elements of an extension algebra are integral over the base ring, and an element of a further extension is integral over the intermediate algebra, then that element is integral over the base ring. This theorem is valid under the conditions that `R`, `A`, and `B` form a scalar tower, which means that the algebra structures are compatible with each other.

If `A` is an `R`-algebra with all elements integral over `R`, and `x` is an element of an `A`-algebra that is integral over `A`, then `x` is integral over `R`.


theorem Basis.constr_basis :
    ∀ {ι : Type u_1} {R : Type u_3} {M : Type u_6} {M' : Type u_7} [inst : Semiring R] [inst_1 : AddCommMonoid M]
      [inst_2 : Module R M] [inst_3 : AddCommMonoid M'] [inst_4 : Module R M'] (b : Basis ι R M) (S : Type u_10)
      [inst_5 : Semiring S] [inst_6 : Module S M'] [inst_7 : SMulCommClass R S M'] (f : ι → M') (i : ι),
      ((Basis.constr b S) f) (b i) = f i :=
  by sorry

This theorem states that for any basis `b` of a module `M` over a semiring `R`, given a semiring `S` and an `S`-module `M'` where `S` commutes with `R` on `M'`, and a function `f` that maps from the index set `ι` of the basis to `M'`, applying the basis construction function `Basis.constr` to `f` and then applying this to a basis element `b i` will simply return `f i`. In other words, the basis construction function applied to `f` preserves the mapping of `f` on the basis elements.

For any semiring-homomorphism f : ι -> M' between the index set ι of a module basis b in an R-module M and an S-module M', where S commutes with R on M', the application of Basis.constr(f) to the basis element bi is equal to f(bi) in M'.


theorem Set.union_inter_cancel_right : ∀ {α : Type u} {s t : Set α}, (s ∪ t) ∩ t = t := by sorry

The theorem `Set.union_inter_cancel_right` states that for any type `α` and any sets `s` and `t` of type `α`, the intersection of the union of `s` and `t` with `t` is equal to `t`. This corresponds to the principle in set theory which asserts that when you unite a set `t` with another set `s` and then intersect it with `t`, you get back the set `t`. This is expressed mathematically as $(s \cup t) \cap t = t$.

For any type `α` and sets `s` and `t` of type `α`, `(s ∪ t) ∩ t = t`.


/-- Any structured arrow factors through a universal arrow.  -/
theorem CategoryTheory.StructuredArrow.IsUniversal.fac :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂}
      [inst_1 : CategoryTheory.Category.{v₂, u₂} D] {S : D} {T : CategoryTheory.Functor C D}
      {f : CategoryTheory.StructuredArrow S T} (h : CategoryTheory.StructuredArrow.IsUniversal f)
      (g : CategoryTheory.StructuredArrow S T),
      CategoryTheory.CategoryStruct.comp f.hom (T.map (CategoryTheory.StructuredArrow.IsUniversal.desc h g)) = g.hom :=
  by sorry

This theorem states that for any structured arrow in a category, it can be factored through a universal arrow. More precisely, given any category `C` and `D`, a functor `T` from `C` to `D`, an object `S` in `D`, and a universally structured arrow `f` from `S` to `T(C)`, for any structured arrow `g` from `S` to `T(C)`, the composition of the morphism of `f` and the `T`-mapped image of the morphism obtained from `f` to `g` by the universal property of `f`, equals to the morphism of `g`. This highlights the property that a universal arrow is initial in the category of structured arrows, from which every other arrow can be obtained via unique morphisms.

Given any functor T from category C to D, object S in D, and universally structured arrow f : S -> T(C), for any structured arrow g : S -> T(C), the composition of f and the unique morphism from g to f via the universal property equals g.


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

This theorem, `Int.ceil_eq_iff`, states that for any type `α` which is a linear ordered ring and has a floor function, and any integer `z` and element `a` of type `α`, the ceiling of `a` equals `z` if and only if `a` is strictly greater than `z - 1` and less than or equal to `z`. In mathematical notation, this would be expressed as: if ⌈a⌉ = z, then z - 1 < a ≤ z.

For any linear ordered ring `α` with a floor function, `⌈a⌉ = z` if and only if `z - 1 < a <= z`.


/-- Being `J`-closed is stable under pullback.  -/
theorem CategoryTheory.GrothendieckTopology.isClosed_pullback :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (J₁ : CategoryTheory.GrothendieckTopology C) {X Y : C}
      (f : Y ⟶ X) (S : CategoryTheory.Sieve X),
      CategoryTheory.GrothendieckTopology.IsClosed J₁ S →
        CategoryTheory.GrothendieckTopology.IsClosed J₁ (CategoryTheory.Sieve.pullback f S) :=
  by sorry

This theorem states that if we are given a category `C` with a Grothendieck topology `J₁`, along with objects `X` and `Y` in `C` and a morphism `f` from `Y` to `X`, then the property of being `J₁`-closed is preserved under pullback. Specifically, if a sieve `S` on `X` is `J₁`-closed, then the sieve obtained by pulling back `S` along `f` to get a sieve on `Y` is also `J₁`-closed. This means that closure under the Grothendieck topology is a property that is stable under the operation of pullback.

Given a Grothendieck topology `J₁` on a category `C`, if a sieve `S` on an object `X` is `J₁`-closed, then the pullback of `S` along any morphism `f : Y → X` results in a `J₁`-closed sieve on `Y`.


/-- If two continuous functions are equal on a dense set, then they are equal.  -/
theorem Continuous.ext_on :
    ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] [inst_2 : T2Space X]
      {s : Set Y}, Dense s → ∀ {f g : Y → X}, Continuous f → Continuous g → Set.EqOn f g s → f = g :=
  by sorry

This theorem states that if there are two continuous functions `f` and `g` from a topological space `Y` to another topological space `X`, which is also a T2 space (or Hausdorff space), and if these two functions are equal on a dense set `s` in `Y`, then the two functions `f` and `g` are equal everywhere. In other words, if `f` and `g` agree on all points in a set `s` that is dense in `Y`, then `f` and `g` must be the same function.

If `f` and `g` are continuous functions from a dense subset `s` of a T2 space `Y` to a topological space `X`, and `f(y) = g(y)` for all `y` in `s`, then `f = g`.


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

The theorem `Function.Surjective.nonempty_preimage` states that for any types `α` and `β`, and any function `f` from `α` to `β`, if `f` is a surjective function, then for any set `s` of type `β`, the preimage of `s` under `f` is nonempty if and only if `s` is nonempty. In other words, a set `s` has some value if and only if there is some value in `α` that maps to `s` under the function `f`, given that `f` is surjective. The preimage of `s` under `f` is the set of all elements in `α` that `f` maps to an element in `s`.

If `f` is a surjective function from `α` to `β`, then for every nonempty `s ∈ β`, the preimage `f⁁¹(s)` is nonempty in `α`.


theorem AlgebraicTopology.DoldKan.Γ₀.Obj.map_on_summand :
    ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
      (K : ChainComplex C ℕ) [inst_2 : CategoryTheory.Limits.HasFiniteCoproducts C] {Δ Δ' : SimplexCategoryᵒᵖ}
      (A : SimplicialObject.Splitting.IndexSet Δ) (θ : Δ ⟶ Δ') {Δ'' : SimplexCategory} {e : Δ'.unop ⟶ Δ''}
      {i : Δ'' ⟶ A.fst.unop} [inst_3 : CategoryTheory.Epi e] [inst_4 : CategoryTheory.Mono i],
      CategoryTheory.CategoryStruct.comp e i =
          CategoryTheory.CategoryStruct.comp θ.unop (SimplicialObject.Splitting.IndexSet.e A) →
        CategoryTheory.CategoryStruct.comp
            (CategoryTheory.Limits.Cofan.inj
              (SimplicialObject.Splitting.cofan (AlgebraicTopology.DoldKan.Γ₀.splitting K) Δ) A)
            ((AlgebraicTopology.DoldKan.Γ₀.obj K).map θ) =
          CategoryTheory.CategoryStruct.comp (AlgebraicTopology.DoldKan.Γ₀.Obj.Termwise.mapMono K i)
            (CategoryTheory.Limits.Cofan.inj
              (SimplicialObject.Splitting.cofan (AlgebraicTopology.DoldKan.Γ₀.splitting K) Δ')
              (SimplicialObject.Splitting.IndexSet.mk e)) :=
  by sorry

The theorem `AlgebraicTopology.DoldKan.Γ₀.Obj.map_on_summand` states that for a given chain complex `K` in a category `C` with finite coproducts, and given elements of the simplex category and their morphisms such that the composition `e i` is equal to the composition `θ.unop (SimplicialObject.Splitting.IndexSet.e A)`, the composition of the "injection" into the cofan and the map `θ` in the Dold-Kan correspondence is equal to the composition of the termwise mapping of a monomorphism `i` and the "injection" into the cofan associated to the epimorphism `e`.

In simpler terms, this theorem is about the relationship between certain composed morphisms in a category theory context, especially in the context of homological algebra and algebraic topology. It's dealing with the consistency of different paths in a diagram in the category, a fundamental idea in category theory.

Given a chain complex in a category with finite coproducts, the map from the termwise application of a monomorphism to the cofan and the map from the cofan associated to an epimorphism, both in the context of the Dold-Kan correspondence, are equal when their compositions with specific simplices and morphisms satisfy a given condition.


theorem DenseInducing.extend_eq_at :
    ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] {i : α → β}
      (di : DenseInducing i) [inst_2 : TopologicalSpace γ] [inst_3 : T2Space γ] {f : α → γ} {a : α},
      ContinuousAt f a → DenseInducing.extend di f (i a) = f a :=
  by sorry

This theorem states that for all types `α`, `β`, and `γ`, given the topological space structures on them, a function `i : α → β` that induces a dense embedding, and a function `f : α → γ`, if `f` is continuous at a point `a` in type `α`, then the extension of `f` by the dense inducing function `i` evaluated at `i a` is equal to `f a`. Here, a `DenseInducing` function `i` means that the image of any open set in `α` under `i` is dense in `β`, and `ContinuousAt f a` means that the function `f` is continuous at the point `a`. The condition `[inst_3 : T2Space γ]` refers to `γ` being a Hausdorff space (or T2 space), meaning that any two distinct points in `γ` can be separated by disjoint open sets.

Given a dense inducing function `i` from type `α` to type `β`, a continuous function `f` from `α` to Hausdorff space `γ` at a point `a` in `α`, the extension of `f` by `i` at `i(a)` equals `f(a)`.


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

This theorem states that for any type `α` that has an additive commutative semigroup structure, a partial order, a subtraction operation, and satisfies some additional properties, and any elements `a`, `b`, and `c` of `α`, if `b` is `AddLECancellable` (meaning adding `b` to any element is an order-reflecting operation) and `b` is less than or equal to `a`, then `a - b` is less than `c` if and only if `a` is less than `c + b`.

For any additive commutative semigroup `α` with a partial order, subtraction operation, and `AddLECancellable` elements `b`, if `b` is less than or equal to `a` then `a - b` is less than `c` if and only if `a` is less than `c + b`.


theorem instCoeTCCompleteLatticeHom.proof_1 :
    ∀ {F : Type u_3} {α : Type u_1} {β : Type u_2} [inst : FunLike F α β] [inst_1 : CompleteLattice α]
      [inst_2 : CompleteLattice β] [inst_3 : CompleteLatticeHomClass F α β] (f : F) (s : Set α),
      f (sInf s) = sInf (⇑f '' s) :=
  by sorry

The theorem `instCoeTCCompleteLatticeHom.proof_1` states that for all types `F`, `α` and `β`, where `F` is a function-like structure from `α` to `β`, both `α` and `β` are complete lattices, and `F` is a complete lattice homomorphism, for any function `f` of type `F` and any set `s` of elements of type `α`, the function applied to the infimum of the set `s` (`f (sInf s)`) is equal to the infimum of the image of the set `s` under the function `f` (`sInf (⇑f '' s)`). This essentially states that complete lattice homomorphisms preserve infimums in a similar way to how they preserve the order relation, by mapping the infimum of a set to the infimum of its image under the homomorphism. In terms of set theory, the infimum of a set (the greatest element not greater than any element of the set) is preserved under the action of a complete lattice homomorphism.

For any complete lattice homomorphism `F` between complete lattices `α` and `β`, `f (��xb{inf} s) = ��xb{inf} (f '' s)` for all functions `f` of type `F` and sets `s` of elements of type `α`.


theorem instCoeTCCompleteLatticeHom.proof_2 :
    ∀ {F : Type u_3} {α : Type u_1} {β : Type u_2} [inst : FunLike F α β] [inst_1 : CompleteLattice α]
      [inst_2 : CompleteLattice β] [inst_3 : CompleteLatticeHomClass F α β] (f : F) (s : Set α),
      f (sSup s) = sSup (⇑f '' s) :=
  by sorry

The theorem `instCoeTCCompleteLatticeHom.proof_2` states that for any function-like `F` from type `α` to type `β`, where `α` and `β` are both complete lattices, and `F` is a class of homomorphisms from `α` to `β`, then for any such function `f` and any set `s` of type `α`, the supremum (greatest lower bound) of `f` applied to `s` is equal to the supremum of the image of `s` under `f`. This demonstrates that the function `f` preserves the supremum operation, a key property of lattice homomorphisms.

For any complete lattice homomorphism `f` from a complete lattice `α` to a complete lattice `β`, the image of the supremum of a set `s` in `α` under `f` is equal to the supremum of the images of elements in `s` under `f`.


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

This theorem, `tsub_lt_iff_right`, holds for any type `α` that is an additive commutative semigroup, has a partial order, has an operation for the existence of addition of less than or equal to, exhibits covariance and contravariance with respect to addition and less than or equal, and supports subtraction operations where addition and subtraction are ordered. The theorem states that for any three elements `a`, `b`, `c` of type `α`, if `b` is less than or equal to `a`, then the inequality `a - b < c` holds true if and only if `a < c + b`. This theorem essentially establishes an equivalence between two different ways of expressing similar inequalities.

For any additive commutative semigroup type `α` with partial order, additive subtraction, and covariance/contravariance properties, the inequality `a - b < c` is equivalent to `a < c + b`.


/-- If `f : R ≃+* S` is a ring isomorphism and `I : Ideal R`, then `map f I = comap f.symm I`.  -/
theorem Ideal.map_comap_of_equiv :
    ∀ {R : Type u} {S : Type v} [inst : Semiring R] [inst_1 : Semiring S] (I : Ideal R) (f : R ≃+* S),
      Ideal.map (↑f) I = Ideal.comap (RingEquiv.symm f) I :=
  by sorry

The theorem `Ideal.map_comap_of_equiv` states that for any semirings `R` and `S`, and for any ideal `I` in `R` and a ring isomorphism `f` from `R` to `S`, the ideal obtained by mapping `I` through `f` is equal to the ideal obtained by applying the function `comap` to the inverse of `f` and `I`. In simpler terms, mapping an ideal through a ring isomorphism and then 'pulling back' through the inverse isomorphism returns the original ideal.

For any semirings R and S, ideal I in R, and ring isomorphism f from R to S, the ideal f''(I) = (comap (inverse f) I).


theorem ack_mono_left : ∀ (n : ℕ), Monotone fun m => ack m n := by sorry

This theorem states that for every natural number `n`, the Ackermann function `ack` is monotone when its first argument varies while the second argument remains fixed to `n`. In other words, if `m1 ≤ m2` for any two natural numbers `m1` and `m2`, then `ack m1 n ≤ ack m2 n`.

For all natural numbers `n`, the Ackermann function `ack` is monotone in its first argument, i.e., `ack m1 n ≤ ack m2 n` for all `m1 ≤ m2`.


/-- Definition of `IsLittleO` in terms of filters.  -/
theorem Asymptotics.isLittleO_iff :
    ∀ {α : Type u_1} {E : Type u_3} {F : Type u_4} [inst : Norm E] [inst_1 : Norm F] {f : α → E} {g : α → F}
      {l : Filter α}, f =o[l] g ↔ ∀ ⦃c : ℝ⦄, 0 < c → ∀ᶠ (x : α) in l, ‖f x‖ ≤ c * ‖g x‖ :=
  by sorry

This theorem, `Asymptotics.isLittleO_iff`, states the definition of "little-o" notation in the context of asymptotic analysis with filters. Specifically, it asserts that for any functions `f : α → E` and `g : α → F`, where `E` and `F` are normed spaces over some type `α`, and a given filter `l` on `α`, `f` is "little-o" of `g` at `l` if and only if for any positive real number `c`, eventually (as defined by the filter `l`), the norm of `f(x)` is less than or equal to `c` times the norm of `g(x)`. This encapsulates the notion that `f` grows no faster than `g` near the limit points defined by the filter `l`.

For functions `f : α → E` and `g : α → F` over a filter `l` on `α` in normed spaces `E` and `F`, `f` is little-o of `g` at `l` if and only if for every `c > 0`, eventually, the norm of `f(x)` is less than or equal to `c` times the norm of `g(x)`.


theorem lcm_dvd_iff :
    ∀ {α : Type u_1} [inst : CancelCommMonoidWithZero α] [inst_1 : GCDMonoid α] {a b c : α},
      lcm a b ∣ c ↔ a ∣ c ∧ b ∣ c :=
  by sorry

This theorem, `lcm_dvd_iff`, states that for any type `α` that has an instance of `CancelCommMonoidWithZero` and `GCDMonoid`, and for any three elements `a`, `b`, `c` of that type, the lowest common multiple (lcm) of `a` and `b` divides `c` if and only if both `a` divides `c` and `b` divides `c`. In other words, it relates the divisibility of a number by the lcm of two other numbers to the divisibility of that number by each of those two numbers individually. This is a fundamental property within number theory.

For elements `a`, `b`, `c` of a type with `CancelCommMonoidWithZero` and `GCDMonoid structures, lcm(a, b) | c if and only if a | c and b | c.` (Here, `|` denotes divisibility.)


theorem cauchySeq_iff_tendsto :
    ∀ {α : Type u} {β : Type v} [uniformSpace : UniformSpace α] [inst : Nonempty β] [inst : SemilatticeSup β]
      {u : β → α}, CauchySeq u ↔ Filter.Tendsto (Prod.map u u) Filter.atTop (uniformity α) :=
  by sorry

The theorem `cauchySeq_iff_tendsto` states that for any types `α` and `β`, with `α` being a uniform space and `β` being a nonempty semilattice sup, and any function `u` from `β` to `α`, the sequence `u` is a Cauchy sequence if and only if the map of pairs `(u, u)` tends to the uniformity of `α` as `β` tends to infinity. This theorem ties the notion of a sequence being Cauchy (i.e., the terms of the sequence becoming arbitrarily close to each other as the sequence progresses) with the notion of a function tending to a limit (in this case, the uniformity of the space `α`).

A sequence in a uniform space is Cauchy if and only if the function mapping each term to itself tends to the uniformity of the space as the sequence index approaches infinity.


theorem AddSubgroup.zmultiples_eq_closure :
    ∀ {G : Type u_1} [inst : AddGroup G] (g : G), AddSubgroup.zmultiples g = AddSubgroup.closure {g} := by sorry

This theorem states that for any given type `G` which forms an additive group, the subgroup generated by multiples of any element `g` of the group (denoted by `AddSubgroup.zmultiples g`) is equivalent to the closure of the set containing just the element `g` (denoted by `AddSubgroup.closure {g}`). In other words, the cyclic subgroup generated by `g` is the smallest subgroup of `G` that contains `g`.

For any additive group `G` and element `g` in `G`, the subgroup generated by multiples of `g` (`AddSubgroup.zmultiples g`) equals the closure of the set containing just `g` (`AddSubgroup.closure {g}`). Alternatively, the cyclic subgroup generated by `g` is the smallest subgroup containing `g`.


/-- The `vectorSpan` is the span of the pairwise subtractions with a given point on the left.  -/
theorem vectorSpan_eq_span_vsub_set_left :
    ∀ (k : Type u_1) {V : Type u_2} {P : Type u_3} [inst : Ring k] [inst_1 : AddCommGroup V] [inst_2 : Module k V]
      [inst_3 : AddTorsor V P] {s : Set P} {p : P},
      p ∈ s → vectorSpan k s = Submodule.span k ((fun x => p -ᵥ x) '' s) :=
  by sorry

The theorem `vectorSpan_eq_span_vsub_set_left` expresses that, given a set of points `s` in an additive torsor space `P` over a module `V`, and a point `p` within `s`, the vector span of `s` is equivalent to the span of the set of vectors formed by subtracting each point in `s` from `p`. Here, the vector subtraction `-ᵥ` returns a vector in `V`. In other words, in such a setting, we can create the vector span of `s` by looking at all vectors resulting from subtracting other points in `s` from a chosen point `p` in `s`, and then spanning over these vectors.

The theorem asserts that the vector span of a set of points in an additive torsor space is equal to the span of the vectors obtained by subtracting each point in the set from a fixed point in the set.


HasFDerivAt.continuousAt

theorem HasFDerivAt.continuousAt :
    ∀ {𝕜 : 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}
      {f' : E →L[𝕜] F} {x : E}, HasFDerivAt f f' x → ContinuousAt f x :=
  by sorry

The theorem `HasFDerivAt.continuousAt` states that for any function `f` from a normed vector space `E` over a nontrivially normed field `𝕜` to another normed vector space `F` over the same field `𝕜`, if `f` has a derivative `f'` at a point `x in E`, then `f` is continuous at `x`. In other words, if `f` satisfies the condition that `f x'` approaches `f x + f' (x' - x) + o (x' - x)` as `x'` tends to `x`, then `f x` tends to `f x₀` when `x` tends to `x₀`, which is the definition of continuity at a point.

If a function `f` from a normed vector space to another normed vector space has a derivative at a point, then it is continuous at that point.


theorem Int.bitwise_bit :
    ∀ (f : Bool → Bool → Bool) (a : Bool) (m : ℤ) (b : Bool) (n : ℤ),
      Int.bitwise f (Int.bit a m) (Int.bit b n) = Int.bit (f a b) (Int.bitwise f m n) :=
  by sorry

The theorem `Int.bitwise_bit` establishes a property of the `Int.bitwise` function and the `Int.bit` function. It states that for any boolean function `f`, any two boolean values `a` and `b`, and any two integers `m` and `n`, the result of applying `Int.bitwise` to the integers obtained by appending `a` and `b` to `m` and `n` respectively using `Int.bit`, is the same as the integer obtained by appending the result of applying `f` to `a` and `b` to the result of applying `Int.bitwise` to `m` and `n`.
In other words, you can either append the bits to the integers first and then apply the bitwise operation, or apply the bitwise operation first and then append the resulting bit, and you end up with the same result.

For any boolean function `f` and integers `m`, `n`, `a`, and `b`, `Int.bitwise m (Int.bit a m) Int.bit b n` is equal to `Int.bitwise (Int.bit a m @ Int.bit b n) (m + n)`.


theorem iSup_plift_down : ∀ {α : Type u_1} {ι : Sort u_5} [inst : SupSet α] (f : ι → α), ⨆ i, f i.down = ⨆ i, f i := by
  sorry

This theorem states that for any type `α` with a `SupSet` instance and a function `f` from sort `ι` to `α`, the supremum of the results of applying `f` to the "down" version of elements of `ι` is equal to the supremum of the results of applying `f` directly to elements of `ι`. In mathematical terms, this can be expressed as: for any function `f : ι → α`, the following equality holds: `sup {f(i.down) | i in ι} = sup {f(i) | i in ι}`.

For any function `f` from a type `ι` to a type `α` with a `SupSet` instance, the supremum of `f` applied to the "down" version of `ι`'s elements equals the supremum of `f` applied to the elements themselves: `sup (map down (f ∘ i) i) = sup (f i)`.


theorem TopologicalSpace.noetherianSpace_iff_opens :
    ∀ (α : Type u_1) [inst : TopologicalSpace α],
      TopologicalSpace.NoetherianSpace α ↔ ∀ (s : TopologicalSpace.Opens α), IsCompact ↑s :=
  by sorry

The theorem `TopologicalSpace.noetherianSpace_iff_opens` establishes an equivalence between two conditions for a given type `α` with a `TopologicalSpace` structure. The first condition is that `α` is a Noetherian space, that means every nonempty set of open subsets of `α` has a minimal element. The second condition is that for every open subset `s` of `α`, the set `s` is compact. Here, a set being compact means that for any nontrivial filter `f` that contains the set, there exists an element in the set such that every set in the filter intersects with every neighborhood of that element.

A topological space is Noetherian if and only if every open subset is compact.


theorem Nat.bit1_inj : ∀ {n m : ℕ}, bit1 n = bit1 m → n = m := by sorry

The theorem `Nat.bit1_inj` states that for all natural numbers `n` and `m`, if the "bit1" (which is defined as twice the input number plus one) of `n` is equal to the "bit1" of `m`, then `n` must be equal to `m`. In other words, the "bit1" function is injective (or one-to-one) over the natural numbers, meaning that it never maps different inputs to the same output.

If two natural numbers have the same "bit1" (twice the number plus one), then they are equal.


theorem frontier_Ici :
    ∀ {α : Type u} [inst : TopologicalSpace α] [inst_1 : LinearOrder α] [inst_2 : OrderTopology α]
      [inst_3 : DenselyOrdered α] [inst_4 : NoMinOrder α] {a : α}, frontier (Set.Ici a) = {a} :=
  by sorry

The theorem `frontier_Ici` states that for any type `α` that has a topology, is linearly ordered, has an order topology, is densely ordered, and has no minimum element, the frontier of the left-closed right-infinite interval starting at any point `a` is the singleton set containing only 'a'. In other words, the only point that lies between the closure and the interior of this interval is its left endpoint 'a'.

For any linearly ordered type with topology, dense order, no minimum element, the frontier of the left-closed right-infinite interval equals its left endpoint.


theorem RingHom.map_multiset_sum :
    ∀ {β : Type u_4} {γ : Type u_5} [inst : NonAssocSemiring β] [inst_1 : NonAssocSemiring γ] (f : β →+* γ)
      (s : Multiset β), f (Multiset.sum s) = Multiset.sum (Multiset.map (⇑f) s) :=
  by sorry

This theorem states that for any non-associative semirings `β` and `γ` and any ring homomorphism `f` from `β` to `γ`, the sum of a multiset `s` of elements in `β` after applying the ring homomorphism `f` is equal to the sum of the multiset obtained by applying `f` to each element of `s` first and then adding them up. In other words, it asserts the distributive property of ring homomorphisms over the sum of multisets: the ring homomorphism applied to the sum of a multiset equals the sum of the multiset with the ring homomorphism applied to each element.

For any non-associative semirings β and γ and ring homomorphism f from β to γ, the application of f to the sum of a multiset in β is equal to the sum of the multiset obtained by applying f to each element.


theorem Complex.frontier_preimage_im : ∀ (s : Set ℝ), frontier (Complex.im ⁻¹' s) = Complex.im ⁻¹' frontier s := by
  sorry

This theorem states that for any set `s` of real numbers, the frontier (boundary) of the preimage of `s` under the imaginary part function of complex numbers is equal to the preimage of the frontier of `s` under the same function. In other words, when mapping from the complex plane to the real line via the imaginary part function, the boundary of the set of preimages is the same as the set of preimages of the boundaries.

The imaginary part function maps the boundary of a set of complex numbers to the boundary of its image, that is, the frontier of the preimage is equal to the preimage of the frontier.


/-- If a small natural number is divisible by a larger natural number,
the small number is zero.  -/
theorem Nat.eq_zero_of_dvd_of_lt : ∀ {a b : ℕ}, a ∣ b → b < a → b = 0 := by sorry

This theorem asserts that if a small natural number 'b' is divisible by a larger natural number 'a', then the small number 'b' must be zero. In other words, no small natural number can be evenly divisible by a larger one, unless the small number is zero. This is a fundamental principle of number division in natural numbers.

A smaller natural number cannot be evenly divided by a larger natural number, except for the case where the smaller number is zero.


theorem Prod.mk_lt_mk_iff_left :
    ∀ {α : Type u} {β : Type v} [inst : Preorder α] [inst_1 : Preorder β] {a₁ a₂ : α} {b : β},
      (a₁, b) < (a₂, b) ↔ a₁ < a₂ :=
  by sorry

This theorem states that for any two elements `a1` and `a2` of a type `α`, and an element `b` of type `β`, under the condition that `α` and `β` are preordered, the ordered pair `(a1, b)` is less than the ordered pair `(a2, b)` if and only if `a1` is less than `a2`. In other words, it asserts that the comparison of two pairs in a product order is determined by the comparison of their first components when the second components are the same.

For any preordered types `α` and `β`, and all `a1, a2 : α` and `b : β`, `(a1, b) < (a2, b)` if and only if `a1 < a2` in `α`.


theorem UniformSpace.Completion.Continuous.inner :
    ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
      {α : Type u_4} [inst_3 : TopologicalSpace α] {f g : α → UniformSpace.Completion E},
      Continuous f → Continuous g → Continuous fun x => ⟪f x, g x⟫_𝕜 :=
  by sorry

This theorem states that for any type `𝕜`, any type `E` which is a normed additive commutative group and an inner product space over `𝕜`, and any type `α` which is a topological space, if we have two functions `f` and `g` from `α` to the Hausdorff completion of `E`, then if `f` and `g` are continuous, the function that maps any `x` in `α` to the inner product of `f(x)` and `g(x)` in `𝕜` is also continuous.

Given a normed additive commutative group and inner product space `E` over a type `𝕜`, two continuous functions `f` and `g` from a topological space `α` to the Hausdorff completion of `E`, the function that maps `x` to the inner product of `f(x)` and `g(x)` is also continuous.