Absorbs.add

theorem Absorbs.add :
    ∀ {M : Type u_1} {E : Type u_2} [inst : Bornology M] {s₁ s₂ t₁ t₂ : Set E} [inst_1 : AddZeroClass E]
      [inst_2 : DistribSMul M E], Absorbs M s₁ t₁ → Absorbs M s₂ t₂ → Absorbs M (s₁ + s₂) (t₁ + t₂) :=
  by sorry

The theorem `Absorbs.add` states that for any types `M` and `E`, given a bornology on `M`, two sets `s₁` and `s₂` of elements of type `E`, and two sets `t₁` and `t₂` also of elements of type `E`, and provided `E` is an additive zero class and there exists a distributive scalar multiplication of elements from `M` on `E`, if the set `s₁` absorbs the set `t₁` and the set `s₂` absorbs the set `t₂`, then the sum of sets `s₁` and `s₂` absorbs the sum of sets `t₁` and `t₂`. In mathematical terms, if `t₁` is contained in all scalings of `s₁` and `t₂` is contained in all scalings of `s₂` by all but a bounded set of elements of `M`, then `t₁ + t₂` is contained in all scalings of `s₁ + s₂` by all but a bounded set of elements of `M`.

If bornologies on type `M`, sets `s₁`, `s₂` of type `E`, and sets `t₁`, `t₂` of type `E` satisfy `s₁ ⊆ λm, m • s₁ ∩ t₁` and `s₂ ⊆ λm, m • s₂ ∩ t₂`, and `M` is an additive zero class with distributive scalar multiplication, then `(s₁ ∪ s₂) ⊆ λm, m • ((s₁ ∪ s₂) ∩ (t₁ ∪ t₂))`.


/-- Assumes left covariance.  -/
theorem Left.mul_nonneg :
    ∀ {α : Type u_1} {a b : α} [inst : MulZeroClass α] [inst_1 : Preorder α] [inst_2 : PosMulMono α],
      0 ≤ a → 0 ≤ b → 0 ≤ a * b :=
  by sorry

The theorem `Left.mul_nonneg` states that for any type `α` equipped with a multiplication operation, a zero element, and a preorder relation, and for any two elements `a` and `b` of `α`, if the multiplication operation of `α` is left-monotonic (meaning, a positive or zero multiplier always results in larger or equal result), then if both `a` and `b` are non-negative (i.e., greater than or equal to zero), their product `a * b` is also non-negative. This theorem is essentially asserting the non-negativity preserving nature of multiplication under the conditions of the multiplication being left-monotonic and the operands being non-negative.

If `α` is a type with a left-monotonic multiplication operation, a zero element, and a preorder relation, then for all non-negative elements `a` and `b` in `α`, their product `a * b` is non-negative.


theorem Set.disjoint_image_of_injective :
    ∀ {α : Type u_1} {β : Type u_2} {f : α → β},
      Function.Injective f → ∀ {s t : Set α}, Disjoint s t → Disjoint (f '' s) (f '' t) :=
  by sorry

This theorem states that for all types `α` and `β` and for all functions `f` from `α` to `β`, if the function `f` is injective, then for any two disjoint sets `s` and `t` of type `α`, their images under the function `f` are also disjoint. Here, two sets are considered disjoint if their intersection is the empty set, and a function is called injective if it assigns distinct outputs to distinct inputs.

If `f` is an injective function from type `α` to type `β`, then the images of any two disjoint sets `s` and `t` in `α` under `f` are also disjoint sets in `β`.


/-- The symmetric version of Tonelli's Theorem: For `ℝ≥0∞`-valued almost everywhere measurable
functions on `α × β`, the integral of `f` is equal to the iterated integral, in reverse order.  -/
theorem MeasureTheory.lintegral_prod_symm :
    ∀ {α : Type u_1} {β : Type u_3} [inst : MeasurableSpace α] [inst_1 : MeasurableSpace β]
      {μ : MeasureTheory.Measure α} {ν : MeasureTheory.Measure β} [inst_2 : MeasureTheory.SFinite ν]
      [inst_3 : MeasureTheory.SFinite μ] (f : α × β → ENNReal),
      AEMeasurable f (MeasureTheory.Measure.prod μ ν) →
        ∫⁻ (z : α × β), f z ∂MeasureTheory.Measure.prod μ ν = ∫⁻ (y : β), ∫⁻ (x : α), f (x, y) ∂μ ∂ν :=
  by sorry

The theorem `MeasureTheory.lintegral_prod_symm` is a symmetric version of Tonelli's Theorem. It states that for functions `f` mapping from a product of two types `α` and `β` to the extended nonnegative real numbers (`ℝ≥0∞`), which are almost everywhere measurable with respect to the product of measures `μ` and `ν`, the integral of `f` with respect to the product measure is equal to the iterated integral, but with the order of integration reversed. In other words, integrating first over `α` and then over `β` is the same as integrating over the product space `α × β`. This statement requires both the measures `μ` and `ν` to be sigma-finite.

For measurable functions `f` from the product space `α × β` to the extended nonnegative real numbers with respect to the sigma-finite product measures `μ` and `ν`, the integral of `f` with respect to `μ` over `α` and then `ν` over `β` equals the integral of `f` with respect to the reversed order of measures.


theorem hasFDerivAtFilter_id :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] (x : E) (L : Filter E), HasFDerivAtFilter id (ContinuousLinearMap.id 𝕜 E) x L :=
  by sorry

The theorem `hasFDerivAtFilter_id` asserts that for any nontrivially normed field `𝕜`, normed add commutative group `E`, a vector `x` in `E`, and a filter `L` on `E`, the identity function has its Fréchet derivative at `x` with respect to the filter `L` and the derivative is given by the continuous linear map `ContinuousLinearMap.id 𝕜 E`. This means that the rate of change of the identity function at `x` in the `L`-direction is precisely the identity map on the space `E`.

For any nontrivially normed field 𝕜, normed add commutative group E, vector x in E, and filter L on E, the identity function on E has its Frechet derivative at x with respect to the filter L equal to the identity map ContinuousLinearMap.id 𝕜 E.


theorem IsCauSeq.cauchy₃ :
    ∀ {α : Type u_1} {β : Type u_2} [inst : LinearOrderedField α] [inst_1 : Ring β] {abv : β → α}
      [inst_2 : IsAbsoluteValue abv] {f : ℕ → β},
      IsCauSeq abv f → ∀ {ε : α}, 0 < ε → ∃ i, ∀ j ≥ i, ∀ k ≥ j, abv (f k - f j) < ε :=
  by sorry

The theorem `IsCauSeq.cauchy₃` states that for any types `α` and `β`, where `α` is a linear ordered field and `β` is a ring, and for any function `abv` from `β` to `α` that is an absolute value, if a sequence of natural numbers to elements of `β` (`f` from `ℕ` to `β`) is a Cauchy sequence (as defined by `IsCauSeq`), then for any positive `ε` in `α`, there exists an index `i` such that for any indices `j` and `k` greater than or equal to `i` and `j` respectively, the absolute value of the difference between the `k`th and `j`th terms of the sequence is less than `ε`. In simple terms, the theorem asserts that if a sequence is Cauchy, then the distances between its later terms can be made as small as desired.

Given a Cauchy sequence `f` of elements in a linear ordered field `α` with respect to an absolute value function `abv` from a ring `β` to `α`, for every positive `ε` in `α`, there exists an index `i` such that for all `j, k ≥ i`, `|abv(f(j) - f(k))| < ε`.


theorem Nat.digits_ne_nil_iff_ne_zero : ∀ {b n : ℕ}, Nat.digits b n ≠ [] ↔ n ≠ 0 := by sorry

This theorem states that for any two natural numbers `b` and `n`, the list of digits of `n` in base `b` is not empty if and only if `n` is not zero. Essentially, it connects the mathematical concepts of numeral representation and non-zero numbers, specifying that a number has a non-empty digit representation in any base if and only if the number itself is not zero.

For any base b and natural number n, the list of digits representing n is non-empty if and only if n is non-zero.


theorem Mathlib.Data.Set.Prod._auxLemma.32 : ∀ (p : Prop), (p ∨ False) = p := by sorry

This theorem states that for any proposition `p`, the statement `p or False` is equivalent to `p` itself. This makes sense in the realm of logic because "or" is a truth-functional operator, so if one of the operands is `False`, the overall truth of the statement depends on the other operand. In this case, `p or False` simplifies to just `p`.

For all propositions p, p or False is logically equivalent to p.


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

The theorem `Mathlib.Data.Set.Prod._auxLemma.17` asserts that for any type `α`, given an element `x` of type `α` and two sets `a` and `b` of type `α`, the statement "x is an element of the union of sets a and b" is equivalent to the statement "x is an element of set a or x is an element of set b". In other words, it establishes that the union operation in set theory corresponds to the logical disjunction operation in propositional logic.

For any type α and sets A and B of type α, the element x ∈ α belongs to the union A ∪ B if and only if x ∈ A or x ∈ B.


theorem Symmetric.flip_eq : ∀ {α : Type u_1} {r : α → α → Prop}, Symmetric r → flip r = r := by sorry

This theorem states that for any type `α` and a relation `r` on `α` that is symmetric, the flipped version of the relation (i.e., the relation obtained by reversing the order of arguments) is the same as the original relation. In mathematical terms, if `r` is a symmetric relation on `α` (that is, for all `x` and `y` in `α`, `r(x, y)` implies `r(y, x)`), then `r(x, y)` is equivalent to `r(y, x)` for all `x` and `y` in `α`, which means the relation remains the same even when the arguments are flipped.

For any symmetric relation `r` on type `α`, `r(x, y)` is equivalent to `r(y, x)` for all `x` and `y` in `α`.


theorem Mathlib.Data.Set.Prod._auxLemma.26 : ∀ {a b c : Prop}, (a ∨ b → c) = ((a → c) ∧ (b → c)) := by sorry

This theorem, named `Mathlib.Data.Set.Prod._auxLemma.26`, states that for any three propositions `a`, `b`, and `c`, the statement "`a` OR `b` implies `c`" is logically equivalent to the combined statements "`a` implies `c`" AND "`b` implies `c`". This is a basic result from propositional logic expressed in the language of Lean 4.

The theorem `Mathlib.Data.Set.PropositionalLogic.or_imp_distrib` in Lean 4 states that for all propositions `a`, `b`, and `c`, `(a Orleans b) -> c` is logically equivalent to `(a -> c)` and `(b -> c)`.


theorem IsUnit.integrable_smul_iff :
    ∀ {α : Type u_1} {β : Type u_2} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} [inst : NormedAddCommGroup β]
      {𝕜 : Type u_5} [inst_1 : NormedRing 𝕜] [inst_2 : Module 𝕜 β] [inst_3 : BoundedSMul 𝕜 β] {c : 𝕜},
      IsUnit c → ∀ (f : α → β), MeasureTheory.Integrable (c • f) μ ↔ MeasureTheory.Integrable f μ :=
  by sorry

The theorem `IsUnit.integrable_smul_iff` states that for any types `α`, `β`, and `𝕜`, where `α` is a measurable space and `𝕜` is a normed ring that's also a module for `β`, given a measure `μ` on `α` and a normed add commutative group structure on `β`. If `c` is a unit in `𝕜` and `f` is a function from `α` to `β`, then `f` is integrable with respect to the measure `μ` if and only if the function obtained by scaling `f` by `c` is also integrable with respect to `μ`. This means that scaling a function by a unit in the ring does not affect its integrability property.

For any measurable space `α`, normed ring `𝕜`, and measure `μ` on `α`, if `c` is a unit in `𝕜` and `f : α → β` is an integrable function with respect to `μ`, then the function `c * f` is also integrable with respect to `μ`. (Here, `β` is a normed add commutative group and `𝕜` is a module over `β`.)


theorem List.nextOr_cons_of_ne :
    ∀ {α : Type u_1} [inst : DecidableEq α] (xs : List α) (y x d : α),
      x ≠ y → List.nextOr (y :: xs) x d = List.nextOr xs x d :=
  by sorry

This theorem, `List.nextOr_cons_of_ne`, states that for any type `α` with decidable equality, given a list `xs` of type `α`, and three elements `y`, `x`, and `d` of type `α`, if `x` is not equal to `y`, then the `nextOr` function, when applied to the list that results from consing `y` onto `xs` (i.e., `y :: xs`), `x`, and `d`, will return the same result as the `nextOr` function applied to `xs`, `x`, and `d`. In other words, if `x` is different from the head of the list, the result of `nextOr` doesn't change when we add an element to the head of the list.

For any type `α` with decidable equality, if list `xs` of type `α`, elements `y`, `x`, and `d` of type `α`, and `x ≠ y`, then `List.nextOr _ (y :: xs) x d` equals `List.nextOr xs x d`.


theorem multiplicity.eq_top_iff_not_finite :
    ∀ {α : Type u_1} [inst : Monoid α] [inst_1 : DecidableRel fun x x_1 => x ∣ x_1] {a b : α},
      multiplicity a b = ⊤ ↔ ¬multiplicity.Finite a b :=
  by sorry

This theorem, `multiplicity.eq_top_iff_not_finite`, states that for any type `α` which has a monoid structure and a decidable relation for divisibility, given two elements `a` and `b` of `α`, the multiplicity of `a` in `b` is infinity (denoted as `⊤`) if and only if it is not finite. In other terms, for any `a` and `b`, `a` divides `b` infinitely many times if and only if there is no natural number `n` such that `a` to the power of `(n + 1)` does not divide `b`.

For any type `α` with a monoid structure and decidable divisibility relation, the multiplicity of `a` in `b` is `⊤` if and only if `a` divides `b` infinitely many times.


theorem BilinForm.compLeft_apply :
    ∀ {R : Type u_1} {M : Type u_2} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
      (B : BilinForm R M) (f : M →ₗ[R] M) (v w : M), (BilinForm.compLeft B f).bilin v w = B.bilin (f v) w :=
  by sorry

The theorem `BilinForm.compLeft_apply` states that for any commutative semiring `R`, an additive commutative monoid `M`, and a module `M` over `R`, given a bilinear form `B` over `R` and `M`, a linear map `f` from `M` to `M`, and two elements `v` and `w` from `M`, applying the `compLeft` function to `B` and `f` and then applying the resulting bilinear form to `v` and `w` is equivalent to applying `B` to the image of `v` under `f` and `w`. In other words, the `compLeft` function applies the linear map `f` to the first argument of the bilinear form.

For any commutative semiring R, additive commutative monoid M, and module M over R, the composition of a bilinear form B over R and M with a linear map f from M to M is equivalent to applying B to the image of the first argument under f and leaving the second argument unchanged.


theorem Fintype.card_of_bijective :
    ∀ {α : Type u_1} {β : Type u_2} [inst : Fintype α] [inst_1 : Fintype β] {f : α → β},
      Function.Bijective f → Fintype.card α = Fintype.card β :=
  by sorry

The theorem `Fintype.card_of_bijective` states that for any two types `α` and `β`, both having finiteness property (instances of `Fintype`), if there exists a bijective function `f` from `α` to `β`, then the number of elements in `α` (represented by `Fintype.card α`) is equal to the number of elements in `β` (represented by `Fintype.card β`). Here, a function is bijective if it is both injective (no two different elements in `α` map to the same element in `β`) and surjective (for every element in `β`, there is an element in `α` that maps to it).

If `α` and `β` are finite types and there exists a bijective function from `α` to `β`, then `Fintype.card α = Fintype.card β`.


theorem CategoryTheory.Limits.pullbackSymmetry_hom_comp_fst_assoc :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z : C} (f : X ⟶ Z) (g : Y ⟶ Z)
      [inst_1 : CategoryTheory.Limits.HasPullback f g] {Z_1 : C} (h : Y ⟶ Z_1),
      CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.pullbackSymmetry f g).hom
          (CategoryTheory.CategoryStruct.comp CategoryTheory.Limits.pullback.fst h) =
        CategoryTheory.CategoryStruct.comp CategoryTheory.Limits.pullback.snd h :=
  by sorry

This theorem, `CategoryTheory.Limits.pullbackSymmetry_hom_comp_fst_assoc`, from the field of Category Theory asserts the following:

Given a category `C`, three objects `X`, `Y`, and `Z` in `C`, and two morphisms `f: X ⟶ Z` and `g: Y ⟶ Z`, if there exists a pullback for `f` and `g`, then for any object `Z_1` in `C` and a morphism `h: Y ⟶ Z_1`, the composition of the homomorphism of the pullback symmetry of `f` and `g`, with the composition of the first projection of the pullback and `h`, is equal to the composition of the second projection of the pullback and `h`.

In simple terms, it states that under certain conditions, the two different routes of composing morphisms in the pullback of `f` and `g` result in the same morphism. The conditions require the existence of a pullback for `f` and `g` and the existence of a morphism `h` from `Y` to another object `Z_1`.

Given a pullback diagram of morphisms `f: X ⟶ Z`, `g: Y ⟶ Z` in a category `C` and a morphism `h: Y ⟶ Z_1`, the composition of the pullback symmetry of `f` and `g` with `h`, and the composition of the first projection of the pullback with `h`, are equal.


/-- If `R` is a ring, then prime ideals in the localization at `M`
correspond to prime ideals in the original ring `R` that are disjoint from `M`.
This lemma gives the particular case for an ideal and its map,
see `le_rel_iso_of_prime` for the more general relation isomorphism, and the reverse implication  -/
theorem IsLocalization.isPrime_of_isPrime_disjoint :
    ∀ {R : Type u_1} [inst : CommSemiring R] (M : Submonoid R) (S : Type u_2) [inst_1 : CommSemiring S]
      [inst_2 : Algebra R S] [inst_3 : IsLocalization M S] (I : Ideal R),
      Ideal.IsPrime I → Disjoint ↑M ↑I → Ideal.IsPrime (Ideal.map (algebraMap R S) I) :=
  by sorry

In the context of commutative semirings R and S, with S being a localization of R at a submonoid M, this theorem states that if an ideal I in R is prime and is disjoint from M (i.e., their intersection is the zero element), then the image of this ideal under the algebraic map from R to S is also a prime ideal. This is a specific case related to the correspondence of prime ideals in the localization and the original semiring when they are disjoint from the submonoid used for localization. The more general relation isomorphism and the reverse implication are given in other related theorems.

In commutative semirings R and its localization S at a submonoid M, if I is a prime ideal in R disjoint from M, then the image of I in S is a prime ideal.


theorem IsOfFinAddOrder.addOrderOf_nsmul :
    ∀ {G : Type u_1} [inst : AddMonoid G] (x : G) (n : ℕ),
      IsOfFinAddOrder x → addOrderOf (n • x) = addOrderOf x / Nat.gcd (addOrderOf x) n :=
  by sorry

The theorem "IsOfFinAddOrder.addOrderOf_nsmul" states that for any type `G` that has a structure of an additive monoid and for any element `x` of `G` which has a finite additive order, and any natural number `n`, the order of the element `n • x` equals the order of `x` divided by the greatest common divisor of the order of `x` and `n`. Here, the order of an element is defined as the smallest positive integer such that multiplying the element by that integer results in the additive identity (zero), and if no such integer exists, the order is conventionally set to zero. The order of multiplication by `n` is the smallest number of applications required to get zero.

For any element `x` of an additive monoid `G` with finite additive order, the order of `n • x` equals the greatest common divisor of the orders of `x` and `n`.


theorem compl_eq_top : ∀ {α : Type u} {x : α} [inst : BooleanAlgebra α], xᶜ = ⊤ ↔ x = ⊥ := by sorry

This theorem states that for all types `α` (where `α` is a Boolean algebra), the complement (`xᶜ`) of a given element `x` from `α` is equal to the top element (`⊤`) if and only if `x` is the bottom element (`⊥`). In other words, in any Boolean algebra, an element and its complement occupy opposite extremes of the algebra; if an element is the least element (`⊥`), its complement is the greatest element (`⊤`), and vice versa.

In a Boolean algebra, the complement of an element is equal to the top element if and only if that element is the bottom element.


theorem Real.Angle.sign_eq_zero_iff : ∀ {θ : Real.Angle}, Real.Angle.sign θ = 0 ↔ θ = 0 ∨ θ = ↑Real.pi := by sorry

The theorem `Real.Angle.sign_eq_zero_iff` states that for any angle `θ` of type `Real.Angle`, the sign of the angle `θ` is zero if and only if the angle `θ` is either zero or equal to pi (`π`). Here, pi is defined as a real number `Real.pi` and the sign of an angle is determined by `Real.Angle.sign` function, which is based on the sign of the sine of the angle.

The sign of a real angle is zero if and only if the angle is either 0 or equal to pi. (In Lean 4, this is expressed as `Real.Angle.sign θ = 0 ↔ θ = 0 or θ = Real.pi`)


theorem Complex.im_ofReal_mul : ∀ (r : ℝ) (z : ℂ), (↑r * z).im = r * z.im := by sorry

This theorem, `Complex.im_ofReal_mul`, states that for all real numbers `r` and complex numbers `z`, the imaginary part of the product of `r` (converted into a complex number) and `z` is equal to `r` multiplied by the imaginary part of `z`. In mathematical terms, it expresses that Im(rz) = r * Im(z), where Im denotes the imaginary part of a complex number.

The imaginary part of the product of a real number and a complex number is equal to the real number times the imaginary part of the complex number.


deriv.neg'

theorem deriv.neg' :
    ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {F : Type v} [inst_1 : NormedAddCommGroup F]
      [inst_2 : NormedSpace 𝕜 F] {f : 𝕜 → F}, (deriv fun y => -f y) = fun x => -deriv f x :=
  by sorry

This theorem states that for any function `f` from a nontrivially normed field `𝕜` to a normed add commutative group `F` (with `𝕜` as its underlying field), the derivative of the negation function (i.e., `fun y => -f y`) is equal to the negation of the derivative of `f` itself. In mathematical notation, this can be expressed as `(d/dx)(-f) = - (d/dx)f`.

For any function `f` from a nontrivially normed field to a normed add commutative group, the derivative of the negation function `fun y => -f y` is equal to the negative of the derivative of `f`. In mathematical notation, `(d/dx)(-f) = -(d/dx)f`.


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

This theorem states that, in a 2-dimensional real vector space endowed with an orientation, the sign of the angle between two vectors remains the same if a multiple of the second vector is added to the first one. In mathematical terms, for any real number `r` and any two vectors `x` and `y`, the sign of the angle between `x + r * y` and `y` is equal to the sign of the angle between `x` and `y`.

For any vectors `x`, `y` in a 2-dimensional real vector space with orientation, and real number `r`, the sign of the angle between `x + r*y` and `y` is equal to the sign of the angle between `x` and `y`.


theorem Complex.ext_abs_arg : ∀ {x y : ℂ}, Complex.abs x = Complex.abs y → Complex.arg x = Complex.arg y → x = y := by
  sorry

The theorem `Complex.ext_abs_arg` states that for any two complex numbers 'x' and 'y', if the absolute values (or magnitudes) of 'x' and 'y' are equal and their arguments (the angles they make with the positive real axis in the complex plane) are also equal, then 'x' and 'y' are the same complex number. This theorem essentially asserts that two complex numbers are equal if and only if they have the same magnitude and the same argument, which is a fundamental property in the study of complex numbers.

Given complex numbers x and y, if |x| = |y| and arg(x) = arg(y), then x = y.


theorem lp.norm_nonneg' :
    ∀ {α : Type u_1} {E : α → Type u_2} {p : ENNReal} [inst : (i : α) → NormedAddCommGroup (E i)] (f : ↥(lp E p)),
      0 ≤ ‖f‖ :=
  by sorry

This theorem states that for any type `α`, any function `E` from `α` to another type, any extended nonnegative real `p`, and any instance of a normed add commutative group for every `i` in `α`, the norm of a function `f` that belongs to the `lp` space defined with `E` and `p` is always nonnegative. In other words, it asserts that the norm of any function in the `lp` space is always greater than or equal to zero, which is a fundamental property of norms in mathematical analysis.

For any type `α`, function `E` from `α` to another type, normed add commutative group instance for each `i` in `α`, and extended nonnegative real `p`, the norm of any function `f` from `α` to the range of `E` belonging to the `lp` space is nonnegative.


theorem Complex.hasSum_cos' :
    ∀ (z : ℂ), HasSum (fun n => (z * Complex.I) ^ (2 * n) / ↑(Nat.factorial (2 * n))) (Complex.cos z) := by sorry

This theorem, `Complex.hasSum_cos'`, states that for any complex number `z`, the series obtained by taking the nth term as `(z * Complex.I) ^ (2 * n) / ↑(Nat.factorial (2 * n))`, where `Complex.I` is the imaginary unit, `^` represents exponentiation, and `Nat.factorial` is the factorial function, converges to the complex cosine of `z`. In mathematical terms, this series is the power series expansion of the complex cosine function.

The complex power series with terms `(z * Complex.I) ^ (2 * n) / Nat.factorial (2 * n)` converges to the complex cosine of `z`.


theorem Bool.false_or : ∀ (b : Bool), (false || b) = b := by sorry

This theorem states that for all Boolean values `b`, the result of a logical OR operation between `false` and `b` is `b`. This corresponds to the logical principle that `false` is the identity for the logical OR operation, which means that if any value is logically OR'ed with `false`, it will not change the value.

For all Boolean values `b`, `false∨b` equals `b`.


theorem List.Nodup.perm_iff_eq_of_sublist :
    ∀ {α : Type u_1} {l₁ l₂ l : List α},
      List.Nodup l → List.Sublist l₁ l → List.Sublist l₂ l → (List.Perm l₁ l₂ ↔ l₁ = l₂) :=
  by sorry

This theorem states that for all lists `l`, `l₁`, and `l₂` of any type `α`, if `l` has no duplicate elements (`List.Nodup l`), and `l₁` and `l₂` are both sublists of `l` (`List.Sublist l₁ l` and `List.Sublist l₂ l`), then `l₁` is a permutation of `l₂` (`List.Perm l₁ l₂`) if and only if `l₁` is equal to `l₂` (`l₁ = l₂`). Essentially, this means that when dealing with sublists of a list with no duplicates, the only way for two such sublists to be permutations of each other is for them to be identical.

For lists `l`, `l₁`, and `l₂` of any type `α` with no duplicate elements (`List.Nodup l`), if `l₁` and `l₂` are both sublists of `l` (`List.Sublist l₁ l` and `List.Sublist l₂ l`), then `l₁` is a permutation of `l₂` (`List.Perm l₁ l₂`) if and only if `l₁ = l₂`.


theorem Complex.log_one : Complex.log 1 = 0 := by sorry

This theorem states that the complex logarithm of 1 equals 0. In other words, if you take the logarithm of 1 in the complex number system, the result is 0. This is consistent with the mathematical fact that the logarithm of 1 (for any base) is always 0, extended to the complex number domain.

The complex logarithm of 1 is equal to 0.


theorem Finset.powerset_card_disjiUnion :
    ∀ {α : Type u_1} (s : Finset α),
      Finset.powerset s = Finset.disjiUnion (Finset.range (s.card + 1)) (fun i => Finset.powersetCard i s) ⋯ :=
  by sorry

This theorem states that for any given finite set `s` of any type `α`, the powerset of `s` (i.e., the set of all subsets of `s`) is equal to the disjoint union of the sets of all subsets of `s` with cardinality `i`, where `i` ranges over the set of natural numbers less than or equal to the size of `s`. In other words, it partitions the powerset of `s` into subsets based on their sizes, and shows that their disjoint union is the entire powerset.

The powerset of a finite set `s` is equal to the disjoint union of the sets of all subsets of `s` with a given cardinality, where the cardinality ranges over natural numbers less than or equal to the size of `s`.


theorem Mathlib.Analysis.SpecialFunctions.Trigonometric.Complex._auxLemma.5 :
    ∀ {G : Type u_3} [inst : AddGroup G] {a b c : G}, (a - b = c) = (a = c + b) := by sorry

This theorem, from the Mathlib library in Lean, states that for any type `G` that is an additive group, and for any elements `a`, `b`, and `c` of that group, the statement "the difference of `a` and `b` equals `c`" is equivalent to the statement " `a` equals `c` added to `b`". This essentially derives from the properties of subtraction and addition in any group.

For any additive group `G` and elements `a`, `b`, `c` in `G`, the equality `a - b = c` is equivalent to `a = c + b`.


theorem Mathlib.Analysis.SpecialFunctions.Trigonometric.Complex._auxLemma.4 :
    ∀ {G : Type u_3} [inst : AddCommGroup G] {a b c : G}, (a = b - c) = (c + a = b) := by sorry

This theorem states that for any type `G` that has an additive commutative group structure, given any three elements `a`, `b`, and `c` of `G`, the equation `a = b - c` is equivalent to the equation `c + a = b`. In other words, subtracting `c` from `b` to get `a` is the same as adding `c` to `a` to get `b`.

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


theorem Mathlib.Analysis.SpecialFunctions.Trigonometric.Complex._auxLemma.1 :
    ∀ {α : Sort u_1} {a b : α}, (a = b) = (b = a) := by sorry

This theorem, defined in the `Mathlib.Analysis.SpecialFunctions.Trigonometric.Complex._auxLemma.1` namespace, states that for any sort `α` and any two elements `a` and `b` of this sort, the statement "a equals b" is logically equivalent to the statement "b equals a". This theorem captures the symmetric property of equality in mathematics, which holds that if a equals b then b equals a, for all types.

The theorem asserts that for all types `α` and elements `a`, `b` of type `α`, the equality `a = b` is logically equivalent to `b = a`.


theorem ContinuousAlternatingMap.toContinuousMultilinearMap_injective :
    ∀ {R : Type u_1} {M : Type u_2} {N : Type u_4} {ι : Type u_6} [inst : Semiring R] [inst_1 : AddCommMonoid M]
      [inst_2 : Module R M] [inst_3 : TopologicalSpace M] [inst_4 : AddCommMonoid N] [inst_5 : Module R N]
      [inst_6 : TopologicalSpace N], Function.Injective ContinuousAlternatingMap.toContinuousMultilinearMap :=
  by sorry

The theorem `ContinuousAlternatingMap.toContinuousMultilinearMap_injective` asserts that for any semiring `R`, Additive Commutative Monoid `M` and `N` and any types `ι` with `M` and `N` being topological spaces and modules over `R`, the function `toContinuousMultilinearMap` from `ContinuousAlternatingMap` is injective. This means that if two continuous alternating maps have the same corresponding continuous multilinear map, then these two continuous alternating maps were originally identical.

For any semiring `R`, given continuous alternating maps `f` and `g` from a topological space `X` to the module `M` over `R`, if their corresponding continuous multilinear maps have equal functions, then `f` and `g` are identical.


theorem List.take_prefix : ∀ {α : Type u_1} (n : ℕ) (l : List α), List.take n l <+: l := by sorry

This theorem, named `List.take_prefix`, states that for any list `l` of elements of an arbitrary type `α` and for any natural number `n`, the prefix of `l` of length `n` (obtained by the `List.take` function) is indeed a prefix of `l`. In other words, taking the first `n` elements from a list always results in a sublist that is a prefix of the original list.

For any list `l` of length `m` and any natural number `n` less than or equal to `m`, `List.take l n` is a prefix of `l`.


theorem Set.iUnion_true : ∀ {α : Type u_1} {s : True → Set α}, Set.iUnion s = s trivial := by sorry

This theorem states that for any type `α` and for any function `s` that maps the `True` proposition to a set of `α`, the indexed union over `s` is equal to `s` applied to the proof of `True` (which is `trivial`). This essentially means that if we take the union of sets indexed by the `True` proposition, we just get the set associated with `True` itself.

For any function `s` mapping `Prop` to sets of type `α`, the indexed union over `s` at `True` equals `s` applied to the trivial proof of `True`.


theorem Complex.ofReal_int_cast : ∀ (n : ℤ), ↑↑n = ↑n := by sorry

This theorem states that for every integer `n`, if we cast `n` to a complex number via an intermediate cast to a real number (i.e., `↑↑n`), it will yield the same result as directly casting `n` to a complex number (i.e., `↑n`). In other words, the process of casting an integer to a complex number is the same, irrespective of whether we first cast it to a real number or not.

For every integer `n`, the conversions `↑↑n` and `↑n` to complex numbers yield equal results.


/-- In the space `ι → ℝ`, the Hausdorff measure coincides exactly with the Lebesgue measure.  -/
theorem MeasureTheory.hausdorffMeasure_pi_real :
    ∀ {ι : Type u_4} [inst : Fintype ι],
      MeasureTheory.Measure.hausdorffMeasure ↑(Fintype.card ι) = MeasureTheory.volume :=
  by sorry

This theorem states that in the function space `ι → ℝ` (which represents the set of all functions from `ι` to `ℝ`), the Hausdorff measure is equivalent to the Lebesgue measure. Specifically, the equivalence holds when the Hausdorff measure is raised to the power equal to the number of elements in `ι` (denoted as `Fintype.card ι`). In mathematical terms, in an `n`-dimensional space (`n` being the cardinality of `ι`), the `n`-dimensional Hausdorff measure equals the Lebesgue measure.

In the function space `ι → ℝ`, the Hausdorff measure equals the Lebesgue measure when raised to the power of `Fintype.card ι`. That is, for any `ι` of cardinality `n`, the `n`-dimensional Hausdorff measure equals the Lebesgue measure.


/-- The property of being `C^n`, initially defined in terms of the Fréchet derivative, can be
reformulated in terms of the one-dimensional derivative.  -/
theorem contDiff_iff_iteratedDeriv :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {F : Type u_2} [inst_1 : NormedAddCommGroup F]
      [inst_2 : NormedSpace 𝕜 F] {f : 𝕜 → F} {n : ℕ∞},
      ContDiff 𝕜 n f ↔
        (∀ (m : ℕ), ↑m ≤ n → Continuous (iteratedDeriv m f)) ∧
          ∀ (m : ℕ), ↑m < n → Differentiable 𝕜 (iteratedDeriv m f) :=
  by sorry

The theorem `contDiff_iff_iteratedDeriv` states that for any function `f` from a nontrivially normed field `𝕜` to a normed add commutative group `F`, under the normed space structure, and for any `n` in extended natural numbers (i.e., the set of natural numbers union infinity), the function `f` is continuously differentiable up to order `n` if and only if two conditions are met:
1. For every natural number `m` less than or equal to `n`, the `m`-th iterated derivative of `f` is a continuous function.
2. For every natural number `m` strictly less than `n`, the `m`-th iterated derivative of `f` is differentiable at every point.

In other words, the property of being continuously differentiable up to order `n` can be reformulated in terms of conditions involving the iterated one-dimensional derivative.

A function from a nontrivially normed field to a normed add commutative group is continuously differentiable up to order n if and only if all its iterated derivatives of order less than n are continuous and differentiable at every point.


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

This theorem states that for any set `s` and `t` of some type `α`, the difference of `s` with the intersection of `t` and `s` is equal to the difference of `s` and `t`. That is, removing the elements that both `s` and `t` have from `s` is the same as just removing the elements of `t` from `s`. In mathematical notation, this is denoted as $s \setminus (t \cap s) = s \setminus t$.

The theorem asserts that for any set `s` and `t` of type `α`, their set difference `s \ (t ∩ s)` equals `s \ t`.


theorem BoxIntegral.Prepartition.iUnion_disjUnion :
    ∀ {ι : Type u_1} {I : BoxIntegral.Box ι} {π₁ π₂ : BoxIntegral.Prepartition I}
      (h : Disjoint (BoxIntegral.Prepartition.iUnion π₁) (BoxIntegral.Prepartition.iUnion π₂)),
      BoxIntegral.Prepartition.iUnion (BoxIntegral.Prepartition.disjUnion π₁ π₂ h) =
        BoxIntegral.Prepartition.iUnion π₁ ∪ BoxIntegral.Prepartition.iUnion π₂ :=
  by sorry

This theorem states that for any given type `ι`, and any box `I` of this type, given two prepartitions `π₁` and `π₂` of this box which are disjoint (meaning their intersection is the bottom element in the lattice), the union of the two prepartitions is equal to the union of the individual sets covered by `π₁` and `π₂`. This essentially demonstrates that the operation of "disjoint union" on prepartitions coincides with the usual set theoretic union operation when applied to the sets they cover.

For any type `ι` and disjoint partitions `π₁` and `π₂` of a box `I` of type `ι`, the union of `π₁ ⊎ π₂` equal the union of `π₁` and `π₂` as sets.


theorem Set.vadd_mem_vadd_set :
    ∀ {α : Type u_2} {β : Type u_3} [inst : VAdd α β] {s : Set β} {a : α} {b : β}, b ∈ s → a +ᵥ b ∈ a +ᵥ s := by sorry

The theorem `Set.vadd_mem_vadd_set` states that for any types `α` and `β` with a vector addition operation (`VAdd α β`), any set `s` of elements of type `β`, and any elements `a` of type `α` and `b` of type `β`, if `b` is an element of `s`, then the result of vector adding `a` and `b` (`a +ᵥ b`) is an element of the set resulting from vector adding `a` to every element of `s` (`a +ᵥ s`).

If `a` is an element of type `α`, `b` is an element of set `s` of type `β`, and `β` has vector addition, then `a +ᵥ b` is an element of `a +ᵥ s`.


theorem SimpleGraph.coe_finsetWalkLength_eq :
    ∀ {V : Type u} (G : SimpleGraph V) [inst : DecidableEq V] [inst_1 : SimpleGraph.LocallyFinite G] (n : ℕ) (u v : V),
      ↑(SimpleGraph.finsetWalkLength G n u v) = {p | SimpleGraph.Walk.length p = n} :=
  by sorry

The theorem `SimpleGraph.coe_finsetWalkLength_eq` states that for any simple graph `G` of vertices of type `V` (where `V` has decidable equality and `G` is locally finite), and for any two vertices `u` and `v` in `G` and a natural number `n`, the set of all walks from `u` to `v` of length `n` (as a subset of the type of all walks) is equal to the set of all walks `p` such that the length of `p` is `n`. This means that the function `SimpleGraph.finsetWalkLength` correctly computes the set of walks of a given length between two vertices in a simple, locally finite graph.

For any simple graph of decidably equalvertices and finite degree, the set of walks of length n between two vertices equals the set of walks of length n from the first vertex to the second vertex.


theorem catalan_eq_centralBinom_div : ∀ (n : ℕ), catalan n = Nat.centralBinom n / (n + 1) := by sorry

This theorem states that for all natural numbers `n`, the `n`-th Catalan number is equal to the `n`-th central binomial coefficient divided by `n + 1`. The Catalan numbers are defined recursively, with the `n + 1`-th Catalan number being the sum of the product of the `i`-th and `(n - i)`-th Catalan numbers for all `i` in the range from 0 to `n`. On the other hand, the `n`-th central binomial coefficient is defined as the number of ways to choose `n` items from a set of `2n` items.

The `n`-th Catalan number equals the `n`-th central binomial coefficient divided by `n + 1`.


theorem RingQuot.mul_quot :
    ∀ {R : Type uR} [inst : Semiring R] (r : R → R → Prop) {a b : R},
      { toQuot := Quot.mk (RingQuot.Rel r) a } * { toQuot := Quot.mk (RingQuot.Rel r) b } =
        { toQuot := Quot.mk (RingQuot.Rel r) (a * b) } :=
  by sorry

This theorem, `RingQuot.mul_quot`, states that for any semiring `R` and any binary relation `r` on `R`, the product of two quotient elements created by `Quot.mk` (which constructs a new quotient type), where the original elements are `a` and `b` from `R`, is equal to the quotient element created from the product `a * b` in `R`. In simple terms, it shows that multiplication in the original semiring `R` corresponds to multiplication in the quotient ring determined by the relation `r`.

For any semiring `R` and binary relation `r` on `R`, `Quot.mk (a : R) (b : R) * Quot.mk (c : R) (d : R) = Quot.mk (a * c) (b * d)` in the quotient ring determined by `r`.


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

The theorem `Mathlib.Data.Finset.Preimage._auxLemma.1` states that for any types `α` and `β`, a function `f` from `α` to `β`, a `Finset` `s` of type `β`, and a proof `hf` that `f` is injective on the preimage of `s`, and for any element `x` of type `α`, `x` is in the preimage of `s` under `f` if and only if the image of `x` under `f` is in `s`. This theorem essentially relates the membership of an element in the preimage of a set to the membership of its image in the original set.

For any injective function `f` from type `α` to type `β`, and `Finset` `s` of type `β`, an element `x` of type `α` is in the preimage of `s` under `f` if and only if `f(x)` is in `s`.


/-- seeing `ℝ≥0∞` as `Real` does not change their sum, unless one of the `ℝ≥0∞` is infinity  -/
theorem ENNReal.toReal_sum :
    ∀ {α : Type u_1} {s : Finset α} {f : α → ENNReal},
      (∀ a ∈ s, f a ≠ ⊤) → (Finset.sum s fun a => f a).toReal = Finset.sum s fun a => (f a).toReal :=
  by sorry

This theorem states that for any finite set `s` of elements of type `α` and any function `f` from `α` to the extended nonnegative real numbers (usually denoted [0, ∞]), if no element in `s` is mapped to infinity by `f`, then the sum of the images of the elements of `s` under `f` (interpreted as real numbers) is equal to the real number corresponding to the sum of the images of the elements of `s` under `f` (interpreted as extended nonnegative real numbers). In other words, viewing extended nonnegative real numbers as real numbers does not alter the sum of a set of such numbers, provided none of them are infinity.

For any finite set `s` of real numbers and function `f` from real numbers to [0, ∞] such that `f(x)` is finite for all `x` in `s`, the sum of the images of `s` under `f` as real numbers equals the sum of the images of `s` under `f` as extended nonnegative real numbers.


/-- The angle between a vector and a positive multiple of a vector.  -/
theorem InnerProductGeometry.angle_smul_right_of_pos :
    ∀ {V : Type u_1} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] (x y : V) {r : ℝ},
      0 < r → InnerProductGeometry.angle x (r • y) = InnerProductGeometry.angle x y :=
  by sorry

This theorem, named `InnerProductGeometry.angle_smul_right_of_pos`, asserts that the undirected angle between any given vector `x` and a scaled version `r • y` of another vector `y`, is the same as the undirected angle between `x` and `y`, given that the scaling factor `r` is positive. This holds for any vectors `x` and `y` in an inner product space over the real numbers, where the inner product space is equipped with a normed add commutative group structure.

For any vectors `x` and `y` in an inner product space over the real numbers with a positive scaling factor `r`, the angle between `x` and `r•y` is equal to the angle between `x` and `y`.


theorem Complex.cosh_conj : ∀ (x : ℂ), Complex.cosh ((starRingEnd ℂ) x) = (starRingEnd ℂ) (Complex.cosh x) := by sorry

The theorem `Complex.cosh_conj` states that for any complex number `x`, the complex hyperbolic cosine of the conjugate of `x` is equal to the conjugate of the complex hyperbolic cosine of `x`. In other words, the complex hyperbolic cosine function commutes with complex conjugation. This can be expressed in mathematical notation as: for all $x \in \mathbb{C}$, $\cosh(\overline{x}) = \overline{\cosh(x)}$.

The complex hyperbolic cosine function commutes with complex conjugation, i.e., for all complex numbers x, $\cosh(\overline{x}) = \overline{\cosh(x)}$.


theorem Flag.chain_le : ∀ {α : Type u_1} [inst : LE α] (s : Flag α), IsChain (fun x x_1 => x ≤ x_1) ↑s := by sorry

The theorem `Flag.chain_le` states that for any type `α` equipped with a less than or equal to relation, and for any set `s` of type `Flag α`, `s` is a chain with respect to the less than or equal to relation. In other words, for all pairs of elements `x` and `y` in `s`, either `x` is less than or equal to `y`, or `y` is less than or equal to `x`. Thus, `s` satisfies the property defined by `IsChain`.

For any set `s` of type `Flag α` in a type `α` equipped with a total order, `s` is a chain with respect to the order relation.


/-- If the additive supports of `f` and `g` are finite, then the sum of `f i + g i`
equals the sum of `f i` plus the sum of `g i`. -/
theorem finsum_add_distrib :
    ∀ {α : Type u_1} {M : Type u_5} [inst : AddCommMonoid M] {f g : α → M},
      Set.Finite (Function.support f) →
        Set.Finite (Function.support g) → (finsum fun i => f i + g i) = (finsum fun i => f i) + finsum fun i => g i :=
  by sorry

This theorem states that for any given types `α` and `M`, with `M` being an additive commutative monoid, and any two functions `f` and `g` from `α` to `M`, if both the additive supports of `f` and `g` are finite, then the total sum over all `i` of `f(i) + g(i)` is equal to the sum of `f(i)` for all `i` added to the sum of `g(i)` for all `i`. In other words, the sum of the combined function `f + g` over its finite support is equal to the sum of `f` over its finite support added to the sum of `g` over its finite support. This is analogous to the distributive property in arithmetic.

For additive commutative monoids M and functions f and g from type α to M with finite additive supports, the sum of (f + g) over their supports equals the sum of f over the supports plus the sum of g over the supports.


theorem ZMod.val_le : ∀ {n : ℕ} [inst : NeZero n] (a : ZMod n), ZMod.val a ≤ n := by sorry

The theorem `ZMod.val_le` asserts that for any non-zero natural number `n` and any integer modulo `n` (denoted `a : ZMod n`), the value of `a` (as defined by the function `ZMod.val`) is less than or equal to `n`. This means that in the context of modular arithmetic, the absolute value of an integer modulo `n` or the least natural number in its equivalence class (depending on whether `n` is zero or positive) will always be less than or equal to `n`.

For any non-zero natural number `n` and integer `a` congruent to some integer modulo `n` (denoted `a : ZMod n`), the absolute value of `a` is less than or equal to `n`.


theorem Set.iInter_const : ∀ {β : Type u_2} {ι : Sort u_4} [inst : Nonempty ι] (s : Set β), ⋂ x, s = s := by sorry

This theorem, `Set.iInter_const`, states that for any set `s` of type `β`, and for any index `ι`, the intersection over all `x` in `ι` of `s` is equal to `s` itself. Here, `ι` represents an index set and `Nonempty ι` indicates that the index set is not empty. In other words, the intersection of the set `s` with itself for all indices in a non-empty index set is the set `s` itself. This can be expressed in mathematical terms as: for any set $s$, $\bigcap_{x \in I} s = s$, where $I$ is a non-empty index set.

For any set `s` and non-empty index set `ι`, the intersection of `s` with itself over all indices in `ι` equals `s`. In mathematical notation: $\bigcap\_{x \in ι} s = s$.


theorem Filter.EventuallyEq.hasFDerivAtFilter_iff :
    ∀ {𝕜 : 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₀ f₁ : E → F} {f₀' f₁' : E →L[𝕜] F} {x : E} {L : Filter E},
      f₀ =ᶠ[L] f₁ →
        f₀ x = f₁ x → (∀ (x : E), f₀' x = f₁' x) → (HasFDerivAtFilter f₀ f₀' x L ↔ HasFDerivAtFilter f₁ f₁' x L) :=
  by sorry

This theorem states that for a given non-trivially normed field '𝕜', normed add commutative group 'E', normed space 'E' over '𝕜', normed add commutative group 'F', normed space 'F' over '𝕜', functions 'f₀' and 'f₁' from 'E' to 'F', linear maps 'f₀'' and 'f₁'' from 'E' to 'F', element 'x' of 'E', and filter 'L' on 'E', if 'f₀' and 'f₁' are eventually equal with respect to the filter 'L', 'f₀' at 'x' is equal to 'f₁' at 'x', and 'f₀'' is identical to 'f₁'' at all points, then the fact that 'f₀' is Frechet differentiable at 'x' with respect to the filter 'L' using 'f₀'' as the derivative is equivalent to 'f₁' being Frechet differentiable at 'x' with respect to the filter 'L' using 'f₁'' as the derivative. This theorem establishes a kind of continuity of differentiation under changes of the underlying function that preserve the function's value at a point and its derivative.

If functions $f\_0$ and $f\_1$ from a normed space $E$ to another normed space $F$ over a non-trivially normed field, with linear derivatives $f\_0''$ and $f\_1''$, are eventually equal with respect to a filter $L$ and have the same value and derivative at a point $x$ in $E$, then $f\_0$ is Frechet differentiable at $x$ with respect to $L$ using $f\_0''$ if and only if $f\_1$ is Frechet differentiable at $x$ with respect to $L$ using $f\_1''$.


theorem dite_eq_left_iff :
    ∀ {α : Sort u_1} {a : α} {P : Prop} [inst : Decidable P] {B : ¬P → α},
      dite P (fun x => a) B = a ↔ ∀ (h : ¬P), B h = a :=
  by sorry

This theorem states that for any type `α`, any instance `a` of `α`, a Proposition `P` and a function `B` that maps `¬P` to `α` (where `P` is a decidable proposition), the expression `dite P (fun x => a) B` is equal to `a` if and only if for every instance `h` where `¬P` holds, `B h` is equal to `a`. In other words, this theorem relates the equality of a dependent if-then-else expression (`dite`) and a certain instance of the type, to the condition that a function applied to every instance of the negation of the proposition results in that same instance.

For any type `α`, proposition `P`, instance `a` of `α`, and function `B` mapping `¬P` to `α`, `dite P (fun x => a) B` equals `a` if and only if for all `h` with `¬P h`, `B h` equals `a`.


theorem edist_add_left :
    ∀ {M : Type u} [inst : Add M] [inst_1 : PseudoEMetricSpace M] [inst_2 : IsometricVAdd M M] (a b c : M),
      edist (a + b) (a + c) = edist b c :=
  by sorry

This theorem, `edist_add_left`, states that for any type `M` that has addition defined on it (`Add M`), is a pseudo-emetric space (`PseudoEMetricSpace M`), and supports isometric addition (`IsometricVAdd M M`), the edistance (extended distance) between the result of adding some elements `a` and `b`, and the result of adding the same `a` and `c`, equals the edistance between `b` and `c`. In other words, adding a fixed element `a` to both `b` and `c` does not change their relative distance in the associated metric space. This is a property of spaces that are translationally invariant, meaning the distances between points remain the same under translation.

For any type `M` with Add, PseudoEMetricSpace, and IsometricVAdd, the edistance between `(a + b)` and `(a + c)` equals the edistance between `b` and `c` for all `a, b, c : M`.


theorem sign_eq_zero_iff :
    ∀ {α : Type u_1} [inst : Zero α] [inst_1 : LinearOrder α] {a : α}, SignType.sign a = 0 ↔ a = 0 := by sorry

This theorem states that for any type `α` which has zero element and supports linear order operations, the `SignType.sign` of an element `a` of type `α` is equal to zero if and only if the element `a` itself is zero. In other words, a value in a linearly ordered type has a sign of zero precisely when it is zero. This theorem provides a bi-directional implication relationship between a value being zero and its sign being zero.

For any linearly ordered type with a zero element, the sign of an element is zero if and only if the element is zero.


/-- Forward direction of Vitali's convergence theorem: if `f` is a sequence of uniformly integrable
functions that converge in measure to some function `g` in a finite measure space, then `f`
converge in Lp to `g`.  -/
theorem MeasureTheory.tendsto_Lp_of_tendstoInMeasure :
    ∀ {α : Type u_1} {β : Type u_2} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} [inst : NormedAddCommGroup β]
      {p : ENNReal} {f : ℕ → α → β} {g : α → β} [inst_1 : MeasureTheory.IsFiniteMeasure μ],
      1 ≤ p →
        p ≠ ⊤ →
          (∀ (n : ℕ), MeasureTheory.AEStronglyMeasurable (f n) μ) →
            MeasureTheory.Memℒp g p μ →
              MeasureTheory.UnifIntegrable f p μ →
                MeasureTheory.TendstoInMeasure μ f Filter.atTop g →
                  Filter.Tendsto (fun n => MeasureTheory.snorm (f n - g) p μ) Filter.atTop (nhds 0) :=
  by sorry

This theorem states the forward direction of Vitali's convergence theorem: if you have a sequence of functions `f` that are uniformly integrable and almost everywhere strongly measurable with respect to a finite measure `μ`, and these functions converge in measure to another function `g` (where convergence in measure is understood with respect to a filter tending towards infinity), then the sequence of functions `f` also converges in Lp to `g`. Here, Lp convergence is defined as the seminorm of the difference between the functions in the sequence and the limit function tending to 0 with respect to a filter tending towards infinity. This theorem requires the condition that `g` belongs to the Lp space for some `p` greater than or equal to 1 but less than infinity.

If a sequence of uniformly integrable and almost everywhere measurable functions converges in measure to a function `g` that belongs to the `Lp` space, then the sequence converges in `Lp` to `g`.


theorem Continuous.strictMono_of_inj_boundedOrder :
    ∀ {α : Type u} [inst : ConditionallyCompleteLinearOrder α] [inst_1 : TopologicalSpace α] [inst_2 : OrderTopology α]
      [inst_3 : DenselyOrdered α] {δ : Type u_1} [inst_4 : LinearOrder δ] [inst_5 : TopologicalSpace δ]
      [inst_6 : OrderClosedTopology δ] [inst_7 : BoundedOrder α] {f : α → δ},
      Continuous f → f ⊥ ≤ f ⊤ → Function.Injective f → StrictMono f :=
  by sorry

The theorem `Continuous.strictMono_of_inj_boundedOrder` states that for any types `α` and `δ`, where `α` is a conditionally complete linear order with a topology, order topology, and densely ordered, and `δ` is a linear order with a topology and order-closed topology, and `α` has a bounded order, given a function `f` from `α` to `δ`, if the function `f` is continuous and the image of the least element of `α` under `f` is less than or equal to the image of the greatest element of `α` under `f`, and `f` is injective, then `f` is strictly monotonic. In other words, a continuous and injective function from a bounded, densely ordered space to a linearly ordered space is strictly increasing provided it preserves the order of the bounding elements.

A continuous, injective function from a bounded, densely ordered space to a linearly ordered space with order-closed topology is strictly increasing if it maps the least element to less than or equal to the image of the greatest element.


theorem Mathlib.Topology.Category.Profinite.Nobeling._auxLemma.36 :
    ∀ {α : Type u} [inst : LinearOrder α] {a b : α}, (¬a < b) = (b ≤ a) := by sorry

This theorem, named `Mathlib.Topology.Category.Profinite.Nobeling._auxLemma.36`, states that for all types `α` endowed with a linear order and for all elements `a` and `b` of this type, the statement "not (`a` is less than `b`)" is equivalent to "`b` is less than or equal to `a`". In mathematical terms, it encapsulates the principle ¬(a < b) = (b ≤ a) in the context of any linear order.

In any linear order, the negation of `a` being less than `b` is equivalent to `b` being less than or equal to `a`.


theorem aemeasurable_of_tendsto_metrizable_ae :
    ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] [inst_1 : TopologicalSpace β]
      [inst_2 : TopologicalSpace.PseudoMetrizableSpace β] [inst_3 : MeasurableSpace β] [inst_4 : BorelSpace β]
      {ι : Type u_3} {μ : MeasureTheory.Measure α} {f : ι → α → β} {g : α → β} (u : Filter ι) [hu : Filter.NeBot u]
      [inst_5 : Filter.IsCountablyGenerated u],
      (∀ (n : ι), AEMeasurable (f n) μ) →
        (∀ᵐ (x : α) ∂μ, Filter.Tendsto (fun n => f n x) u (nhds (g x))) → AEMeasurable g μ :=
  by sorry

This theorem states that for any types `α`, `β` and `ι` where `α` is a measurable space, `β` is a topological space which is also a pseudo metrizable space, a measurable space, and a Borel space, and a measure `μ` is defined on `α`, if we have a sequence of functions `f : ι → α → β` and another function `g : α → β`, with a filter `u` on `ι` that is countably generated and not bottom, such that each function `f n` is almost everywhere measurable with respect to measure `μ`, and for almost all `x` in `α`, the function values `f n x` tend to `g x` as `n` goes to `u` (in the sense that the pre-image of any neighborhood of `g x` under `f n` is a neighborhood in `u`), then the function `g` is also almost everywhere measurable. Here, being almost everywhere measurable means that `g` coincides almost everywhere with a measurable function.

If `α` is a measurable space, `β` is a Borel space, a pseudo-metric space, and a topological space with a measure `μ`, `f : ι → α → β` is a sequence of almost everywhere measurable functions, `g : α → β` is a function, and `u` is a countably generated non-bottom filter on `ι`, such that for almost all `x` in `α`, `f n x` converges to `g x` as `n` goes to `u`, then `g` is almost everywhere measurable.


theorem Metric.measure_ball_pos :
    ∀ {X : Type u_1} [inst : PseudoMetricSpace X] {m : MeasurableSpace X} (μ : MeasureTheory.Measure X)
      [inst_1 : MeasureTheory.Measure.IsOpenPosMeasure μ] (x : X) {r : ℝ}, 0 < r → 0 < ↑↑μ (Metric.ball x r) :=
  by sorry

The theorem `Metric.measure_ball_pos` states that for any given type `X` that has a `PseudoMetricSpace` structure, a measurable space `m`, a measure `μ` on `X` that is open and positive, and any point `x` in `X`, if the radius `r` is greater than zero, then the measure of the ball centered at `x` with radius `r` is also greater than zero. In other words, if we have a positive radius, the measure of the set of all points at a distance less than the radius from a given point is also positive.

For any `PseudoMetricSpace` `X` with a `Measure` `μ` that is open and positive, given a point `x` in `X` and a positive radius `r`, the measure of the open ball `Ball x r` is also positive.


theorem ContinuousLinearMap.map_zero :
    ∀ {R₁ : Type u_1} {R₂ : Type u_2} [inst : Semiring R₁] [inst_1 : Semiring R₂] {σ₁₂ : R₁ →+* R₂} {M₁ : Type u_4}
      [inst_2 : TopologicalSpace M₁] [inst_3 : AddCommMonoid M₁] {M₂ : Type u_6} [inst_4 : TopologicalSpace M₂]
      [inst_5 : AddCommMonoid M₂] [inst_6 : Module R₁ M₁] [inst_7 : Module R₂ M₂] (f : M₁ →SL[σ₁₂] M₂), f 0 = 0 :=
  by sorry

The theorem `ContinuousLinearMap.map_zero` states that for any continuous linear map `f` from a topological module `M₁` over a semiring `R₁` to a topological module `M₂` over another semiring `R₂`, the map of zero from `M₁` (denoted `f 0`) is zero in `M₂`. Here, `σ₁₂` is a ring homomorphism from `R₁` to `R₂`, `inst_2` and `inst_4` state that `M₁` and `M₂` are topological spaces, `inst_3` and `inst_5` state that `M₁` and `M₂` are commutative monoids, and `inst_6` and `inst_7` provide the module structures of `M₁` over `R₁` and `M₂` over `R₂` respectively.

For any continuous linear map `f` from a topological module `M₁` over semiring `R₁` to a topological module `M₂` over semiring `R₂` with a ring homomorphism `σ₁₂` from `R₁` to `R₂`, `f 0 = 0` in `M₂`, where `0` denotes the additive identity in `M₁` and `M₂`.


theorem FreeAddMonoid.sumAux_eq :
    ∀ {M : Type u_4} [inst : AddMonoid M] (l : List M), FreeAddMonoid.sumAux l = List.sum l := by sorry

The theorem `FreeAddMonoid.sumAux_eq` states that for any given type `M` which is an instance of `AddMonoid`, and any list `l` of elements from `M`, the result of applying the `FreeAddMonoid.sumAux` function to `l` is equal to the result of applying the `List.sum` function to `l`. In other words, these two functions, `FreeAddMonoid.sumAux` and `List.sum`, produce the same sum for any list of elements in an additive monoid.

For any list `l` of elements in an additive monoid `M`, `FreeAddMonoid.sumAux l` equals `List.sum l`.


theorem MeasureTheory.SimpleFunc.support_eq :
    ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] [inst_1 : Zero β] (f : MeasureTheory.SimpleFunc α β),
      Function.support ↑f = ⋃ y ∈ Finset.filter (fun y => y ≠ 0) (MeasureTheory.SimpleFunc.range f), ↑f ⁻¹' {y} :=
  by sorry

The theorem `MeasureTheory.SimpleFunc.support_eq` states that for any measurable space `α` and any type `β` with a zero, given a simple function `f` mapping `α` to `β`, the support of `f` (i.e., the set of points `x` in `α` for which `f(x)` is not zero) is equal to the union of the preimage of `f` for each element `y` in the filtered set, where the filter excludes zero and operates on the range of `f`. In other words, the support of `f` is the collection of all points mapped to nonzero values by `f`.

The support of a simple function from a measurable space to a type with a zero is equal to the union of the preimages of non-zero elements under that function.


theorem Ordinal.bddAbove_iff_small : ∀ {s : Set Ordinal.{u}}, BddAbove s ↔ Small.{u, u + 1} ↑s := by sorry

The theorem `Ordinal.bddAbove_iff_small` establishes an equivalence between two conditions for a set of ordinals, which is a type representing well orders. Specifically, it states that for any set `s` of ordinals, `s` is bounded above (i.e., there exists an ordinal that is greater than or equal to every ordinal in `s`) if and only if `s` is "small". Here, "small" is a type-theoretic property that means the elements of the set `s` can be indexed by some ordinal, i.e., there exists a surjective function from an ordinal to `s`.

A set of ordinals is bounded above if and only if it is "small," meaning it can be indexed by some ordinal.


theorem AddSubgroup.zmultiples_eq_bot :
    ∀ {G : Type u_1} [inst : AddGroup G] {g : G}, AddSubgroup.zmultiples g = ⊥ ↔ g = 0 := by sorry

This theorem states that for any additive group `G` and any element `g` of `G`, the subgroup generated by `g` (i.e., the set of all integer multiples of `g`) is trivial (consists only of the additive identity, denoted by `⊥`) if and only if `g` itself is the additive identity (0). In other words, an element generates a trivial subgroup if and only if it is zero.

An element `g` in an additive group generates a trivial subgroup if and only if `g = 0`.


PerfectRing.toPerfectField

theorem PerfectRing.toPerfectField :
    ∀ (K : Type u_1) (p : ℕ) [inst : Field K] [inst_1 : ExpChar K p] [inst_2 : PerfectRing K p], PerfectField K := by
  sorry

This theorem states that for any type `K`, natural number `p`, and given `K` is a field with exponential characteristic `p` and is a perfect ring, `K` is also a perfect field. More intuitively, this theorem establishes that any perfect ring that is also a field (with a specific exponential characteristic) is necessarily a perfect field.

If a field `K` of exponential characteristic `p` is a perfect ring, then `K` is a perfect field.


theorem add_self_div_two : ∀ {α : Type u_2} [inst : LinearOrderedSemifield α] (a : α), (a + a) / 2 = a := by sorry

This theorem states that for any type `α` which is a linearly ordered semifield, dividing the sum of any element `a` from this type and itself by 2 results in the original element `a`. In mathematical terms, it expresses that $(a + a) / 2 = a$ for any element `a` in a linearly ordered semifield.

In a linearly ordered semifield, element-wise addition and division by 2 commute, i.e., `(a + a) / 2 = a` for all `a` in the semifield.


theorem Subalgebra.le_topologicalClosure :
    ∀ {R : Type u_1} [inst : CommSemiring R] {A : Type u} [inst_1 : TopologicalSpace A] [inst_2 : Semiring A]
      [inst_3 : Algebra R A] [inst_4 : TopologicalSemiring A] (s : Subalgebra R A),
      s ≤ Subalgebra.topologicalClosure s :=
  by sorry

This theorem states that for any subalgebra `s` of a topological semiring `A` over a commutative semiring `R`, `s` is subset of its topological closure. In other words, every element in the subalgebra `s` is also an element in its topological closure. This theorem holds in the context of a topological space `A` that also has a semiring structure where `R` is the ring of scalars and `A` is the ring of elements, and the semiring `A` is also a topological semiring.

Given a topological semiring `A` over a commutative semiring `R`, any subalgebra `s` of `A` is contained in its topological closure.


theorem CategoryTheory.Limits.MonoCoprod.binaryCofan_inr :
    ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] {A B : C}
      [inst_1 : CategoryTheory.Limits.MonoCoprod C] (c : CategoryTheory.Limits.BinaryCofan A B),
      CategoryTheory.Limits.IsColimit c → CategoryTheory.Mono (CategoryTheory.Limits.BinaryCofan.inr c) :=
  by sorry

The theorem `CategoryTheory.Limits.MonoCoprod.binaryCofan_inr` states that for any category `C` with a `MonoCoprod`, given any binary cofan `c` of objects `A` and `B` in `C`, if `c` is a colimit, then the second inclusion of the binary cofan, denoted by `CategoryTheory.Limits.BinaryCofan.inr c`, is a monomorphism. In category theory, a monomorphism is an injective morphism, and a colimit of a diagram is a universal cone over that diagram. The theorem connects the concepts of colimits and monomorphisms in the context of binary cofans.

In any category with a Monocoprod, the second inclusion of a binary colimit is a monomorphism.


/-- For any sum along `{0, ..., n - 1}` of a commutative-monoid-valued function, we can
verify that it's equal to a different function just by checking differences of adjacent terms.

This is a discrete analogue of the fundamental theorem of calculus. -/
theorem Finset.sum_range_induction :
    ∀ {β : Type u_4} [inst : AddCommMonoid β] (f s : ℕ → β),
      s 0 = 0 → (∀ (n : ℕ), s (n + 1) = s n + f n) → ∀ (n : ℕ), (Finset.sum (Finset.range n) fun k => f k) = s n :=
  by sorry

The theorem `Finset.sum_range_induction` states that for any function `f` and `s` from natural numbers to a type `β` that forms a commutative monoid, given that the value of `s` at `0` is the additive identity (zero), and for all natural numbers `n`, the value of `s` at `n + 1` is the sum of `s` at `n` and `f` at `n`, then for all natural numbers `n`, the sum of `f` over the set of natural numbers less than `n` (i.e., `{0, ..., n - 1}`) is equal to the value of `s` at `n`. This is a discrete version of the fundamental theorem of calculus, and the condition on `s` can be thought of as a discrete version of a definite integral from `0` to `n` of `f`.

For any commutative monoid `β` and function `f : ℕ → β` such that `s(0) = 0` and `s(n + 1) = s(n) + f(n)` for all natural numbers `n`, the sum of `f` over the range `{0, ..., n - 1}` equals `s(n)`.


theorem Sym.cons_erase :
    ∀ {α : Type u_1} {n : ℕ} [inst : DecidableEq α] {s : Sym α (Nat.succ n)} {a : α} (h : a ∈ s),
      a ::ₛ Sym.erase s a h = s :=
  by sorry

The theorem `Sym.cons_erase` states that for any type `α` with decidable equality, any `n`-th symmetric power `s` of `α` (which is a multiset of size `n+1`), and any element `a` of `α` that is in `s`, prepending `a` to the symmetric power obtained by erasing `a` from `s` yields the original symmetric power `s`. Essentially, it says that if you remove an element from a multiset and then prepend it again, you get back the original multiset.

For any type `α` with decidable equality, for any natural number `n`, and for any `a` in an `n+1`-element symmetric power `s` of `α`, the operation of erasing `a` from `s` and then adding it back results in `s`. In mathematical notation, `(s \ a) ++ {a} = s`.


theorem Matrix.invOf_eq :
    ∀ {n : Type u'} {α : Type v} [inst : Fintype n] [inst_1 : DecidableEq n] [inst_2 : CommRing α] (A : Matrix n n α)
      [inst_3 : Invertible (Matrix.det A)] [inst_4 : Invertible A], ⅟A = ⅟(Matrix.det A) • Matrix.adjugate A :=
  by sorry

This theorem states that for any type `n` representing the indices of rows and columns, and any type `α` representing the entries of a matrix, given that `n` is finite (`Fintype n`), equality on `n` is decidable (`DecidableEq n`), and `α` forms a commutative ring (`CommRing α`), if a matrix `A` of dimensions `n x n` with entries in `α` has an invertible determinant (`Invertible (Matrix.det A)`) and the matrix `A` itself is invertible (`Invertible A`), then the multiplicative inverse of the matrix `A` (represented as `⅟A`) is equal to the multiplicative inverse of the determinant of `A` (represented as `⅟(Matrix.det A)`) scaled by the adjugate of `A` (`Matrix.adjugate A`). In mathematical notation, this theorem states that $A^{-1} = \frac{1}{det(A)} \cdot adj(A)$, where $adj(A)$ is the adjugate matrix of $A$.

If `n` is a finite type, `α` is a commutative ring, `A` is an `n x n` matrix over `α` with invertible determinant and inverse, then `A^(-1) = 1 / det(A) * adj(A)`.


IsProperMap.continuous

/-- By definition, a proper map is continuous.  -/
theorem IsProperMap.continuous :
    ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {f : X → Y},
      IsProperMap f → Continuous f :=
  by sorry

This theorem states that for any two types `X` and `Y`, which have the structure of topological spaces, and for any function `f` from `X` to `Y`, if `f` is a proper map (as per the definition of properness in topology), then `f` is also continuous. In mathematical terms, this theorem is verifying that every proper map between two topological spaces is a continuous function.

Every proper map between two topological spaces is a continuous function.


theorem MvPowerSeries.coeff_add_monomial_mul :
    ∀ {σ : Type u_1} {R : Type u_2} [inst : Semiring R] (m n : σ →₀ ℕ) (φ : MvPowerSeries σ R) (a : R),
      (MvPowerSeries.coeff R (m + n)) ((MvPowerSeries.monomial R m) a * φ) = a * (MvPowerSeries.coeff R n) φ :=
  by sorry

This theorem states that for any semiring `R`, any multivariate formal power series `φ` over the index set `σ` and coefficients in `R`, and any `m`, `n` in the set of functions from `σ` to natural numbers and `a` in `R`, the coefficient of the term with exponent `m + n` in the product of the `m`th monomial (with coefficient `a`) and `φ`, is equal to `a` times the `n`th coefficient of `φ`. In mathematical terms, it means that the coefficient of `x^(m + n)` in the multiplication of a monomial `a * x^m` and a power series `φ(x)` is `a` times the coefficient of `x^n` in `φ(x)`.

For any semiring `R`, multivariate formal power series `φ` over index set `σ` with coefficients in `R`, and `a` in `R` and functions `m, n : σ -> Nat`, the coefficient of `x^(m + n)` in the product of `a * x^m` and `φ(x)` equals `a * φ^n(x)`, where `φ^n(x)` denotes the `n`th coefficient of `φ(x)` with respect to `x`.


theorem Filter.Tendsto.sup_nhds :
    ∀ {L : Type u_1} [inst : TopologicalSpace L] {α : Type u_3} {l : Filter α} {f g : α → L} {x y : L} [inst_1 : Sup L]
      [inst_2 : ContinuousSup L],
      Filter.Tendsto f l (nhds x) →
        Filter.Tendsto g l (nhds y) → Filter.Tendsto (fun i => f i ⊔ g i) l (nhds (x ⊔ y)) :=
  by sorry

This theorem states that for any type `L` that is a topological space and equipped with an operation `⊔` (supremum), and for any functions `f` and `g` from a type `α` to `L`, if `f` tends to `x` and `g` tends to `y` with respect to a filter `l` (i.e., as we take values from `l`, `f` gets closer to `x` and `g` gets closer to `y`), then the function which for each input `i` in `α` takes the supremum of `f(i)` and `g(i)` also tends towards the supremum of `x` and `y` with respect to the same filter `l`. This holds under the condition that `L` is a continuous sup space, meaning that the supremum operation is continuous.

Let `(L, ⊔)` be a continuous sup space, and given functions `f, g: α -> L` from a type `α` to `L`, if `f` converges to `x` and `g` converges to `y` with respect to a filter `l`, then the function `i => ⊔(f i, g i)` converges to `⊔(x, y)` with respect to `l`.


theorem MeasureTheory.Measure.restrict_union :
    ∀ {α : Type u_2} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} {s t : Set α},
      Disjoint s t → MeasurableSet t → μ.restrict (s ∪ t) = μ.restrict s + μ.restrict t :=
  by sorry

This theorem relates to measure theory in the field of mathematics. It states that for any set of elements of type `α` (with `α` having an associated measurable space and measure), if two subsets `s` and `t` are disjoint (meaning the infimum, or greatest lower bound, of the two sets is the bottom element) and if the set `t` is measurable, then the measure of the union of `s` and `t` (restricted to the elements in `s` union `t`) is equal to the sum of the measures of `s` and `t`, each restricted to their own elements. This theorem captures the intuitive idea of the measure of the union of two disjoint, measurable sets being the sum of the individual measures.

Given measurable sets `s` and `t` with no elements in common (disjoint), the measure of their union equals the sum of their individual measures.


theorem Hyperreal.infinitePos_mul_of_infiniteNeg_not_infinitesimal_neg :
    ∀ {x y : ℝ*}, Hyperreal.InfiniteNeg x → ¬Hyperreal.Infinitesimal y → y < 0 → Hyperreal.InfinitePos (x * y) := by
  sorry

The theorem states that for any two hyperreal numbers `x` and `y`, if `x` is negative infinite (meaning it is less than all real numbers), `y` is not infinitesimal (meaning its standard part is not zero), and `y` is less than zero, then the product of `x` and `y` is positive infinite (meaning it is greater than all real numbers). In other words, a product of a negative infinite hyperreal number and a negative non-infinitesimal hyperreal number is a positive infinite hyperreal number.

For any hyperreal numbers `x` and `y`, if `x` is negative infinite and `y` is a non-infinitesimal negative number, then `x * y` is positive infinite.


theorem Finset.powerset_insert :
    ∀ {α : Type u_1} [inst : DecidableEq α] (s : Finset α) (a : α),
      Finset.powerset (insert a s) = Finset.powerset s ∪ Finset.image (insert a) (Finset.powerset s) :=
  by sorry

This theorem states that for any type `α` with decidable equality, a given finite set `s` of `α` and an element `a` of `α`, the powerset of the finite set resulting from inserting `a` into `s` is equal to the union of the powerset of `s` and the image of the finite set obtained by inserting `a` into each subset of the powerset of `s`. In other words, adding a new element to a set yields a powerset that contains all subsets of the original set, both with and without the new element.

For any decidably equal type `α` and finite set `s` of `α`, the powerset of `s ∪ {a}` is equal to the set-union of the powerset of `s` and the images of each subset of `s` under the function x => x ∪ {a}.


theorem Mathlib.Algebra.Invertible.Basic._auxLemma.2 :
    ∀ {G : Type u_3} [inst : DivInvMonoid G] (a b c : G), a * (b / c) = a * b / c := by sorry

This theorem states that for any type `G` that has a division and inversion monoid structure (i.e., an algebraic structure where division and inversion operations are defined), and for any elements `a`, `b`, `c` of `G`, the product of `a` and the result of `b` divided by `c` is equal to the result of `a` multiplied by `b` divided by `c`. In mathematical notation, this is saying that for all `a`, `b`, `c` in `G`, we have `a * (b / c) = a * b / c`.

For all `a`, `b`, `c` in a type `G` with division and inversion monoid structure, `a * (b / c) = a * b / c`.


theorem Mathlib.Algebra.Module.Submodule.Lattice._auxLemma.2 :
    ∀ {S : Type u_4} {M : Type u_5} [inst : Zero M] [inst_1 : SetLike S M] [self : ZeroMemClass S M] (s : S),
      (0 ∈ s) = True :=
  by sorry

This theorem, `Mathlib.Algebra.Module.Submodule.Lattice._auxLemma.2`, states that for any SetLike structure `S` (a structure that behaves like a set) over a type `M` which has a zero element, and any element `s` of type `S` within the context where `S` is a `ZeroMemClass` (a class with a property that zero is in the set), the statement that "zero is an element of `s`" is always true.

For any SetLike structure over a type with a zero element, zero is an element of every such structure where zero is a member.


theorem nnnorm_eq_zero : ∀ {E : Type u_6} [inst : NormedAddGroup E] {a : E}, ‖a‖₊ = 0 ↔ a = 0 := by sorry

This theorem states that for any type `E` that is a normed add group, the non-negative norm (`‖a‖₊`) of an element `a` from `E` is equal to zero if and only if the element `a` itself is zero. In other words, in a normed add group, an element has zero norm if and only if it is the zero element.

In a normed add group, the element of zero norm is equivalent to the zero element.


/-- The product `x * r`, `r : ℚ`, `r ≠ 0`, is a Liouville number with exponent `p` if and only if
`x` satisfies the same condition.  -/
theorem LiouvilleWith.mul_rat_iff : ∀ {p x : ℝ} {r : ℚ}, r ≠ 0 → (LiouvilleWith p (x * ↑r) ↔ LiouvilleWith p x) := by
  sorry

The theorem `LiouvilleWith.mul_rat_iff` states that for any real numbers `p` and `x`, and any rational number `r` not equal to zero, the product `x * r` is a Liouville number with exponent `p` if and only if `x` itself is a Liouville number with the same exponent `p`. A Liouville number with exponent `p` is defined as a real number `x` for which there exists a real number `C` such that for infinitely many natural numbers `n` (acting as denominators), there exists an integer `m` (acting as numerator) such that `x` is not equal to `m/n` and the absolute value of the difference between `x` and `m/n` is less than `C / n^p`.

For real numbers `x` and `p`, `x` is a Liouville number with exponent `p` if and only if `x * r` is a Liouville number with exponent `p` for any non-zero rational number `r`.


theorem neg_le_sub_iff_le_add :
    ∀ {α : Type u} [inst : AddCommGroup α] [inst_1 : LE α]
      [inst_2 : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] {a b c : α}, -b ≤ a - c ↔ c ≤ a + b :=
  by sorry

This theorem, `neg_le_sub_iff_le_add`, states that for any type `α` that is an additive commutative group and has a less than or equal to (`LE`) order, and for any three elements `a`, `b`, `c` of type `α`, the inequality `-b ≤ a - c` is equivalent to `c ≤ a + b`. Specifically, it means that subtracting `c` from `a` and then ensuring the result is greater or equal to negative `b` is the same as adding `b` to `a` and ensuring the result is greater or equal to `c`. This theorem showcases an important property of ordered additive commutative groups.

For any additive commutative group with a `LE` order, the inequality `-b ≤ a - c` is equivalent to `c ≤ a + b`.


theorem Subtype.coind_injective :
    ∀ {α : Sort u_4} {β : Sort u_5} {f : α → β} {p : β → Prop} (h : ∀ (a : α), p (f a)),
      Function.Injective f → Function.Injective (Subtype.coind f h) :=
  by sorry

The theorem `Subtype.coind_injective` states that for any types `α` and `β`, any function `f : α → β`, and any property `p` of type `β → Prop` such that `p` holds for all `f(a)` where `a` is of type `α`, if the function `f` is injective (meaning that whenever `f(x) = f(y)`, it implies `x = y`), then the function `Subtype.coind f h` is also injective. Here, `Subtype.coind f h` is a function that maps each element of type `α` to a subtype (a subset of a given type) of type `β` satisfying the property `p`, constructed by applying `f` to the element of type `α`.

If `f : α → β` is an injective function and `p (β) : Prop` holds for all `f(a)` in `α`, then `Subtype.coind f h` is an injective function from `α` to the collection of subtypes of `β` satisfying `p`.


theorem Function.support_smul_subset_right :
    ∀ {α : Type u_1} {R : Type u_2} {M : Type u_5} [inst : Zero M] [inst_1 : SMulZeroClass R M] (f : α → R) (g : α → M),
      Function.support (f • g) ⊆ Function.support g :=
  by sorry

The theorem `Function.support_smul_subset_right` states that for any two functions `f : α → R` and `g : α → M`, where `R` is a scalar multiplication zero class and `M` has a zero element, the support (set of points where the function is non-zero) of the scalar multiplication of `f` and `g` (represented as `f • g`) is a subset of the support of the function `g`. In other words, any element in the domain `α` for which `f • g` is non-zero must also be an element for which `g` is non-zero.

The support of the scalar multiplication of two functions `f : α → R` and `g : α → M` is contained in the support of `g`, where `R` is a scalar multiplication zero class and `M` has a zero element. In other words, for all `x ∈ α`, if `f • g(x) ≠ 0`, then `g(x) ≠ 0`.


theorem Polynomial.monic_multiset_prod_of_monic :
    ∀ {R : Type u} {ι : Type y} [inst : CommSemiring R] (t : Multiset ι) (f : ι → Polynomial R),
      (∀ i ∈ t, Polynomial.Monic (f i)) → Polynomial.Monic (Multiset.prod (Multiset.map f t)) :=
  by sorry

The theorem `Polynomial.monic_multiset_prod_of_monic` states that for any type `R`, given a commutative semiring structure on `R`, and any other type `ι`, if we have a multiset `t` of type `ι` and a function `f` from `ι` to `Polynomial R`, then if every polynomial `f i` for `i` in `t` is monic (i.e., its leading coefficient is 1), then the polynomial obtained by taking the product of the multiset obtained by mapping `f` over `t` is also monic. In other words, the product of a collection of monic polynomials is itself a monic polynomial.

Given a commutative semiring `R`, a multiset `t` of indices `ι`, and a function `f` mapping each index `i` in `t` to a monic polynomial `f i` in `Polynomial R`, the product of `f i` for all `i` in `t` is a monic polynomial in `Polynomial R`.


theorem nhds_eq_uniformity :
    ∀ {α : Type ua} [inst : UniformSpace α] {x : α}, nhds x = Filter.lift' (uniformity α) (UniformSpace.ball x) := by
  sorry

This theorem states that for any type `α` equipped with a uniform space structure and any element `x` of `α`, the neighborhood filter at `x` is equal to the lift via the uniformity filter of `α` of the ball centered at `x`. In other words, the set of all neighborhoods of `x` is obtained by transforming the uniformity filter on `α` using the function that maps each set to the set of all points in `α` that are close to `x` according to the given set.

For any uniform space `(α, υ)` and `x ∈ α`, the neighborhood filter of `x` is equal to the lift of the ball `B(x, r)` centered at `x` through the uniformity filter `υ`.


theorem WithTop.le_of_add_le_add_left :
    ∀ {α : Type u} [inst : Add α] {a b c : WithTop α} [inst_1 : LE α]
      [inst_2 : ContravariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1], a ≠ ⊤ → a + b ≤ a + c → b ≤ c :=
  by sorry

The theorem `WithTop.le_of_add_le_add_left` states that for any type `α` with addition (`Add α`), an order (`LE α`), and a contravariant class - where addition of any two elements is less than or equal to the sum of two other elements - if we have three elements `a`, `b`, and `c` of the type `α` extended with `⊤` (`WithTop α`), and `a` is not top (`⊤`), then if `a + b` is less than or equal to `a + c`, it follows that `b` is less than or equal to `c`. This is essentially a property of 'cancellation' for addition in this context, resembling the property of the integers.

If `α` is a type with an order and additions, and `a, b, c` are elements of `α` with `a ≠ ⊤`, then `a + b ≤ a + c` implies `b ≤ c`.


Commute.map

theorem Commute.map :
    ∀ {F : Type u_1} {M : Type u_2} {N : Type u_3} [inst : Mul M] [inst_1 : Mul N] {x y : M} [inst_2 : FunLike F M N]
      [inst_3 : MulHomClass F M N], Commute x y → ∀ (f : F), Commute (f x) (f y) :=
  by sorry

The theorem `Commute.map` states that for any types `F`, `M`, and `N`, given multiplication operations on `M` and `N`, any two elements `x` and `y` of `M` that commute, a function-like from `M` to `N` (`FunLike F M N`), and a multiplication homomorphism from `M` to `N` (`MulHomClass F M N`), the image of the commuting elements under any function `f` of type `F` will also commute. In other words, the property of commuting is preserved under the mapping `f`.

Given types `M` and `N`, multiplication operations on `M` and `N`, a function-like `F` from `M` to `N`, a multiplication homomorphism `h` from `M` to `N`, and commuting elements `x` and `y` in `M`, `h(x * y) = h(y * x)`.


theorem Int.add_emod_self_left : ∀ {a b : ℤ}, (a + b) % a = b % a := by sorry

This theorem states that for any two integers `a` and `b`, the result of adding `b` to `a` and then taking the modulus of this sum with respect to `a` is equal to the result of taking the modulus of `b` with respect to `a`. In mathematical terms, it says that `(a + b) mod a` is equal to `b mod a` for all integers `a` and `b`.

For all integers `a` and `b`, `(a + b) % a` equals `b % a`. Here, `%` denotes the modulo operation.


theorem Nat.dvd_add_right : ∀ {a b c : ℕ}, a ∣ b → (a ∣ b + c ↔ a ∣ c) := by sorry

This theorem states that for any three natural numbers `a`, `b`, and `c`, if `a` divides `b`, then `a` divides `b + c` if and only if `a` divides `c`. This sets a necessary and sufficient condition for `a` to divide the sum of `b` and `c` based on the divisibility of `a` and `c`. In mathematical terms, we write this as "a | b implies (a | (b + c) iff a | c)".

A natural number `a` divides the sum `b + c` of natural numbers `b` and `c` if and only if `a` divides `c` (i.e., `a | b -> a | (b + c) <-> a | c`).


/-- **Alias** of the reverse direction of `ENNReal.coe_le_coe`. -/
theorem ENNReal.coe_le_coe_of_le : ∀ {r q : NNReal}, r ≤ q → ↑r ≤ ↑q := by sorry

This theorem states that for any two nonnegative real numbers `r` and `q`, if `r` is less than or equal to `q`, then the real number corresponding to `r` is also less than or equal to the real number corresponding to `q`. This is essentially the converse direction of the theorem `ENNReal.coe_le_coe`.

If `r` is a nonnegative real number and `r <= q` for some nonnegative real number `q`, then the real number representation of `r` is less than or equal to the real number representation of `q`.


/-- **Alias** of the reverse direction of `ENat.coe_toNat_eq_self`. -/
theorem ENat.coe_toNat : ∀ {n : ℕ∞}, n ≠ ⊤ → ↑(ENat.toNat n) = n := by sorry

This theorem, referred to as an alias of the reverse direction of `ENat.coe_toNat_eq_self`, asserts that for any extended natural number `n` (represented as `ℕ∞`, where `∞` signifies infinity), provided that `n` is not equal to `∞`, the natural number obtained by converting `n` using the function `ENat.toNat` and then coercing back to an extended natural number yields the original extended natural number `n`. In other words, if `n` is a finite extended natural number, its conversion to a regular natural number and back to an extended natural number is a lossless operation.

For all finite extended natural numbers `n`, `ENat.toNat (ENat.coeToNat n) = n`.


/-- `sinh` is strictly monotone.  -/
theorem Real.sinh_strictMono : StrictMono Real.sinh := by sorry

This theorem states that the real hyperbolic sine function, denoted as `sinh`, is strictly monotone. In other words, if `a` and `b` are real numbers such that `a < b`, then `sinh(a) < sinh(b)`. This means that as you move from left to right on the real number line, the values of the `sinh` function strictly increase.

The real hyperbolic sine function is strictly increasing.


theorem IntermediateField.exists_algHom_of_splits_of_aeval :
    ∀ {F : Type u_1} {E : Type u_2} {K : Type u_3} [inst : Field F] [inst_1 : Field E] [inst_2 : Field K]
      [inst_3 : Algebra F E] [inst_4 : Algebra F K],
      (∀ (s : E), IsIntegral F s ∧ Polynomial.Splits (algebraMap F K) (minpoly F s)) →
        ∀ {x : E} {y : K}, (Polynomial.aeval y) (minpoly F x) = 0 → ∃ φ, φ x = y :=
  by sorry

This theorem states that for any three fields `F`, `E`, and `K`, where `F` is a field of scalars for both `E` (via an algebra structure) and `K` (via another algebra structure), if every element `s` in `E` is integral over `F`, and its minimal polynomial over `F` splits into linear factors over `K` under the mapping induced by the `F` to `K` algebra structure, then for any element `x` in `E` and any element `y` in `K` such that `y` is a root of the minimal polynomial of `x` over `F`, there exists an algebra homomorphism `φ` from `E` to `K` mapping `x` to `y`. Essentially, this theorem provides a condition under which we can construct an algebra homomorphism between two fields that sends a specific element in the source field to a specific element in the target field.

Given fields `F`, `E`, and `K` with `F` being a common subfield of `E` and `K` as scalars, if every element in `E` is integral over `F` with a minimal polynomial splitting linearly over `K`, then there exists an algebra homomorphism from `E` to `K` mapping any element in `E` to a root of its minimal polynomial in `K`.


/-- Any category with finite products and equalizers has all finite limits.

See <https://stacks.math.columbia.edu/tag/002O>.
 -/
theorem CategoryTheory.Limits.hasFiniteLimits_of_hasEqualizers_and_finite_products :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasFiniteProducts C]
      [inst_2 : CategoryTheory.Limits.HasEqualizers C], CategoryTheory.Limits.HasFiniteLimits C :=
  by sorry

This theorem states that for any category `C`, if `C` has finite products and equalizers, then `C` has all finite limits. In other words, the presence of finite products and equalizers is sufficient to guarantee the existence of all finite limits in the category. This is a result in category theory, a branch of mathematics that deals with abstract algebraic structures. For more details, you can refer to the link provided, which leads to an entry in the Stacks Math Project.

In any category with finite products and equalizers, all finite limits exist.


theorem Submonoid.pow_mem :
    ∀ {M : Type u_5} [inst : Monoid M] (S : Submonoid M) {x : M}, x ∈ S → ∀ (n : ℕ), x ^ n ∈ S := by sorry

This theorem states that for any given type `M` equipped with a monoid structure, any submonoid `S` of `M`, and any element `x` from `M` that belongs to `S`, the result of raising `x` to the power of any natural number `n` will also belong to `S`. In mathematical terms, if `S` is a submonoid of a monoid `M`, and `x` is some element of `S`, then `x^n` for any natural number `n` is also an element of `S`.

If `S` is a submonoid of the monoid `M`, then for all `x ∈ S` and natural number `n`, `x^n ∈ S`.


theorem Array.mem_def : ∀ {α : Type u_1} (a : α) (as : Array α), a ∈ as ↔ a ∈ as.data := by sorry

This theorem, `Array.mem_def`, states that for any type α and for any instance `a` of the type `α` and any array `as` of the type `α`, `a` is a member of `as` if and only if `a` is a member of the underlying data of `as`. Essentially, it equates membership in the array with membership in the array's data.

For any type α and array as of type α, an element a is in the array as if and only if a is in the underlying data of as.


theorem inv_lt' :
    ∀ {α : Type u} [inst : Group α] [inst_1 : LT α]
      [inst_2 : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x < x_1]
      [inst_3 : CovariantClass α α (Function.swap fun x x_1 => x * x_1) fun x x_1 => x < x_1] {a b : α},
      a⁻¹ < b ↔ b⁻¹ < a :=
  by sorry

The theorem `inv_lt'` is stated as follows in natural language: For all elements `a` and `b` of a group `α`, which is equipped with a multiplication operation and a less-than relation, and for which both the multiplication operation and its swapped version are covariant with this less-than relation, the reciprocal of `a` is less than `b` if and only if the reciprocal of `b` is less than `a`. In other words, in such a group, the order of inverses (reciprocals) reverses the order of the original elements.

In a group equipped with a covariant multiplication and less-than relation, the order of inverses is the reverse of the order of the original elements with respect to the less-than relation.


theorem Submonoid.powers_le :
    ∀ {M : Type u_1} [inst : Monoid M] {n : M} {P : Submonoid M}, Submonoid.powers n ≤ P ↔ n ∈ P := by sorry

This theorem, `Submonoid.powers_le`, states that for any type `M` equipped with a monoid structure, any element `n` of `M`, and any submonoid `P` of `M`, the submonoid generated by `n` (i.e., the set of all powers of `n`) is a subset of `P` if and only if `n` is an element of `P`. In other words, in any monoid, an element generates a submonoid that is contained within another submonoid if and only if the element is a member of the second submonoid.

In a monoid, an element generates a submonoid contained within another if and only if the element is a member of that submonoid.


Finset.Nonempty.product

theorem Finset.Nonempty.product :
    ∀ {α : Type u_1} {β : Type u_2} {s : Finset α} {t : Finset β}, s.Nonempty → t.Nonempty → (s ×ˢ t).Nonempty := by
  sorry

This theorem states that for any two non-empty sets `s` and `t` of any types `α` and `β` respectively, the product set `s ×ˢ t` is also non-empty. In other words, if we have at least one element in each of the two sets, then there will be at least one ordered pair in the product set created by combining `s` and `t`.

For any non-empty sets `s` of type `α` and `t` of type `β`, the product set `s ×ˢ t` is non-empty.


theorem convexHull_pair :
    ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : OrderedSemiring 𝕜] [inst_1 : AddCommMonoid E] [inst_2 : Module 𝕜 E]
      (x y : E), (convexHull 𝕜) {x, y} = segment 𝕜 x y :=
  by sorry

The `convexHull_pair` theorem states that for any ordered semiring `𝕜`, and any type `E` that is both an additive commutative monoid and a `𝕜`-module, and for any two elements `x` and `y` of `E`, the convex hull of the set containing just `x` and `y` is exactly the segment between `x` and `y`. In other words, the smallest convex set that contains both `x` and `y` is the set of all points that can be obtained by taking a convex combination of `x` and `y`.

Given an ordered semiring 𝕜, an additive commutative monoid and 𝕜-module E, the convex hull of {x, y} ⊆ E equals the line segment between x and y.


theorem isLUB_iSup :
    ∀ {α : Type u_1} {ι : Sort u_5} [inst : CompleteLattice α] {f : ι → α}, IsLUB (Set.range f) (⨆ j, f j) := by sorry

This theorem, `isLUB_iSup`, states that for any type `α` that forms a complete lattice and for any function `f` from some type `ι` to `α`, the least upper bound (LUB) of the range of `f` is the supremum of the function `f` over all `j` in `ι`. In other words, the least upper bound of the set of all possible outputs of `f` is exactly the supremum of the outputs of `f`.

For any complete lattice `α` and function `f` from a type `ι` to `α`, the LUB of `f`'s range equals the supremum of `f` over all elements in `ι`.


theorem Mathlib.RingTheory.WittVector.Frobenius._auxLemma.5 :
    ∀ {b : Prop} (α : Sort u_1) [i : Nonempty α], (α → b) = b := by sorry

This theorem from the Mathlib's Ring Theory, specifically related to Witt Vectors and the Frobenius function, states that for any proposition `b` and any sort `α` (which is nonempty), the function type from `α` to `b` is equal to `b`. In other words, if there exists at least one element of type `α`, then a function that takes any `α` as input and returns a `b` is essentially equivalent to `b` itself.

For any nonempty sort `α` and proposition `b`, the type of functions from `α` to `b` is equivalent to `b`.


theorem Finset.sum_smul :
    ∀ {R : Type u_3} {M : Type u_4} {ι : Type u_5} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
      {f : ι → R} {s : Finset ι} {x : M}, (Finset.sum s fun i => f i) • x = Finset.sum s fun i => f i • x :=
  by sorry

The theorem `Finset.sum_smul` states that for any type `R` equipped with a semiring structure, any type `M` equipped with an additively commutative monoid structure and a module structure over `R`, a function `f` from a type `ι` to `R`, a finite set `s` of type `ι`, and an element `x` of type `M`, the scalar multiplication of the sum of the function `f` applied to all elements in `s` by `x` is equal to the sum over `s` of the scalar multiplication of `x` by `f i` for each element `i` in `s`. In mathematical terms, it states that $\left(\sum_{i \in s} f(i)\right) \cdot x = \sum_{i \in s} (f(i) \cdot x)$, where the sum is over a finite set `s`.

For any semiring `R`, additively commutative monoid `M` with an `R`-module structure, function `f` from a type `ι` to `R`, finite set `s` of type `ι`, and element `x` of type `M`, we have $\sum\_{i \in s} (f(i) \cdot x) = (\sum\_{i \in s} f(i)) \cdot x$.


theorem csSup_le_csSup :
    ∀ {α : Type u_1} [inst : ConditionallyCompleteLattice α] {s t : Set α},
      BddAbove t → Set.Nonempty s → s ⊆ t → sSup s ≤ sSup t :=
  by sorry

This theorem states that for any type `α` that forms a conditionally complete lattice and for any two sets `s` and `t` of type `α`, if `t` is bounded above, and `s` is not empty, and every element of `s` is also an element of `t` (i.e., `s` is a subset of `t`), then the supremum (least upper bound) of `s` is less than or equal to the supremum of `t`. In simpler terms, the least upper bound of a non-empty subset of a bounded set does not exceed the least upper bound of the whole set.

Let `α` be a conditionally complete lattice, `s` and `t` be non-empty sets of type `α`, and `t` be bounded above. If `s` is a subset of `t`, then the supremum of `s` is less than or equal to the supremum of `t`.


theorem Finmap.keys.proof_1 :
    ∀ {α : Type u_1} {β : α → Type u_2} (s : Finmap β), Multiset.Nodup (Multiset.keys s.entries) := by sorry

The theorem `Finmap.keys.proof_1` states that for every `Finmap`, which maps keys of any type `α` to elements of a type `β` defined by α, the multiset of keys extracted from its entries does not contain any duplicates. In other words, the multiset of keys, obtained by mapping each entry of the `Finmap` to its key, satisfies the property `Multiset.Nodup`, meaning that each key appears at most once.

For every Finmap of type `α →β`, the multiset of keys (Image of the Finmap under the `Finmap.key` function) is a multiset of distinct elements.