/-- A point belongs to the closure of `s` iff its infimum distance to this set vanishes.  -/
theorem Metric.mem_closure_iff_infDist_zero :
    ∀ {α : Type u} [inst : PseudoMetricSpace α] {s : Set α} {x : α},
      Set.Nonempty s → (x ∈ closure s ↔ Metric.infDist x s = 0) :=
  by sorry

This theorem states that for any type `α` equipped with a pseudo metric space structure, for any set `s` of `α`, and for any point `x` of `α`, if the set `s` is nonempty, then the point `x` belongs to the closure of the set `s` if and only if the infimum distance of the point `x` to the set `s` is zero. In other words, a point is in the closure of a set if its minimum distance to the set is zero, provided the set is nonempty. The closure of a set is the smallest closed set containing the set. The infimum distance is the smallest possible distance between a point and a set in a pseudo metric space.

For any pseudo metric space `(α, d)` and nonempty set `s ∈ α`, a point `x ∈ α` belongs to the closure of `s` if and only if the infimum distance `��բ(x, s) = 0`.


Embedding.codRestrict

theorem Embedding.codRestrict :
    ∀ {X : Type u} {Y : Type v} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {e : X → Y},
      Embedding e → ∀ (s : Set Y) (hs : ∀ (x : X), e x ∈ s), Embedding (Set.codRestrict e s hs) :=
  by sorry

The theorem `Embedding.codRestrict` states that for any two types `X` and `Y`, with each having a topological space structure, and given a function `e` from `X` to `Y` that is an embedding, for any set `s` of `Y` such that every image of `e` is in `s`, the function obtained by restricting the codomain of `e` to `s` is also an embedding. In other words, if `e` is an embedding, then the function that sends each element `x` in `X` to the element in `s` corresponding to `e(x)` (with a proof that `e(x)` is indeed in `s`), is also an embedding.

If `e: X → Y` is an embedding of topological spaces `X` and `Y`, then the restriction of `e` to the image of `e` is also an embedding from `X` to the subspace of `Y` consisting of the images of points in `X`.


AnalyticOn.differentiableOn

theorem AnalyticOn.differentiableOn :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {F : Type v} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {f : E → F}
      {s : Set E}, AnalyticOn 𝕜 f s → DifferentiableOn 𝕜 f s :=
  by sorry

The theorem `AnalyticOn.differentiableOn` states that for any nontrivially normed field `𝕜`, normed add commutative groups `E` and `F`, and a function `f` from `E` to `F`, if `f` is analytic on a set `s` of `E`, then `f` is also differentiable on the same set `s`. In other words, in the context of these algebraic structures, being analytic implies being differentiable.

If `f` is an analytic function from a normed additive commutative group `E` to another normed additive commutative group `F` over a nontrivially normed field, then `f` is differentiable on the domain where it is analytic.


Filter.Tendsto.abs

theorem Filter.Tendsto.abs :
    ∀ {α : Type u_1} {G : Type u_2} [inst : TopologicalSpace G] [inst_1 : LinearOrderedAddCommGroup G]
      [inst_2 : OrderTopology G] {l : Filter α} {f : α → G} {a : G},
      Filter.Tendsto f l (nhds a) → Filter.Tendsto (fun x => |f x|) l (nhds |a|) :=
  by sorry

The theorem `Filter.Tendsto.abs` states that for any types `α` and `G`, where `G` is equipped with a topological space structure, a linear ordered additive commutative group structure, and an order topology, given a filter `l` on `α`, a function `f` from `α` to `G`, and a point `a` in `G`, if `f` tends to `a` along `l` (i.e., for every neighborhood of `a` in `G`, the preimage under `f` of that neighborhood is a neighborhood in `l`), then the absolute value function applied to `f`, i.e., `|f(x)|`, also tends to `|a|` along `l`. In other words, this theorem asserts that the limit of the absolute value of a function is the absolute value of the limit of the function, under the conditions described.

If a filter on a space converges to a point in a topological group under a function, then the absolute value of the function converges to the absolute value of the point under the filter.


theorem MulSalemSpencer.le_mulRothNumber :
    ∀ {α : Type u_2} [inst : DecidableEq α] [inst_1 : Monoid α] {s t : Finset α},
      MulSalemSpencer ↑s → s ⊆ t → s.card ≤ mulRothNumber t :=
  by sorry

The theorem `MulSalemSpencer.le_mulRothNumber` asserts that for any type `α` which has decidable equality and is a monoid, and for any finite sets `s` and `t` of `α`, if `s` is a multiplicative Salem-Spencer set (i.e., for any distinct elements `a`, `b`, and `c` in `s`, if `a * b = c * c`, then `a = b`) and `s` is a subset of `t`, then the cardinality of `s` is less than or equal to the multiplicative Roth number of `t`. The multiplicative Roth number of a finite set is defined as the size of its largest multiplicative Salem-Spencer subset.

For any finite subset `s` of a monoid `α` with decidable equality that is a multiplicative Salem-Spencer set, the size of `s` is bounded above by the multiplicative Roth number of any larger finite subset of `α` containing `s`.


theorem finSuccEquiv_succ : ∀ {n : ℕ} (m : Fin n), (finSuccEquiv n) (Fin.succ m) = some m := by sorry

This theorem states that for any natural number `n` and any value `m` in the finite sequence `Fin n`, applying the function `Fin.succ` to `m` and then the equivalence function `finSuccEquiv n` will yield `some m`. In other words, it asserts that the `finSuccEquiv n` function correctly identifies the successor of a `Fin n` value as its equivalent in the `Option (Fin n)` set. This is essentially a form of mapping between a finite set of size `n+1` and an optional finite set of size `n`.

For any natural number `n` and `Fin n` value `m`, `Fin.succ m = some (finSuccEquiv n m)`.


theorem AddLECancellable.tsub_lt_self :
    ∀ {α : Type u_1} [inst : CanonicallyLinearOrderedAddCommMonoid α] [inst_1 : Sub α] [inst_2 : OrderedSub α]
      {a b : α}, AddLECancellable a → 0 < a → 0 < b → a - b < a :=
  by sorry

The theorem `AddLECancellable.tsub_lt_self` states that, for any type `α` that is a canonically linearly ordered additive commutative monoid and also has a subtraction operation which is ordered, if an element `a` of this type is "addition-left-`≤`-cancellable" (meaning that if `a + b ≤ a + c` then it must be the case that `b ≤ c`), and if `a` and `b` are both positive (greater than `0`), then the subtraction `a - b` is strictly less than `a`. In a more mathematical language, given an element `a` such that `a + b ≤ a + c` implies `b ≤ c`, and two positive elements `a` and `b`, then `a - b < a`.

If `α` is a canonically linearly ordered additive commutative monoid with ordered subtraction, `a` and `b` are positive elements, and `a + b ≤ a + c` implies `b leq c`, then `a - b < a`.


theorem ProperCone.toPointedCone_injective :
    ∀ {𝕜 : Type u_1} [inst : OrderedSemiring 𝕜] {E : Type u_2} [inst_1 : AddCommMonoid E] [inst_2 : TopologicalSpace E]
      [inst_3 : Module 𝕜 E], Function.Injective ProperCone.toPointedCone :=
  by sorry

The theorem `ProperCone.toPointedCone_injective` asserts that for any ordered semiring `𝕜` and any type `E` that is an additively commutative monoid, a topological space and a module over `𝕜`, the function `ProperCone.toPointedCone` is injective. This means that for these conditions, if two proper cones in the context are mapped to the same pointed cone via the function `ProperCone.toPointedCone`, then the two initial proper cones must have been the same.

For any ordered semiring `𝕜`, additively commutative monoid, topological space, and `𝕜`-module `E`, the function `ProperCone.toPointedCone` maps distinct proper cones to distinct pointed cones.


theorem Real.hasStrictDerivAt_sqrt : ∀ {x : ℝ}, x ≠ 0 → HasStrictDerivAt Real.sqrt (1 / (2 * Real.sqrt x)) x := by sorry

The theorem `Real.hasStrictDerivAt_sqrt` states that for all real numbers `x` that are not equal to zero, the function `Real.sqrt` (which computes the square root of a real number) has a strict derivative at the point `x`. The derivative of `Real.sqrt` at `x` is given by the expression `1 / (2 * Real.sqrt x)`. In mathematical notation, this can be written as: if $x \neq 0$, then $\frac{d}{dx}\sqrt{x} = \frac{1}{2\sqrt{x}}$. This means that the rate of change of the square root function at point `x` is one half the reciprocal of the square root of `x`.

For all non-zero real numbers x, the square root function has a strict derivative equal to 1 / (2 * √x).


theorem LinearMap.restrictScalars_injective :
    ∀ (R : Type u_1) {S : Type u_6} {M : Type u_9} {M₂ : Type u_11} [inst : Semiring R] [inst_1 : Semiring S]
      [inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid M₂] [inst_4 : Module R M] [inst_5 : Module R M₂]
      [inst_6 : Module S M] [inst_7 : Module S M₂] [inst_8 : LinearMap.CompatibleSMul M M₂ R S],
      Function.Injective ↑R :=
  by sorry

The theorem `LinearMap.restrictScalars_injective` states that for any type `R`, and given types `S`, `M`, and `M₂`, along with a host of conditions on these types (such as `R` and `S` being semirings, `M` and `M₂` being additive commutative monoids, `M` and `M₂` being `R`-modules and `S`-modules, and the compatibility of scalar multiplication on these modules), the function that maps an element from `R` to its corresponding element in the larger type space is injective. In other words, no two different elements in `R` would map to the same element in the larger type space, given these conditions.

Given semirings R and S, additive commutative monoids and R-modules M and M₂, and S-modules M and M₂ with compatible scalar multiplications, the restriction of scalars map from R to M and from R to M₂ are injective.


theorem Matrix.adjugate_transpose :
    ∀ {n : Type v} {α : Type w} [inst : DecidableEq n] [inst_1 : Fintype n] [inst_2 : CommRing α] (A : Matrix n n α),
      Matrix.transpose (Matrix.adjugate A) = Matrix.adjugate (Matrix.transpose A) :=
  by sorry

This theorem states that for any square matrix `A` with elements from a commutative ring `α`, the transpose of the adjugate of `A` equals the adjugate of the transpose of `A`. The theorem assumes the size `n` of the matrix `A` is a finite type and has decidable equality. In mathematical terms, if `A` is a square matrix, then `(adj(A))^T = adj(A^T)`, where `adj` denotes the adjugate of a matrix, `T` denotes the transpose of the matrix, and `^` denotes exponentiation.

For any square matrix A over a commutative ring of finite type with decidable equality, the transpose of the adjugate of A is equal to the adjugate of the transpose of A. (In mathematical notation: adj(A)^T = adj(A^T))


theorem Nat.ord_compl_pos : ∀ {n : ℕ} (p : ℕ), n ≠ 0 → 0 < n / p ^ (Nat.factorization n) p := by sorry

This theorem, `Nat.ord_compl_pos`, states that for any non-zero natural number `n` and any prime number `p`, the quotient of `n` divided by `p` raised to the power of the multiplicity of `p` in the prime factorization of `n` (i.e., `p ^ (Nat.factorization n) p`) is strictly positive. In other words, after dividing `n` by the largest power of `p` that divides `n`, the result is always greater than zero.

For any non-zero natural number `n` and prime number `p`, the quotient of `n` divided by `p` raised to the power of the multiplicity of `p` in the prime factorization of `n` is positive.


theorem ball_add_zero :
    ∀ {E : Type u_1} [inst : SeminormedAddCommGroup E] (δ : ℝ) (s : Set E),
      Metric.ball 0 δ + s = Metric.thickening δ s :=
  by sorry

This theorem, `ball_add_zero`, states that for any subset `s` of a seminormed additive commutative group `E` and any real number `δ`, the sum of the ball of radius `δ` centered at the origin and the set `s` is equal to the `δ`-thickening of the set `s`. In other words, the set of all points within a distance `δ` from the origin plus any element in `s` is the same as the set of all points that are less than `δ` distance away from some point in `s`.

For any seminormed additive commutative group E, subset s, and real number δ, the set {x : E | ∥x∥ ≤ δ ∨ x ∈ s} equals the set {x : E | ∥x - o ∥ ≤ δ}, where o is the origin of E.


theorem List.sum_singleton : ∀ {M : Type u_5} [inst : AddZeroClass M] {a : M}, List.sum [a] = a := by sorry

This theorem states that for any type `M` that has an addition operation and a zero element (a member of the class `AddZeroClass`), the sum of a list that contains only a single element `a` (of type `M`) is `a` itself. In other words, if you have a list with just one element `a`, the sum of all elements in the list is just `a`.

For any type `M` in the `AddZeroClass` with addition `+` and zero element `0`, the sum of a list `[a]` containing a single element `a` of type `M` is equal to `a`, i.e., `sum [a] = a`.


theorem Ordinal.le_of_dvd : ∀ {a b : Ordinal.{u_4}}, b ≠ 0 → a ∣ b → a ≤ b := by sorry

The theorem `Ordinal.le_of_dvd` states that for any two ordinals `a` and `b` of the same type, if `b` is not equal to zero and `a` divides `b`, then `a` is less than or equal to `b`. In mathematical terms, this theorem asserts that if we have a well-order `b` that is nonzero and another well-order `a` which divides `b`, then `a` cannot be strictly larger than `b`.

If `a` is an ordinal that divides a non-zero ordinal `b` of the same type, then `a` is less than or equal to `b`.


theorem Nat.choose_succ_right_eq : ∀ (n k : ℕ), Nat.choose n (k + 1) * (k + 1) = Nat.choose n k * (n - k) := by sorry

The theorem `Nat.choose_succ_right_eq` states that for all natural numbers `n` and `k`, the binomial coefficient of `n` choose `(k + 1)`, multiplied by `(k + 1)`, is equal to the binomial coefficient of `n` choose `k`, multiplied by `(n - k)`. In mathematical notation, this is expressed as $\binom{n}{k+1} \cdot (k+1) = \binom{n}{k} \cdot (n - k)$. This theorem is a relation between consecutive binomial coefficients.

The theorem asserts that for all natural numbers n and k, the product of the binomial coefficient of n choose k+1 and k+1 equals the product of the binomial coefficient of n choose k and (n-k). In other words, $\binom{n}{k+1} \cdot (k+1) = \binom{n}{k} \cdot (n-k)$.


theorem CategoryTheory.ComposableArrows.map'.proof_3 :
    ∀ {n : ℕ} (i j : ℕ) (hij : autoParam (i ≤ j) _auto✝) (hjn : autoParam (j ≤ n) _auto✝¹),
      { val := i, isLt := ⋯ } ≤ { val := j, isLt := ⋯ } :=
  by sorry

This theorem, `CategoryTheory.ComposableArrows.map'.proof_3`, asserts that within the context of Category Theory, for any given natural number `n` and any two natural numbers `i` and `j`, given the automatic parameters `hij` and `hjn` which ensure `i` is less than or equal to `j` and `j` is less than or equal to `n` respectively, then the object with value `i` and an undisclosed property `isLt` is less than or equal to the object with value `j` and the same undisclosed property `isLt`. The automatic parameters here are not employed during type class resolution but only during elaboration. The proof of this theorem, however, is not provided in this context.

For any natural numbers `i`, `j`, and `n`, if `i ≤ j` and `j ≤ n`, then the object with value `i` is less than or equal to the object with value `j` in the category theory context.


CPolynomialAt.analyticAt

theorem CPolynomialAt.analyticAt :
    ∀ {𝕜 : Type u_1} {E : Type u_2} {F : Type u_3} [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {f : E → F} {x : E},
      CPolynomialAt 𝕜 f x → AnalyticAt 𝕜 f x :=
  by sorry

The theorem `CPolynomialAt.analyticAt` states that for any non-trivially normed field `𝕜`, normed add-commutative groups `E` and `F`, a normed space `E` over `𝕜`, a normed space `F` over `𝕜`, and a function `f` from `E` to `F`, if `f` is continuously polynomial at a point `x` in `E` (i.e., it admits a finite power series expansion around `x`), then `f` is also analytic at `x` (i.e., it admits a convergent power series expansion around `x`).

If a function `f` from a normed space `E` to another normed space `F` over a non-trivially normed field `𝕜` has a finite power series expansion around a point `x` in `E`, then `f` is analytic at `x`, meaning it has a convergent power series expansion around `x`.


theorem Polynomial.derivative_sub :
    ∀ {R : Type u} [inst : Ring R] {f g : Polynomial R},
      Polynomial.derivative (f - g) = Polynomial.derivative f - Polynomial.derivative g :=
  by sorry

The theorem `Polynomial.derivative_sub` states that for all types `R`, given a Ring structure on `R`, and for any two polynomials `f` and `g` with coefficients in `R`, the derivative of the difference of `f` and `g` is equal to the difference of the derivatives of `f` and `g`. In mathematical terms, this corresponds to the property (f - g)' = f' - g' for polynomials `f` and `g`, showing that the derivative operation in the polynomial ring respects subtraction.

For all types `R` with a Ring structure and polynomials `f` and `g` over `R`, the derivative of `(f - g)` equals `(f' - g')`.


theorem Filter.tendsto_atTop_add_nonneg_left' :
    ∀ {α : Type u_3} {β : Type u_4} [inst : OrderedAddCommMonoid β] {l : Filter α} {f g : α → β},
      (∀ᶠ (x : α) in l, 0 ≤ f x) →
        Filter.Tendsto g l Filter.atTop → Filter.Tendsto (fun x => f x + g x) l Filter.atTop :=
  by sorry

The theorem `Filter.tendsto_atTop_add_nonneg_left'` states that, given a preordered additive commutative monoid `β` and a filter `l` over a type `α`, if a function `f` from `α` to `β` is nonnegative almost everywhere (i.e., everywhere except on a set of measure zero) with respect to the filter `l`, and if a function `g` from `α` to `β` tends towards infinity with respect to the filter `l`, then the function `(fun x => f x + g x)` that adds the values of `f` and `g` also tends towards infinity with respect to the filter `l`. This reflects the intuition that adding a nonnegative function to a function that tends to infinity should result in a function that also tends to infinity.

If a non-negative function adds to a function tending to infinity almost everywhere with respect to a filter, then the sum also tends to infinity with respect to that filter.


theorem Polynomial.card_support_eq_zero :
    ∀ {R : Type u} [inst : Semiring R] {p : Polynomial R}, (Polynomial.support p).card = 0 ↔ p = 0 := by sorry

This theorem states that for any semiring `R` and any polynomial `p` over `R`, the cardinality (i.e., the number of elements) of the support of `p` is zero if and only if `p` is the zero polynomial. Here, the support of a polynomial `p` is defined as the set of all `n` such that the `n`-th power of `X` has a non-zero coefficient in `p`.

For any semiring `R` and polynomial `p` over `R`, the polynomial `p` is the zero polynomial if and only if the cardinality of the support of `p` is zero.


theorem CategoryTheory.MonoidalCategory.whiskerLeft_iff :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.MonoidalCategory C] {X Y : C}
      (f g : X ⟶ Y),
      CategoryTheory.MonoidalCategory.whiskerLeft (𝟙_ C) f = CategoryTheory.MonoidalCategory.whiskerLeft (𝟙_ C) g ↔
        f = g :=
  by sorry

This theorem deals with category theory in the context of a monoidal category. It states that, for any type `C` equipped with both a category structure and a monoidal category structure, and for objects `X` and `Y` in `C`, if two morphisms `f` and `g` from `X` to `Y` are such that the whisker left operation with the identity morphism on `C` applied to `f` equals the same operation applied to `g`, then `f` and `g` must be equal. The whisker left operation is a type of operation in category theory that modifies a morphism in a certain way.

In a monoidal category, if two morphisms from object X to object Y have equal whisker left compositions with the identity morphism, then they are equal.


theorem hasCompactSupport_def :
    ∀ {α : Type u_2} {β : Type u_4} [inst : TopologicalSpace α] [inst_1 : Zero β] {f : α → β},
      HasCompactSupport f ↔ IsCompact (closure (Function.support f)) :=
  by sorry

This theorem states that for any function `f` from a type `α` to a type `β`, where `α` has a topological space structure and `β` has a zero element, the function `f` has compact support if and only if the closure of the support of the function `f` is compact. In other words, a function `f` is said to have compact support when the smallest closed set that contains all the points `x` for which `f(x)` is not zero, is a compact set. Here, a set is compact if for every nontrivial filter that contains the set, there exists a point in the set such that every set in the filter intersects with every neighborhood of this point.

A function from a compact space to a space with a zero element has compact support if and only if its support's closure is a compact set.


IsUnit.star

theorem IsUnit.star : ∀ {R : Type u} [inst : Monoid R] [inst_1 : StarMul R] {a : R}, IsUnit a → IsUnit (star a) := by
  sorry

The theorem `IsUnit.star` states that for any type `R` that is a `Monoid` and also has a `StarMul` structure, if an element `a` of `R` is a unit (i.e., it has a two-sided inverse), then its star (obtained by applying the `star` operation from the `StarMul` structure) is also a unit. In other words, the `star` operation preserves the property of being a unit in the monoid.

If `R` is a monoid with a `StarMul` structure and `a` is a unit in `R`, then the star of `a` (obtained from the `star` operation in `StarMul`) is also a unit in `R`.


theorem Set.zero_subset : ∀ {α : Type u_2} [inst : Zero α] {s : Set α}, 0 ⊆ s ↔ 0 ∈ s := by sorry

This theorem states that for any type `α` that has a zero element (denoted as `0`), and for any set `s` of elements of type `α`, the set containing only the zero element is a subset of `s` if and only if the zero element is an element of `s`. In other words, it states a condition under which a set containing only the zero element is considered a subset of another set in terms of membership of the zero element in the other set. This theorem essentially connects the notion of subset with the notion of element membership for the specific case of the zero element.

For any type `α` with a zero element `0`, the set `{0}` is a subset of `s` if and only if `0` is an element of `s`.


theorem IsFractionRing.exists_reduced_fraction :
    ∀ (A : Type u_4) [inst : CommRing A] [inst_1 : IsDomain A] [inst_2 : UniqueFactorizationMonoid A] {K : Type u_5}
      [inst_3 : Field K] [inst_4 : Algebra A K] [inst_5 : IsFractionRing A K] (x : K),
      ∃ a b, IsRelPrime a ↑b ∧ IsLocalization.mk' K a b = x :=
  by sorry

The theorem `IsFractionRing.exists_reduced_fraction` states that for every element `x` in the field of fractions `K` of an integral domain `A` (with `A` possessing the structure of a commutative ring, an integral domain, and a unique factorization monoid), there exists a pair of elements `a` and `b` such that `a` and `b` are relatively prime (i.e., any common divisor of `a` and `b` is a unit) and the fraction `a/b` represented by the localization map equals `x`. In other words, every element of the field of fractions can be represented as a fraction of two relatively prime elements from the integral domain.

For every element in the field of fractions of a commutative ring that is an integral domain and a unique factorization monoid, there exists a pair of relatively prime elements whose localization gives that element.


theorem LocallyConstant.comap_injective :
    ∀ {X : Type u_1} {Y : Type u_2} {Z : Type u_3} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y]
      (f : X → Y), Continuous f → Function.Surjective f → Function.Injective (LocallyConstant.comap f) :=
  by sorry

The theorem `LocallyConstant.comap_injective` states that for any three types `X`, `Y`, and `Z` with `X` and `Y` being topological spaces, given a function `f` from `X` to `Y` that is continuous and surjective (i.e., for every element in `Y`, there exists an element in `X` such that the function `f` maps this element of `X` to the element of `Y`), the function `LocallyConstant.comap f`, which is the precomposition of any function with `f`, is injective (i.e., if `LocallyConstant.comap f` maps two elements of its domain to the same value, then these two elements were the same to begin with).

If `f: X → Y` is a continuous and surjective function between topological spaces `X` and `Y`, then `LocallyConstant.comap f` is an injective function.


theorem AddLECancellable.lt_add_of_tsub_lt_left :
    ∀ {α : Type u_1} [inst : PartialOrder α] [inst_1 : AddCommSemigroup α] [inst_2 : Sub α] [inst_3 : OrderedSub α]
      {a b c : α}, AddLECancellable b → a - b < c → a < b + c :=
  by sorry

The theorem `AddLECancellable.lt_add_of_tsub_lt_left` states that for any type `α`, under the conditions that `α` is a partially ordered set, an additive commutative semigroup, and has an ordered subtraction operation, and given three elements `a`, `b`, `c` in `α` such that `b` satisfies the `AddLECancellable` property (i.e., for all elements `x` and `y` in `α`, `b + x ≤ b + y` implies `x ≤ y`), if `a - b` is less than `c`, then `a` is less than `b + c`. This theorem represents a property of addition and subtraction in the context of ordered additive structures.

If `α` is an ordered additive semigroup with an ordered subtraction operation, and `b` is AddLECancellable, then `a < b + c` given `a - b < c`.


theorem Finset.insertNone.proof_1 : ∀ {α : Type u_1} (s : Finset α), none ∉ Finset.map Function.Embedding.some s := by
  sorry

This theorem states that, for any type `α` and any finite set `s` of type `α`, the `None` value is not an element of the image of `s` under the embedding using the `some` function. In other words, when we embed each element of a finite set into the `Option α` type by wrapping it with the `Some` constructor, the `None` value is guaranteed to not be in the resulting set.

For any finite set `s` and type `α`, the image of `s` under the embedding using the `some` function is a subset of `Option α \ {None}`.


Int.ModEq.add

theorem Int.ModEq.add : ∀ {n a b c d : ℤ}, a ≡ b [ZMOD n] → c ≡ d [ZMOD n] → a + c ≡ b + d [ZMOD n] := by sorry

This theorem states that for any integers `n`, `a`, `b`, `c`, and `d`, if `a` is congruent to `b` modulo `n` and `c` is congruent to `d` modulo `n`, then the sum `a + c` is also congruent to the sum `b + d` modulo `n`. In other words, the congruence of integers modulo a certain number is preserved under addition.

If `a` is congruent to `b` (modulo `n`) and `c` is congruent to `d` (modulo `n`), then `a + c` is congruent to `b + d` (modulo `n`).


theorem Nat.log_pos : ∀ {b n : ℕ}, 1 < b → b ≤ n → 0 < Nat.log b n := by sorry

The theorem `Nat.log_pos` states that for any natural numbers `b` and `n`, if `b` is greater than 1 and `b` is less than or equal to `n`, then the logarithm of `n` in base `b` (denoted as `Nat.log b n`) is always greater than 0. In other words, the logarithm of a natural number `n` in a base `b` that is greater than 1 and less than or equal to `n`, is a positive integer.

For any natural numbers `b` greater than 1 and `n` such that `b` is less than or equal to `n`, `Nat.log b n` is a positive integer.


theorem ContinuousWithinAt.mono_of_mem :
    ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] {f : α → β} {s t : Set α}
      {x : α}, ContinuousWithinAt f t x → t ∈ nhdsWithin x s → ContinuousWithinAt f s x :=
  by sorry

The theorem `ContinuousWithinAt.mono_of_mem` states that for any two types `α` and `β` with given topological structures, a function `f` from `α` to `β`, two subsets `s` and `t` of `α`, and a point `x` in `α`, if the function `f` is continuous at the point `x` within the subset `t`, and `t` is in the neighborhood filter of `x` within `s`, then `f` is also continuous at the point `x` within the subset `s`. In other words, if we know that `f` is continuous at `x` when staying within a smaller set `t` and `t` is a part of the local neighborhood of `x` in `s`, we can infer that `f` is continuous at `x` when staying within the larger set `s`.

If a function is continuous at a point in a subset and that subset is in the neighborhood filter of that point in a larger subset, then the function is continuous at that point in the larger subset.


theorem PNat.find_min' : ∀ {p : ℕ+ → Prop} [inst : DecidablePred p] (h : ∃ n, p n) {m : ℕ+}, p m → PNat.find h ≤ m := by
  sorry

The theorem `PNat.find_min'` states that for any decidable predicate `p` on positive natural numbers (`ℕ+`), given the existence of a positive natural number `n` that satisfies the predicate `p` (notated as `p n`), and any positive natural number `m` such that `p m` holds, the function `PNat.find h`, which finds the smallest positive natural number satisfying the predicate `p`, always returns a value that is less than or equal to `m`.

For any decidable predicate `p` on positive natural numbers, if there exists a positive natural number `n` such that `p n` holds and `m` is any positive natural number with `p m` holding, then `PNat.find h` returns a value less than or equal to `m`.


/-- An element of `s` that is not an element of `erase s a` must be`a`.  -/
theorem Finset.eq_of_mem_of_not_mem_erase :
    ∀ {α : Type u_1} [inst : DecidableEq α] {s : Finset α} {a b : α}, b ∈ s → b ∉ Finset.erase s a → b = a := by sorry

This theorem states that for any type `α` equipped with a decidable equality relation, given a finite set `s` of type `α`, and any two elements `a` and `b` of type `α`, if `b` is an element of `s` and `b` is not an element of the set obtained by erasing `a` from `s`, then `b` must be equal to `a`. In other words, if an element is in the original set but is not in the set after erasing a specific element, it must be because that element is the one that was erased.

If `α` is a type with decidable equality, `s` is a finite subset of `α`, and `a, b ∈ α` with `b ∈ s` and `b ∉ s \ {a}`, then `a = b`.


theorem Matrix.PosSemidef.conjTranspose_mul_mul_same :
    ∀ {n : Type u_2} {R : Type u_3} [inst : Fintype n] [inst_1 : CommRing R] [inst_2 : PartialOrder R]
      [inst_3 : StarOrderedRing R] {A : Matrix n n R},
      Matrix.PosSemidef A →
        ∀ {m : Type u_5} [inst_4 : Fintype m] (B : Matrix n m R), Matrix.PosSemidef (Matrix.conjTranspose B * A * B) :=
  by sorry

The theorem `Matrix.PosSemidef.conjTranspose_mul_mul_same` states that for any given commutative ring `R`, with a partial order and a star operation (i.e., it is a star-ordered ring), and finite types `n` and `m`; if matrix `A` with entries in `R` of size `n × n` is positive semidefinite, then for any matrix `B` of size `n × m` with entries in `R`, the product of the conjugate transpose of `B`, `A`, and `B` is also positive semidefinite. In mathematical terms, if `A` is positive semidefinite, then so is ${B^*}AB$ for any `B`.

If `A` is a positive semidefinite `n × n` matrix over a commutative ring `R` with a partial order and a star operation, then for any `n × m` matrix `B` over `R`, the product `{B^*}AB` is also positive semidefinite.


theorem Real.add_one_lt_exp : ∀ {x : ℝ}, x ≠ 0 → x + 1 < Real.exp x := by sorry

The theorem `Real.add_one_lt_exp` asserts that for all real numbers `x`, provided `x` is not equal to zero, `x + 1` is strictly less than the exponential of `x`, denoted as `Real.exp x`. In other words, for each non-zero real number, when you increment it by 1, the result is always smaller than the exponential of the original number.

For all non-zero real numbers x, x + 1 < Real.exp x.


theorem List.Nodup.pairwise_of_forall_ne :
    ∀ {α : Type u} {l : List α} {r : α → α → Prop},
      List.Nodup l → (∀ a ∈ l, ∀ b ∈ l, a ≠ b → r a b) → List.Pairwise r l :=
  by sorry

This theorem states that for any type `α`, given a list `l` of type `α` and a binary relation `r` on `α`, if the list `l` has no duplicates (i.e., every element appears at most once in the list), and if for every distinct pair of elements `a` and `b` in `l`, `r a b` holds, then the elements of `l` are pairwise related by `r`. In other words, `r` holds for every pair of distinct elements in the list `l`.

Given a list `l` of distinct elements of type `α` and a binary relation `r` on `α`, if `r` holds between every pair of distinct elements in `l`, then `r` holds for all pairs of distinct elements in `l`.


/-- If `f : α → E` is a function such that `norm ∘ f` has a maximum along a filter `l` at a point
`c`, then the function `fun x => ‖f x + f c‖` has a maximum along `l` at `c`.  -/
theorem IsMaxFilter.norm_add_self :
    ∀ {α : Type u_1} {E : Type u_3} [inst : SeminormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {f : α → E}
      {l : Filter α} {c : α}, IsMaxFilter (norm ∘ f) l c → IsMaxFilter (fun x => ‖f x + f c‖) l c :=
  by sorry

The theorem `IsMaxFilter.norm_add_self` states that for any function `f` from an arbitrary type `α` to a seminormed add commutative group `E` over the real numbers, if the composition of the `norm` function and `f` has a maximum value at a point `c` along a filter `l`, then the function that maps `x` to the norm of the sum of `f(x)` and `f(c)` also has a maximum along the same filter `l` at the same point `c`.

If `f: α → E` is a function from type `α` to a seminormed add commutative group `E` over the real numbers, and `c ∈ α` is a point such that `∥f(c)∥ ≥ ∥f(x)∥∀x ∈ l`, then `x ↦ ∥f(x) + f(c)∥` has a maximum at `c` along filter `l`.


theorem IsPrimitiveRoot.map_of_injective :
    ∀ {M : Type u_1} {N : Type u_2} {F : Type u_6} [inst : CommMonoid M] [inst_1 : CommMonoid N] {k : ℕ} {ζ : M} {f : F}
      [inst_2 : FunLike F M N] [inst_3 : MonoidHomClass F M N],
      IsPrimitiveRoot ζ k → Function.Injective ⇑f → IsPrimitiveRoot (f ζ) k :=
  by sorry

This theorem states that if `ζ` is a primitive root of order `k` in a commutative monoid `M`, and `f` is an injective function that is a monoid homomorphism from `M` to another commutative monoid `N`, then the image of `ζ` under `f` is a primitive root of order `k` in `N`.

In other words, the property of being a primitive root is preserved under the injective homomorphism `f`.

If `ζ` is a primitive root of order `k` in a commutative monoid `M` and `f` is an injective homomorphism from `M` to a commutative monoid `N`, then `f(ζ)` is a primitive root of order `k` in `N`.


theorem Equiv.symm_comp_eq :
    ∀ {α : Sort u_1} {β : Sort u_2} {γ : Sort u_3} (e : α ≃ β) (f : γ → α) (g : γ → β), ⇑e.symm ∘ g = f ↔ g = ⇑e ∘ f :=
  by sorry

The theorem `Equiv.symm_comp_eq` states that for all types `α`, `β`, and `γ`, given an equivalence `e` between `α` and `β`, and functions `f` from `γ` to `α` and `g` from `γ` to `β`, the composition of the inverse of `e` and `g` is equal to `f` if and only if `g` is equal to the composition of `e` and `f`. This theorem essentially describes a property of function composition under equivalence transformations.

For all types α, β, γ, equivalences e between α and β, and functions f: γ -> α and g: γ -> β, if e ∘ f = g then f ∘ e⁻¹ = g.


theorem Real.hasStrictDerivAt_sin : ∀ (x : ℝ), HasStrictDerivAt Real.sin (Real.cos x) x := by sorry

This theorem states that for all real numbers `x`, the function `Real.sin`, which represents the real sine function, has a strict derivative at the point `x`. The derivative is given by `Real.cos x`, which represents the real cosine function. This means that the change in the sine function at any point `x` is best represented by the value of the cosine function at that same point, with the change becoming arbitrarily close as the difference in points approaches zero. In the mathematical notation, this would be expressed as `f'(x) = cos(x)` for `f(x) = sin(x)`.

The real sine function has a strict derivative equal to the real cosine function at every real number.


theorem ClosureOperator.closure_sup_closure_right :
    ∀ {α : Type u_1} [inst : SemilatticeSup α] (c : ClosureOperator α) (x y : α), c (x ⊔ c y) = c (x ⊔ y) := by sorry

This theorem states that for any given type `α` equipped with a semilattice (a structure with an associative, commutative, and idempotent binary operation "sup"), and for any closure operator `c` on this type, the result of applying `c` to the supremum of `x` and the closure of `y` (denoted `c (x ⊔ c y)`) is the same as the result of applying `c` to the supremum of `x` and `y` (denoted `c (x ⊔ y)`). In effect, this means that the closure of `y` under the operator `c` can be "pulled out" of the supremum operation without changing the overall result of the computation.

For any semilattice `α` and closure operator `c` on `α`, the application of `c` to the supremum of `x` and `c y` is equal to the application of `c` to the supremum of `x` and `y`. In other words, `c (x ⊔ y) = c (x ⊔ c y)`.


theorem Matroid.Base.finiteRk_of_finite :
    ∀ {α : Type u_1} {M : Matroid α} {B : Set α}, M.Base B → Set.Finite B → Matroid.FiniteRk M := by sorry

This theorem asserts that, for any type `α`, given a matroid `M` over that type and a set `B` of that type, if `B` is a base of the matroid `M` and `B` is a finite set, then the rank of that matroid `M` is finite. In other words, if we have a finite base for a matroid, it implies that the rank of the matroid is finite. Here, 'base' and 'rank' refer to the mathematical concepts from the theory of matroids.

If `M` is a matroid over type `α`, `B` is a finite base of `M`, then the rank of `M` is finite.


/-- An object in `Type u` is initial if and only if it is empty.  -/
theorem CategoryTheory.Limits.Types.initial_iff_empty :
    ∀ (X : Type u), Nonempty (CategoryTheory.Limits.IsInitial X) ↔ IsEmpty X := by sorry

This theorem states that an object in the category of types (i.e., `Type u`) is initial if and only if it is empty. In the context of category theory, an object is initial if there is precisely one morphism from it to any other object. Here, this theorem is asserting that this property for a type is equivalent to the type being empty.

A type is initial in the category of types if and only if it is empty.


theorem MvPolynomial.C_mul_monomial :
    ∀ {R : Type u} {σ : Type u_1} {a a' : R} {s : σ →₀ ℕ} [inst : CommSemiring R],
      MvPolynomial.C a * (MvPolynomial.monomial s) a' = (MvPolynomial.monomial s) (a * a') :=
  by sorry

The theorem `MvPolynomial.C_mul_monomial` states that for any type `R` forming a commutative semi-ring, any type `σ`, any `R` values `a` and `a'`, and any function `s` mapping `σ` to natural numbers, the constant polynomial with value `a` multiplied by the monomial with coefficient `a'` and exponents given by `s` is equal to the monomial with the coefficient `a * a'` and exponents given by `s`. This theorem essentially captures the distributive property of multiplication over constant and monomial polynomials in the context of multivariate polynomials.

For any commutative semi-ring type R, any type σ, and functions s from σ to natural numbers, the constant polynomial `a` multiplied by the monomial `a' × x^(s)` is equal to the monomial `(a × a') × x^(s)`, where x represents a variable of type σ.


theorem contMDiff_id :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {H : Type u_3} [inst_3 : TopologicalSpace H] {I : ModelWithCorners 𝕜 E H}
      {M : Type u_4} [inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] {n : ℕ∞}, ContMDiff I I n id :=
  by sorry

This theorem, `contMDiff_id`, states that for any nontrivially normed field `𝕜`, normed additive commutative group `E`, topological space `H`, model with corners `I` (mapping `H` into `E`), and charted space `M` with chart modelled on `H`, the identity function is continuously differentiable to any order `n` in the manifold `M` with corners `I`. Here, `n` could be any natural number or infinity (`ℕ∞`).

For any nontrivially normed field `𝕜`, normed additive commutative group `E`, topological space `H`, model with corners `I` mapping `H` into `E`, and charted space `M` with chart modelled on `H`, the identity function on `M` with corners `I` is continuously differentiable to any order `n` in the manifold `M`.


theorem ZMod.cast_nat_cast :
    ∀ {n : ℕ} {R : Type u_1} [inst : Ring R] {m : ℕ} [inst_1 : CharP R m], m ∣ n → ∀ (k : ℕ), ZMod.cast ↑k = ↑k := by
  sorry

The theorem `ZMod.cast_nat_cast` states that for any natural numbers `n` and `m`, any ring `R` of type `u_1`, and any natural number `k`, if the characteristic `m` of the ring `R` divides `n`, then casting `k` to `ZMod n` and then to `R` (using `ZMod.cast`) is the same as directly casting `k` to `R`. In mathematical notation, this can be written as `m | n -> ∀k, ZMod.cast ↑k = ↑k`, where `|` denotes "divides", `∀` is a universal quantifier meaning "for all", and `↑` denotes casting.

For any ring R of characteristic m and natural numbers n, m | n implies ZMod.cast (cast n to Nat) = cast _ (cast _ R) for all k.


theorem Nat.mul_dvd_mul_iff_left : ∀ {a b c : ℕ}, 0 < a → (a * b ∣ a * c ↔ b ∣ c) := by sorry

This theorem states that for any three natural numbers `a`, `b`, and `c`, given that `a` is greater than `0`, the product of `a` and `b` divides the product of `a` and `c` if and only if `b` divides `c`. In other words, it says that if `a` is a non-zero factor common to both sides of the divisibility relation, then it can be "cancelled out".

For natural numbers a, b, and c with a > 0, a * b | (a * c) if and only if b | c. (a * b is the product of a and b, | denotes divisibility, and b | c means b divides c.)


theorem Monoid.PushoutI.of_comp_eq_base :
    ∀ {ι : Type u_1} {G : ι → Type u_2} {H : Type u_3} [inst : (i : ι) → Monoid (G i)] [inst_1 : Monoid H]
      {φ : (i : ι) → H →* G i} (i : ι), MonoidHom.comp (Monoid.PushoutI.of i) (φ i) = Monoid.PushoutI.base φ :=
  by sorry

The theorem `Monoid.PushoutI.of_comp_eq_base` states that for any index set `ι`, a family `G : ι → Type` of monoids, a base monoid `H`, and a family `φ : (i : ι) → H →* G i` of monoid homomorphisms from `H` to each `G i`, the composition of the morphism `Monoid.PushoutI.of i` (which is a map from each indexing group into the pushout) with `φ i` is equal to the morphism `Monoid.PushoutI.base φ` (which is a map from the base monoid `H` into the pushout). In other words, each `G i` and the base `H` map to the same place in the pushout via these respective maps, up to composition with the original homomorphisms `φ`.

For any index set ι, family of monoids G : ι → Type, base monoid H, and family of monoid homomorphisms φ : (i : ι) → H →* G i, the composition of Monoid.PushoutI.of i with φ i equals Monoid.PushoutI.base φ.


theorem MeasureTheory.Filtration.memℒp_limitProcess_of_snorm_bdd :
    ∀ {Ω : Type u_1} {m : MeasurableSpace Ω} {μ : MeasureTheory.Measure Ω} {R : NNReal} {p : ENNReal} {F : Type u_5}
      [inst : NormedAddCommGroup F] {ℱ : MeasureTheory.Filtration ℕ m} {f : ℕ → Ω → F},
      (∀ (n : ℕ), MeasureTheory.AEStronglyMeasurable (f n) μ) →
        (∀ (n : ℕ), MeasureTheory.snorm (f n) p μ ≤ ↑R) →
          MeasureTheory.Memℒp (MeasureTheory.Filtration.limitProcess f ℱ μ) p μ :=
  by sorry

The theorem `MeasureTheory.Filtration.memℒp_limitProcess_of_snorm_bdd` states that, for a measure space `Ω` with measure `μ`, a nonnegative real number `R`, an extended nonnegative real number `p`, a normed additive commutative group `F` and a filtration `ℱ` of the measurable space, if we have a sequence of functions `f : ℕ → Ω → F` such that each function `f n` is almost everywhere strongly measurable with respect to measure `μ`, and the `ℒp` seminorm of each function `f n` measured with respect to `μ` is less than or equal to `R`, then the limit process of the sequence of functions `f` with respect to the filtration `ℱ` and measure `μ` is in `ℒp` space, i.e., it is almost everywhere strongly measurable and its `ℒp` seminorm is finite.

Given a measure space `(Ω, μ)`, a normed additive commutative group `F`, a filtration `ℱ`, a real number `R`, and a sequence of almost everywhere strongly measurable functions `f : ℕ → Ω → F` with `ℒp` seminorms less than `R`, the limit process of `f` with respect to `ℱ` and `μ` is an almost everywhere strongly measurable function in `ℒp(Ω, μ, F)` with a finite `ℒp` seminorm.


theorem Nat.sub_add_eq : ∀ (a b c : ℕ), a - (b + c) = a - b - c := by sorry

This theorem, `Nat.sub_add_eq`, states that for all natural numbers `a`, `b`, and `c`, the result of subtracting the sum of `b` and `c` from `a` is the same as the result of subtracting `c` from the difference of `a` and `b`. In mathematical notation, this would be expressed as `a - (b + c) = a - b - c`.

For all natural numbers `a`, `b`, and `c`, `a - (b + c) = a - b - c`.


theorem PosNum.cast_bit0 : ∀ {α : Type u_1} [inst : One α] [inst_1 : Add α] (n : PosNum), ↑(PosNum.bit0 n) = bit0 ↑n :=
  by sorry

This theorem, `PosNum.cast_bit0`, states that for any type `α` which has a defined addition and a defined "one" element, and for any positive number `n`, the result of converting the `bit0` (which duplicates the number) of `n` from `PosNum` (the type for positive numbers in Lean) to `α` is equal to the `bit0` of the converted `n`. In other words, the process of duplicating a number (using `bit0`) and then converting it to another type is the same as first converting the number to the other type and then duplicating it.

For any type `α` with addition and a one element, and for any positive number `n` in Lean's `PosNum`, the conversion of `n.bit0` to `α` is equal to the conversion of `n` to `α` followed by taking the `bit0`.


theorem SimpleGraph.connected_iff :
    ∀ {V : Type u} (G : SimpleGraph V), SimpleGraph.Connected G ↔ SimpleGraph.Preconnected G ∧ Nonempty V := by sorry

The theorem `SimpleGraph.connected_iff` states that, for any type `V` and a Simple Graph `G` on that type, `G` is connected if and only if `G` is preconnected and `V` is not empty. In terms of graph theory, a graph is considered connected if there exists a path between every pair of vertices. In this context, preconnected means that for every pair of vertices in the graph, it is possible to reach one from the other, and `Nonempty V` asserts that there exists at least one vertex in the graph.

A Simple Graph on a non-empty type is connected if and only if it is preconnected.


theorem iSup_eq_dif :
    ∀ {α : Type u_1} [inst : CompleteLattice α] {p : Prop} [inst_1 : Decidable p] (a : p → α),
      ⨆ (h : p), a h = if h : p then a h else ⊥ :=
  by sorry

This theorem, `iSup_eq_dif`, asserts that for any complete lattice type `α`, any decidable proposition `p`, and any function `a` mapping from the proposition `p` to the lattice type `α`, the supremum (`⨆`) of the function `a` over all true instances `h` of the proposition `p` is equal to the value of the function `a` at `h` if `h` is true, and otherwise is equal to the bottom element (`⊥`) of the lattice `α`. In other words, it states that the supremum of a function over a decidable proposition is determined by the value of the function at the true instances of the proposition, and is the bottom element of the lattice if the proposition is false.

For any complete lattice type `α`, decidable proposition `p`, and function `a` from `p` to `α`, the supremum of `a` over true instances of `p` equals `a(h)` for `h` true in `p`, and equals the bottom element of `α` otherwise.


theorem smul_nonneg_iff_pos_imp_nonneg :
    ∀ {α : Type u_1} {β : Type u_2} [inst : LinearOrderedRing α] [inst_1 : LinearOrderedAddCommGroup β]
      [inst_2 : Module α β] [inst_3 : PosSMulStrictMono α β] {a : α} {b : β},
      0 ≤ a • b ↔ (0 < a → 0 ≤ b) ∧ (0 < b → 0 ≤ a) :=
  by sorry

The theorem `smul_nonneg_iff_pos_imp_nonneg` states that for any types `α` and `β`, where `α` is a linearly ordered ring, `β` is a linearly ordered additive commutative group, and `β` is a module over `α` with strictly positive scalar multiplication, the scalar multiplication of `a` (an element of `α`) and `b` (an element of `β`) is non-negative if and only if when `a` is positive it implies `b` is non-negative, and `b` is positive it implies `a` is non-negative.

For any linearly ordered ring `α`, linearly ordered additive commutative group `β` with strictly positive scalar multiplication, and `a` in `α` and `b` in `β`, the scalar multiplication `a * b` is non-negative if and only if `a` is positive implies `b` is non-negative, and `b` is positive implies `a` is non-negative.


/-- If `f : X → Y` is a surjective Borel measurable map from a standard Borel space
to a topological space with second countable topology, then the preimage of a set `s`
is measurable if and only if the set is measurable.
One implication is the definition of measurability, the other one heavily relies on `X` being a
standard Borel space.  -/
theorem Measurable.measurableSet_preimage_iff_of_surjective :
    ∀ {X : Type u_3} {Y : Type u_4} [inst : MeasurableSpace X] [inst_1 : StandardBorelSpace X]
      [inst_2 : TopologicalSpace Y] [inst_3 : T2Space Y] [inst_4 : MeasurableSpace Y] [inst_5 : OpensMeasurableSpace Y]
      [inst_6 : SecondCountableTopology Y] {f : X → Y},
      Measurable f → Function.Surjective f → ∀ {s : Set Y}, MeasurableSet (f ⁻¹' s) ↔ MeasurableSet s :=
  by sorry

This theorem states that if there exists a surjective (one-to-one onto) Borel measurable function `f` mapping from a standard Borel space `X` to a topological space `Y` with a second countable topology, then the pre-image of a set `s` in `Y` under the function `f` is measurable if and only if the set `s` itself is measurable. This theorem is fundamental in measure theory and relies heavily on the property of `X` being a standard Borel space. One direction of the statement is the definition of measurability, while the other direction requires more detailed justification based on the properties of Borel spaces.

A surjective Borel measurable function from a standard Borel space to a second countable topological space preserves measurability: the preimage of any measurable set is measurable.


theorem pow_right_strictAnti :
    ∀ {R : Type u_3} [inst : StrictOrderedSemiring R] {a : R}, 0 < a → a < 1 → StrictAnti fun x => a ^ x := by sorry

The theorem `pow_right_strictAnti` states that for any strict ordered semiring `R` and for any element `a` of `R`, if `a` is positive and less than 1, then the function `f(x) = a^x` is strictly antitone. In other words, if `a` and `b` are elements of `R` such that `a < b`, then `f(b) < f(a)`.

For any strict ordered semiring `R` and strict positive element `a` in `R` less than 1, the function `f(x) = a^x` is strictly antitone, i.e., `a^b < a^a` for all `b` in `R` with `b > a`.


theorem Real.logb_abs : ∀ {b : ℝ} (x : ℝ), Real.logb b |x| = Real.logb b x := by sorry

The theorem `Real.logb_abs` states that for any real numbers `b` and `x`, the logarithm base `b` of the absolute value of `x` is equal to the logarithm base `b` of `x`. In other words, in the definition of the real logarithm `Real.logb` we have chosen, the absolute value operation doesn't affect the result of logarithm. This is similar to saying that $\log_b |x| = \log_b x$, for all real numbers `b` and `x`.

For all real numbers `b` and `x`, `Real.logb (Abs x) = Real.logb x`.


theorem SetTheory.PGame.moveLeft_nim' :
    ∀ {o : Ordinal.{u}} (i : SetTheory.PGame.LeftMoves (SetTheory.PGame.nim o)),
      SetTheory.PGame.moveLeft (SetTheory.PGame.nim o) i =
        SetTheory.PGame.nim ↑(SetTheory.PGame.toLeftMovesNim.symm i) :=
  by sorry

The theorem `SetTheory.PGame.moveLeft_nim'` states that for any ordinal 'o' and any legal left move 'i' in the game of Nim on 'o', making the move 'i' results in a game state equivalent to playing Nim on the ordinal obtained by applying the inverse of the function `toLeftMovesNim` to 'i'. In other words, it describes how the game state changes when the left player makes a move in the game of Nim.

For any ordinal o and left move i in the game of Nim, making move i is equivalent to playing Nim on the ordinal obtained by applying the inverse of `toLeftMovesNim` to i.


theorem Real.two_le_pi : 2 ≤ Real.pi := by sorry

The theorem `Real.two_le_pi` states that the number 2 is less than or equal to π, the mathematical constant representing the ratio of a circle's circumference to its diameter, in real numbers. It formalizes the numerical fact that π, approximately 3.14159265, is indeed greater than 2.

The theorem `Real.two_le_pi` asserts that 2 ≤ π in the real number system.


theorem Filter.map_swap_eq_comap_swap :
    ∀ {α : Type u} {β : Type v} {f : Filter (α × β)}, Prod.swap <$> f = Filter.comap Prod.swap f := by sorry

The theorem `Filter.map_swap_eq_comap_swap` states that for all types `α` and `β`, and for any filter `f` of pairs from `α` and `β`, mapping the `Prod.swap` function over the filter `f` is equivalent to the co-domain (comap) of the `Prod.swap` function with respect to the filter `f`. In simpler terms, it's saying the operation of swapping elements in each pair in the filter is the same whether we do it in the domain (using map) or in the co-domain (using comap).

For any filter on pairs from types `α` and `β`, mapping `Prod.swap` is equivalent to composing `Prod.swap` with the filter's comap operation.


theorem measurable_real_toNNReal : Measurable Real.toNNReal := by sorry

The theorem `measurable_real_toNNReal` states that the function `Real.toNNReal`, which converts a real number to a non-negative real number (returning `0` if the original number is less than `0`), is a measurable function. In mathematical terms, a function is said to be measurable if the preimage of any measurable set under this function is also measurable. In this case, for any measurable set of non-negative real numbers, the set of real numbers that are mapped to this set by `Real.toNNReal` is measurable.

The function `Real.toNNReal : Real → ℝ⁺` is measurable, i.e., for every measurable set `M` of non-negative real numbers, the preimage `{x : Real | Real.toNNReal x ∈ M}` is a measurable subset of the real numbers.


theorem AlgebraicGeometry.IsAffineOpen.isCompact :
    ∀ {X : AlgebraicGeometry.Scheme} {U : TopologicalSpace.Opens ↑↑X.toPresheafedSpace},
      AlgebraicGeometry.IsAffineOpen U → IsCompact ↑U :=
  by sorry

This theorem states that for any scheme `X` and an open subset `U` of the topological space associated with `X`, if `U` is affine open (meaning the open subscheme corresponding to `U` is affine), then `U` is compact. Here, a set is compact if for every nontrivial filter that contains the set, there exists an element in the set such that every set in the filter intersects every neighborhood of this element.

For any scheme `X` and an affine open subset `U` of `X`, `U` is compact.


theorem strictMono_mul_right_of_pos :
    ∀ {α : Type u} [inst : StrictOrderedSemiring α] {a : α}, 0 < a → StrictMono fun x => x * a := by sorry

The theorem `strictMono_mul_right_of_pos` states that for any strictly ordered semiring `α` and any element `a` in `α`, if `a` is greater than 0, then the function that multiplies `x` by `a` is strictly monotone. In other words, for any two elements `b` and `c` in `α`, if `b` is less than `c`, then `b * a` is less than `c * a`.

For any strictly ordered semiring `α` and element `a` in `α` with `0 < a`, the multiplication function `×` is strictly increasing: `(x₁ < x₂) → (x₁ * a < x₂ * a)`.


ZFSet.image.mk

theorem ZFSet.image.mk :
    ∀ (f : ZFSet → ZFSet) [H : PSet.Definable 1 f] (x : ZFSet) {y : ZFSet}, y ∈ x → f y ∈ ZFSet.image f x := by sorry

The theorem `ZFSet.image.mk` states that for any function `f` from ZFSet to ZFSet that is definable in the sense of PSet, and for any sets `x` and `y` in the ZFSet universe, if `y` is an element of `x`, then the image of `y` under the function `f` is an element of the image set of `x` under `f`. In other words, if $y \in x$ then $f(y) \in \text{image of } f \text{ on } x$. This is a formalization of the familiar property of image of a function in set theory.

For any function `f` from a set `x` to a set `y` in the ZFSet universe that preserves elements (i.e., `y ∋ f(y)` for all `y ∈ x`), the image of an element `y` under `f` belongs to the image set of `x` under `f`.


theorem ENNReal.biSup_add' :
    ∀ {a : ENNReal} {ι : Sort u_4} {p : ι → Prop},
      (∃ i, p i) → ∀ {f : ι → ENNReal}, (⨆ i, ⨆ (_ : p i), f i) + a = ⨆ i, ⨆ (_ : p i), f i + a :=
  by sorry

The theorem `ENNReal.biSup_add'` states that for any extended nonnegative real number 'a', and any indexed family of extended nonnegative real numbers 'f' indexed by a type 'ι', where at least one element 'i' of type 'ι' satisfies a certain property 'p', the supremum of 'f' under the constraint 'p' plus 'a' is equal to the supremum of the sum of 'f' and 'a' under the same constraint 'p'. In mathematical terms, it states that if ∃i, p(i) is true, then sup{i | p(i)} (f(i) + a) = sup{i | p(i)} f(i) + a.

For any extended nonnegative real number 'a' and indexed family 'f' of extended nonnegative real numbers indexed by type 'ι', where there exists an 'i' in 'ι' satisfying property 'p', the supremum of 'f(i) + a' under constraint 'p' equals the sum of the supremum of 'f' under constraint 'p' and 'a'.


theorem Associates.prod_coe :
    ∀ {α : Type u_1} [inst : CancelCommMonoidWithZero α] {s : Multiset { a // Irreducible a }},
      Associates.FactorSet.prod ↑s = Multiset.prod (Multiset.map Subtype.val s) :=
  by sorry

The theorem `Associates.prod_coe` states that for any type `α` that has a `CancelCommMonoidWithZero` structure and for any multiset `s` of elements `a` which satisfy the property of being irreducible, the product of `s` as an `Associates.FactorSet` is equal to the product of the multiset obtained by mapping the `Subtype.val` function over `s`. In mathematical terms, this theorem shows the consistency between the product of a `FactorSet` and the product of the corresponding multiset of irreducible elements in a commutative monoid with zero.

For any commutative monoid with zero `α` and irreducible multiset `s` of elements `a` in `α`, the product of `s` as an `Associates.FactorSet` equals the product of the multiset of `Subtype.val a` for all `a` in `s`.


theorem isClopen_iff :
    ∀ {α : Type u} [inst : TopologicalSpace α] [inst_1 : PreconnectedSpace α] {s : Set α},
      IsClopen s ↔ s = ∅ ∨ s = Set.univ :=
  by sorry

The theorem `isClopen_iff` states that for any type `α` equipped with a topology and assumed to be preconnected, and any set `s` of type `α`, the statement "The set `s` is clopen" is equivalent to "The set `s` is either empty or equal to the universal set of `α`". Here, a set is defined to be clopen if it is both closed and open in the given topological space. This theorem essentially says that in a preconnected topological space, the only clopen sets are the empty set and the entire space itself.

In a preconnected topological space, a set is clopen if and only if it is either the empty set or the universal set.


/-- Post-composition by a uniform inducing function is
a uniform inducing function for the uniform structures of uniform convergence.

More precisely, if `f : γ → β` is uniform inducing,
then `(f ∘ ·) : (α →ᵤ γ) → (α →ᵤ β)` is uniform inducing.  -/
theorem UniformFun.postcomp_uniformInducing :
    ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : UniformSpace β] [inst_1 : UniformSpace γ] {f : γ → β},
      UniformInducing f → UniformInducing (⇑UniformFun.ofFun ∘ (fun x => f ∘ x) ∘ ⇑UniformFun.toFun) :=
  by sorry

The theorem `UniformFun.postcomp_uniformInducing` states that post-composition by a uniform inducing function preserves the property of inducing a uniform structure in the context of uniform convergence. More specifically, for any types `α`, `β`, and `γ`, and given uniform spaces on `β` and `γ`, if a function `f` from `γ` to `β` is uniform inducing, then the function obtained by post-composing `f` with each function from `α` to `γ` is also uniform inducing. This new function maps from the space of uniformly continuous functions from `α` to `γ` to the space of uniformly continuous functions from `α` to `β`.

If `f` is a uniformly inducing function from a uniform space `γ` to another uniform space `β`, then the function obtained by post-composing `f` with each uniformly continuous function from `α` to `γ` is a uniformly inducing function from the space of uniformly continuous functions from `α` to `γ` to the space of uniformly continuous functions from `α` to `β`.


theorem Caratheodory.mem_minCardFinsetOfMemConvexHull :
    ∀ {𝕜 : Type u_1} {E : Type u} [inst : LinearOrderedField 𝕜] [inst_1 : AddCommGroup E] [inst_2 : Module 𝕜 E]
      {s : Set E} {x : E} (hx : x ∈ (convexHull 𝕜) s),
      x ∈ (convexHull 𝕜) ↑(Caratheodory.minCardFinsetOfMemConvexHull hx) :=
  by sorry

The theorem `Caratheodory.mem_minCardFinsetOfMemConvexHull` states that for any linear ordered field `𝕜`, any additive commutative group `E` and module `𝕜 E`, any set `s` of elements of type `E`, and any element `x` of type `E`, if `x` is an element of the convex hull of `s`, then `x` is also an element of the convex hull of the subset of `s` returned by the function `Caratheodory.minCardFinsetOfMemConvexHull`. This subset has the minimum cardinality among all subsets of `s` whose convex hull contains `x`. In other words, this theorem asserts that `x` is in the convex hull of the smallest possible subset of `s` that still includes `x` in its convex hull.

For any linear ordered field 𝕜, additive commutative group E and its module over 𝕜, any set s of elements in E, and any x in E that belongs to the convex hull of s, x is also in the convex hull of the smallest subset of s with minimum cardinality guaranteeing x's inclusion.


FundamentalGroupoid.ext

theorem FundamentalGroupoid.ext : ∀ {X : Type u} (x y : FundamentalGroupoid X), x.as = y.as → x = y := by sorry

The theorem `FundamentalGroupoid.ext` states that for any type `X`, given two elements `x` and `y` of the type `FundamentalGroupoid X`, if the `as` attribute of `x` is equal to the `as` attribute of `y`, then `x` is equal to `y`. Essentially, this theorem says that two fundamental groupoids are equal if and only if their `as` attributes are equal.

In the type of fundamental groupoids of a type X, elements with equal `as` attributes are equal.


theorem AddMonoidAlgebra.sum_single_index :
    ∀ {k : Type u₁} {G : Type u₂} [inst : Semiring k] {N : Type u_3} [inst_1 : AddCommMonoid N] {a : G} {b : k}
      {h : G → k → N}, h a 0 = 0 → Finsupp.sum (AddMonoidAlgebra.single a b) h = h a b :=
  by sorry

The theorem `AddMonoidAlgebra.sum_single_index` states that for any types `k`, `G`, and `N`, where `k` is a semiring and `N` is an additive commutative monoid, and for any elements `a` of type `G`, `b` of type `k`, and a function `h` from `G` and `k` to `N` such that `h a 0` equals to zero, the sum of `h a (f a)` over the support of `f` where `f` is the AddMonoidAlgebra.single of `a` and `b`, is equal to `h a b`. In other words, the sum over the function `h` applied to the single element created by the AddMonoidAlgebra is equal to the function `h` applied directly to the elements `a` and `b`.

For any semiring `k`, additive commutative monoid `N`, type `G`, element `a` of `G`, element `b` of `k`, and function `h` from `G` x `k` to `N` such that `h a 0 = 0`, the sum of `h (a, b)` over the support of `AddMonoidAlgebra.single a b` equals `h (a, b)`.


theorem List.prod_singleton : ∀ {M : Type u_5} [inst : MulOneClass M] {a : M}, List.prod [a] = a := by sorry

This theorem states that the product of a list containing a single element `a` is equal to `a` itself. Here, `M` is any type endowed with a multiplication operation and a special element called "one" (represented by the `MulOneClass` typeclass in Lean 4). The function `List.prod` computes the product of all elements in a list, starting from "one" and then multiplying each element in the list in order.

For any type `M` with multiplication and a multiplicative identity `one`, the product of a list containing a single element `a` of type `M` is equal to `a`.


theorem Int.lt_mul_ediv_self_add : ∀ {x k : ℤ}, 0 < k → x < k * (x / k) + k := by sorry

This theorem states that for any integers `x` and `k`, where `k` is greater than 0, `x` is less than `k` times the quotient of `x` divided by `k`, plus `k`. In mathematical terms, this can be written as `x < k * (x / k) + k` for all integers `x` and `k` where `k > 0`.

For all integers `x` and `k` with `k > 0`, `x` is less than `k` times the quotient of `x` by `k` plus `k`. Equivalently, `x < k * (x / k) + k`.


theorem InnerProductSpace.Core.inner_neg_left :
    ∀ {𝕜 : Type u_1} {F : Type u_3} [inst : RCLike 𝕜] [inst_1 : AddCommGroup F] [inst_2 : Module 𝕜 F]
      [c : InnerProductSpace.Core 𝕜 F] (x y : F), ⟪-x, y⟫_𝕜 = -⟪x, y⟫_𝕜 :=
  by sorry

This Lean theorem, `InnerProductSpace.Core.inner_neg_left`, states that for any type `𝕜` that resembles a ring, and any additive commutative group `F` that is also a `𝕜`-module, as well as any two elements `x` and `y` of `F`, the inner product of `-x` and `y` is equal to the negation of the inner product of `x` and `y`. In other words, the inner product operation in this context respects the distributivity of scalar multiplication over vector addition.

For any additive commutative group `F` that is a `𝕜`-module over a ring `𝕜`, the inner product of `-x` and `y` equals the negation of the inner product of `x` and `y`, for all `x, y ∈ F`.


theorem Subsingleton.mem_iff_nonempty :
    ∀ {α : Type u_2} [inst : Subsingleton α] {s : Set α} {x : α}, x ∈ s ↔ Set.Nonempty s := by sorry

This theorem states that for any type `α` that is a subsingleton (i.e., a type with at most one element), any set `s` of elements of type `α`, and any element `x` of type `α`, `x` is a member of `s` if and only if `s` is nonempty. Essentially, it's saying that, in the context of a subsingleton, the membership of any element in a set is equivalent to the set being nonempty.

For any subsingleton type `α`, a set `s` of type `α` has exactly one element if and only if `s` is nonempty and contains that element.


theorem Measurable.sub_const :
    ∀ {G : Type u_2} {α : Type u_3} [inst : MeasurableSpace G] [inst_1 : Sub G] {m : MeasurableSpace α} {f : α → G}
      [inst_2 : MeasurableSub G], Measurable f → ∀ (c : G), Measurable fun x => f x - c :=
  by sorry

The theorem `Measurable.sub_const` states that for any type `G` with a `MeasurableSpace` and `Sub` structure, any type `α` with a `MeasurableSpace` structure, any function `f` from `α` to `G`, and any element `c` of `G`, if `f` is a measurable function and `G` supports measurable subtraction, then the function that maps each element `x` in `α` to the difference between `f(x)` and `c` is also measurable. This essentially means that subtracting a constant from a measurable function yields another measurable function, provided the codomain of the function supports both measurable spaces and subtraction.

If `f` is a measurable function from a measurable space `α` to a measurable space `G` with subtraction, then the function `x ↦ f(x) - c` is measurable for any constant `c` in `G`.


theorem Set.pairwise_empty : ∀ {α : Type u_1} (r : α → α → Prop), Set.Pairwise ∅ r := by sorry

The theorem `Set.pairwise_empty` states that for any type `α` and any relation `r` defined on `α`, the relation `r` is pairwise on the empty set. In other words, the property that for any two distinct elements in the set, the relation `r` holds between them, is trivially true for the empty set, because there are no two distinct elements in the empty set.

The empty relation is reflexive and pairwise on the empty set. (In the context of Lean's `Set.pairwise_empty` theorem, where the relation `r` is empty, this statement holds.)


theorem Set.vadd_subset_vadd_right :
    ∀ {α : Type u_2} {β : Type u_3} [inst : VAdd α β] {s₁ s₂ : Set α} {t : Set β}, s₁ ⊆ s₂ → s₁ +ᵥ t ⊆ s₂ +ᵥ t := by
  sorry

This theorem, `Set.vadd_subset_vadd_right`, states that for any types `α` and `β` where `α` has a vector addition operation (`VAdd α β`), given any two sets `s₁` and `s₂` of type `α`, and another set `t` of type `β`, if `s₁` is a subset of `s₂` (`s₁ ⊆ s₂`), then the set formed by adding each element of `s₁` to each element of `t` (`s₁ +ᵥ t`) is also a subset of the set formed by adding each element of `s₂` to each element of `t` (`s₂ +ᵥ t`).

For any types `α` with vector addition and sets `s₁ ⊆ s₂` of `α`, `s₁ ⊆ s₂ +ᵥ t` holds for any set `t`.


theorem AlgebraicTopology.inclusionOfMooreComplexMap_f :
    ∀ {A : Type u_2} [inst : CategoryTheory.Category.{u_3, u_2} A] [inst_1 : CategoryTheory.Abelian A]
      (X : CategoryTheory.SimplicialObject A) (n : ℕ),
      (AlgebraicTopology.inclusionOfMooreComplexMap X).f n =
        CategoryTheory.Subobject.arrow (AlgebraicTopology.NormalizedMooreComplex.objX X n) :=
  by sorry

This theorem, `AlgebraicTopology.inclusionOfMooreComplexMap_f`, states that for any category `A` having a category theory structure and an Abelian structure, and for any simplicial object `X` in `A` and any natural number `n`, the `n`-th component of the functor `AlgebraicTopology.inclusionOfMooreComplexMap` applied to `X` is equal to the arrow from the `n`-th object of the Normalized Moore Complex of `X` to its ambient object in the category `A`. The Normalized Moore Complex and its `n`-th object `objX` form part of a construction in algebraic topology involving simplicial objects and Abelian categories, where the arrow represents a specific morphism in the category `A`.

For any simplicial object X in an Abelian category A with a category structure, the n-th component of the inclusion of Moore Complex functor equals the morphism from the n-th object of X's Normalized Moore Complex to X in A.


theorem CategoryTheory.isFiltered_structuredArrow_of_isFiltered_of_exists :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂}
      [inst_1 : CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor C D)
      [inst_2 : CategoryTheory.IsFilteredOrEmpty C],
      (∀ (d : D), ∃ c, Nonempty (d ⟶ F.obj c)) →
        (∀ {d : D} {c : C} (s s' : d ⟶ F.obj c),
            ∃ c' t, CategoryTheory.CategoryStruct.comp s (F.map t) = CategoryTheory.CategoryStruct.comp s' (F.map t)) →
          ∀ (d : D), CategoryTheory.IsFiltered (CategoryTheory.StructuredArrow d F) :=
  by sorry

This theorem is about the structure of categories in category theory. Specifically, it states that for any type `C` which forms a category and is either filtered or empty, a given functor `F` from `C` to another category `D`, and under the condition that for any object `d` in `D`, there exists an object `c` in `C` and a morphism from `d` to the image of `c` under the functor `F`, if for any two morphisms `s` and `s'` from object `d` to the image of `c` under `F`, there exists an object `c'` and a morphism `t` such that the composition of `s` and the image of `t` under `F` equals the composition of `s'` and the image of `t` under `F`, then for any object `d` in `D`, the category of structured arrows from `d` to `F` is filtered.

In mathematical terms, this theorem asserts that under these conditions, the category of structured arrows from any object in the target category to the functor is a filtered category. It essentially highlights a particular structure preservation property of functors in category theory.

If `C` is a filtered or empty category, `F` is a functor from `C` to another category `D`, and for every object `d` in `D`, there exists an object `c` in `C` and a morphism `t` such that for any morphisms `s` and `s'` from `d` to the image of `c` under `F`, the existence of `c'` implies the equality `s ∘ F(t) = s' ∘ F(t)`, then the category of structured arrows from `d` to `F` is filtered.


theorem Algebraic.cardinal_mk_lift_le_max :
    ∀ (R : Type u) (A : Type v) [inst : CommRing R] [inst_1 : CommRing A] [inst_2 : IsDomain A] [inst_3 : Algebra R A]
      [inst_4 : NoZeroSMulDivisors R A],
      Cardinal.lift.{u, v} (Cardinal.mk { x // IsAlgebraic R x }) ≤
        max (Cardinal.lift.{v, u} (Cardinal.mk R)) Cardinal.aleph0 :=
  by sorry

This theorem states that for any types `R` and `A` where `R` is a commutative ring, `A` is a commutative ring and a domain, `A` is an `R`-algebra, and `R` and `A` have no zero divisors under scalar multiplication, the cardinality of the set of algebraic elements of `A` over `R` (lifted to a higher universe level if necessary), is less than or equal to the maximum of the cardinality of `R` (lifted to a higher universe level if necessary) and the cardinality of the natural numbers, denoted by `ℵ₀`. In mathematical terms, we can say that the number of algebraic elements in an R-algebra `A` is bounded above by the max of the number of elements in `R` and the cardinality of the set of natural numbers.

The number of algebraic elements in a commutative `R`-algebra `A`, where `R` is a commutative ring with no zero divisors and `A` is a commutative domain, is bounded above by the maximum of the cardinalities of `R` and the natural numbers.


theorem MulAction.mem_orbit_iff :
    ∀ {M : Type u} [inst : Monoid M] {α : Type v} [inst_1 : MulAction M α] {a₁ a₂ : α},
      a₂ ∈ MulAction.orbit M a₁ ↔ ∃ x, x • a₁ = a₂ :=
  by sorry

The theorem `MulAction.mem_orbit_iff` states that for any monoid `M` and any type `α` with a monoid action (`MulAction`), for any two elements `a₁` and `a₂` of α, `a₂` is in the orbit of `a₁` under the action of `M` if and only if there exists an element `x` in `M` such that the action of `x` on `a₁` results in `a₂`. In mathematical terms, `a₂` is in the orbit of `a₁` under the group action if and only if there exists `x` in `M` such that `x * a₁ = a₂`.

For any monoid `M` and `MulAction` on type `α`, an element `a₂` is in the orbit of `a₁` under the action if and only if there exists an element `x` in `M` such that `x * a₁ = a₂`.


theorem LieSubmodule.sup_coe_toSubmodule :
    ∀ {R : Type u} {L : Type v} {M : Type w} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : AddCommGroup M]
      [inst_3 : Module R M] [inst_4 : LieRingModule L M] (N N' : LieSubmodule R L M), ↑(N ⊔ N') = ↑N ⊔ ↑N' :=
  by sorry

This theorem, "LieSubmodule.sup_coe_toSubmodule", states that for any commutative ring `R`, Lie ring `L`, and additive commutative group `M` that is also a module over `R` and a Lie ring module over `L`, and for any two Lie submodules `N` and `N'` of `M`, the Lie submodule generated by the union of `N` and `N'` is the same as the submodule generated by the union of the underlying submodules of `N` and `N'`. In other words, the process of taking a union of two Lie submodules and then considering the underlying submodule does not depend on the order in which these operations are performed.

Given a commutative ring `R`, a Lie ring `L`, an additive commutative group `M` that is both an `R`-module and a Lie `L`-module, and Lie submodules `N` and `N'` of `M`, the Lie submodule generated by `N ∪ N'` is equal to the submodule generated by `N ∎ N'`, where `∎` denotes the submodule generated by a union.


theorem Mathlib.Topology.Semicontinuous._auxLemma.10 : (¬False) = True := by sorry

This theorem states that the negation of 'False' is 'True'. In the context of logic, a statement is either true or false. Therefore, if a statement is not false, it necessarily must be true. This is a fundamental concept in logic and boolean algebra.

The negation of False is True. (or equivalently, False implies True)


theorem tsum_apply :
    ∀ {α : Type u_1} {ι : Type u_5} {π : α → Type u_6} [inst : (x : α) → AddCommMonoid (π x)]
      [inst_1 : (x : α) → TopologicalSpace (π x)] [inst_2 : ∀ (x : α), T2Space (π x)] {f : ι → (x : α) → π x} {x : α},
      Summable f → tsum (fun i => f i) x = ∑' (i : ι), f i x :=
  by sorry

This theorem states that for any types `α`, `ι`, and `π`, where `π` is a function from `α` to some type, and for any operations of addition and topology on `π x` (for each `x` in `α`), and assuming `π x` is a Hausdorff space (or T2 space) for each `x` in `α`, then for any function `f` from `ι` to `π x` (for each `x` in `α`) and any element `x` in `α`, if `f` is summable, the sum over `ι` of `f i` at the point `x` is equal to the total sum of the function `f` at the point `x`.

In other words, if we have a function `f` that is mapping from `ι` to some value in `π x` (for a given `x`), and if that function `f` has a sum, the sum over all elements in `ι` of the function applied to those elements is the same as the total sum of the function at that point `x`.

Given types `α`, `ι`, and a Hausdorff space `π` over `α`, if `π x` has additions and `f` is a summable function from `ι` to `π x` for each `x` in `α`, then for all `x` in `α`, the sum of `f i` over `ι` equals the total sum of `f` at `x`.


theorem le_of_forall_one_lt_le_mul :
    ∀ {α : Type u} [inst : LinearOrder α] [inst_1 : DenselyOrdered α] [inst_2 : Monoid α] [inst_3 : ExistsMulOfLE α]
      [inst_4 : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x < x_1]
      [inst_5 : ContravariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x < x_1] {a b : α},
      (∀ (ε : α), 1 < ε → a ≤ b * ε) → a ≤ b :=
  by sorry

This theorem states that for any type `α` that has a linear order, is densely ordered, has a monoid structure, has a multiplication associated with less than or equal to, and has two types of covariance on multiplication and less than, if for all `ε` out of `α` that are greater than 1 it holds that `a` is less than or equal to `b * ε`, then `a` is less than or equal to `b`.

If `α` is a type with a dense linear order, a monoid structure, and covariance on multiplication and order such that for all `ε > 1` in `α`, we have `a ≤ b * ε`, then `a ≤ b`.


theorem parallelogram_law_with_norm :
    ∀ (𝕜 : Type u_1) {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst : InnerProductSpace 𝕜 E]
      (x y : E), ‖x + y‖ * ‖x + y‖ + ‖x - y‖ * ‖x - y‖ = 2 * (‖x‖ * ‖x‖ + ‖y‖ * ‖y‖) :=
  by sorry

This theorem states the parallelogram law with respect to the norm in the context of an inner product space. Given any type 𝕜 that operates like the real or complex numbers, and any normed additive commutative group E that also forms an inner product space with 𝕜, the theorem states that for any two elements x and y in E, the sum of the squared norms of x+y and x-y is equal to twice the sum of the squared norms of x and y. In mathematical notation, ‖x + y‖² + ‖x - y‖² = 2 * (‖x‖² + ‖y‖²).

In an inner product space E over normed field 𝕜, the norm of the sum (difference) of two vectors x and y is equal to the norm of x plus (minus) the norm of y, added (subtracted) twice: ‖x + y‖² = ‖x‖² + ‖y‖² ± 2‖x‖‖y‖.


theorem Set.compl_sInter : ∀ {α : Type u_1} (S : Set (Set α)), (⋂₀ S)ᶜ = ⋃₀ (compl '' S) := by sorry

The theorem `Set.compl_sInter` states that for any type `α`, and for any set `S` of sets of `α`, the complement of the intersection over all sets in `S` is equal to the union of the complements of all sets in `S`. In other words, for all `α` and `S`, the complement of the set of all elements that are in every set in `S` is the set of all elements that are not in at least one set in `S`. This is a formalisation of De Morgan's laws for sets.

 For any type `α` and set `S` of subsets of `α`, `Set.compl_sInter` asserts that `(∀s ∈ S, s).compl = ∧ s ∈ S, s.compl`.

This statement represents the De Morgan's laws for sets, stating that the complement of the intersection of all sets in `S` is equal to the union of the complements of those sets.


theorem intervalIntegral.FTCFilter.finiteAt_inner :
    ∀ {a : ℝ} (l : Filter ℝ) {l' : Filter ℝ} [h : intervalIntegral.FTCFilter a l l'] {μ : MeasureTheory.Measure ℝ}
      [inst : MeasureTheory.IsLocallyFiniteMeasure μ], MeasureTheory.Measure.FiniteAtFilter μ l' :=
  by sorry

This theorem states that for any real number `a` and any pair of filters `l` and `l'` on the real numbers, such that `l'` is the Future Time Control (FTC) filter of `l` at `a`, and given a locally finite measure `μ`, the measure `μ` is finite at the filter `l'`. In other words, there exists some set `s` in the filter `l'` such that the measure of `s` is less than infinity. This theorem is a result from the area of real analysis, specifically the Fundamental Theorem of Calculus (FTC) in the context of measure theory.

Given a real number `a`, a filter `l` on the real numbers, and assuming `l'` is the FTC filter of `l` at `a`, for any locally finite measure `μ`, there exists a set `s` in `l'` with finite measure `μ(s)`.


theorem MeasureTheory.compl_mem_measurableCylinders :
    ∀ {ι : Type u_1} {α : ι → Type u_2} [inst : (i : ι) → MeasurableSpace (α i)] {s : Set ((i : ι) → α i)},
      s ∈ MeasureTheory.measurableCylinders α → sᶜ ∈ MeasureTheory.measurableCylinders α :=
  by sorry

This theorem, `MeasureTheory.compl_mem_measurableCylinders`, states that for any type `ι`, any function `α` from `ι` to another type, and given that each `α i` has a measurable space, if a set `s` of functions from `ι` to `α i` belongs to the set of all measurable cylinders over `α`, then the complement of `s`, denoted `sᶜ`, also belongs to the set of all measurable cylinders over `α`. In other words, if a set is a measurable cylinder, then its complement is also a measurable cylinder.

If `s` is a measurable cylinder over a function `α : ι → αi` with each `α i` having a measurable space, then the complement `sᶜ` is also a measurable cylinder over `α`.


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

This theorem states that for any type `α` that is a linear ordered add commutative group and also an Archimedean field, given a positive element `p`, two elements `a` and `b` of the same type, and an integer `m`, the function `toIcoMod` applied to `a` and `(b + m * p)` is the same as the function `toIcoMod` applied to `a` and `b`. In other words, adding an integer multiple of `p` to `b` does not change the value returned by the `toIcoMod` function. This essentially illustrates the periodicity property in the interval `[a, a+p)`.

For any linear ordered add commutative group and Archimedean field `α`, and positive element `p` of `α`, for all integers `m` and elements `a, b` of `α`, `toIcoMod a (b + m * p) = toIcoMod a b`.


theorem Order.succ_eq_iff_covBy :
    ∀ {α : Type u_1} [inst : PartialOrder α] [inst_1 : SuccOrder α] {a b : α} [inst_2 : NoMaxOrder α],
      Order.succ a = b ↔ a ⋖ b :=
  by sorry

This theorem states that for any type `α` equipped with a partial order and a successor order, and for any elements `a` and `b` of the type `α` in a space without a maximal element, the successor of `a` equals `b` if and only if `a` is covered by `b`. Here, 'covered by' is denoted by the symbol `⋖`, which means that `a` is less than `b` and there is no element `c` such that `a` is less than `c` and `c` is less than `b`.

For any type `α` with a partial order and successor order, without a max element, `a ⋖ b` if and only if `a = Suc(b)`, where `Suc` denotes the successor function.


/-- The angle between the negation of two vectors.  -/
theorem InnerProductGeometry.angle_neg_neg :
    ∀ {V : Type u_1} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] (x y : V),
      InnerProductGeometry.angle (-x) (-y) = InnerProductGeometry.angle x y :=
  by sorry

This theorem states that the angle between the negatives of two vectors in an inner product space is the same as the angle between the original two vectors. More formally, given any normed add commutative group 'V' with an inner product space over the real numbers and any two vectors 'x' and 'y' from 'V', the angle measured between '-x' and '-y' is equal to the angle measured between 'x' and 'y'. The angle is defined as the arccosine of the inner product of the vectors divided by the product of their norms.

In an inner product space over the real numbers, the angle between the negatives of two vectors is equal to the angle between the original vectors, both defined as the arccosine of their inner product divided by the product of their norms.


theorem SimpleGraph.adjMatrix_mulVec_apply :
    ∀ {V : Type u_1} {α : Type u_2} (G : SimpleGraph V) [inst : DecidableRel G.Adj] [inst_1 : Fintype V]
      [inst_2 : NonAssocSemiring α] (v : V) (vec : V → α),
      Matrix.mulVec (SimpleGraph.adjMatrix α G) vec v = Finset.sum (SimpleGraph.neighborFinset G v) fun u => vec u :=
  by sorry

The theorem `SimpleGraph.adjMatrix_mulVec_apply` states that for any given simple graph `G` with vertices of type `V` and adjacency matrix with entries of type `α`, and for any function `vec` from `V` to `α`, the result of multiplying the adjacency matrix of `G` by `vec` at a vertex `v` is equal to the sum over all neighbors `u` of `v` of the values of `vec` at `u`. In other words, the product of the adjacency matrix and a vector at a certain vertex is the sum of the vector's values at the neighbors of that vertex. This involves the non-associative semiring structure of `α`, as well as the finite type structure of `V`, and the decidable relation of adjacency in `G`.

For any simple graph with finite vertex set and adjacency matrix over a non-associative semiring, the product of the adjacency matrix and a vector at a vertex equals the sum of the vector values over its neighboring vertices.


Ordnode.BalancedSz.symm

theorem Ordnode.BalancedSz.symm : ∀ {l r : ℕ}, Ordnode.BalancedSz l r → Ordnode.BalancedSz r l := by sorry

The theorem `Ordnode.BalancedSz.symm` states that for any two natural numbers `l` and `r`, if the hypothetical tree with children of sizes `l` and `r` is balanced according to the `Ordnode.BalancedSz` definition, then the hypothetical tree with children of sizes `r` and `l` is also balanced. In other words, the balance condition is symmetric with respect to swapping the sizes of the left and right subtrees.

If a binary tree is balanced according to `Ordnode.BalancedSz` definition with left child of size `l` and right child of size `r`, then it is also balanced with left child of size `r` and right child of size `l`.


theorem MeasureTheory.AECover.lintegral_tendsto_of_countably_generated :
    ∀ {α : Type u_1} {ι : Type u_2} [inst : MeasurableSpace α] {μ : MeasureTheory.Measure α} {l : Filter ι}
      [inst_1 : Filter.IsCountablyGenerated l] {φ : ι → Set α},
      MeasureTheory.AECover μ l φ →
        ∀ {f : α → ENNReal},
          AEMeasurable f μ → Filter.Tendsto (fun i => ∫⁻ (x : α) in φ i, f x ∂μ) l (nhds (∫⁻ (x : α), f x ∂μ)) :=
  by sorry

The theorem `MeasureTheory.AECover.lintegral_tendsto_of_countably_generated` states that for any measurable space `α` and index set `ι`, a given measure `μ` on `α`, and a countably generated filter `l` on `ι`, if you have a family of sets `φ : ι → Set α` that forms an almost-everywhere cover with respect to measure `μ` and filter `l`, then for any function `f : α → ENNReal` that is almost everywhere measurable, the limit as `i` tends to the filter `l` of the Lebesgue integral of `f` over the set `φ i` (denoted as `∫⁻ (x : α) in φ i, f x ∂μ`) is equal to the Lebesgue integral of `f` over the entire space `α` (denoted as `∫⁻ (x : α), f x ∂μ`), where the limit is taken with respect to the neighborhood filter at the integral value over the entire space.
This theorem is essentially telling us about the behavior of the integral of a function over a sequence of sets that converges almost everywhere to the whole space.

Given a measurable space, a countably generated filter, a measurable family of sets forming an almost-everywhere cover, and a almost everywhere measurable function, the limit of the Lebesgue integrals of the function over the covers as the filter converges to the entire space equals the Lebesgue integral over the entire space.


theorem Mathlib.LinearAlgebra.Ray._auxLemma.2 :
    ∀ {R : Type u_1} [inst : StrictOrderedCommSemiring R] {M : Type u_2} [inst_1 : AddCommMonoid M]
      [inst_2 : Module R M] (x : M), SameRay R x 0 = True :=
  by sorry

This theorem, named `Mathlib.LinearAlgebra.Ray._auxLemma.2`, states that for any type `R` which is a strict ordered commutative semiring, any type `M` which is an additive commutative monoid and a module over `R`, and any element `x` of `M`, `x` and `0` are always in the same ray. In mathematical terms, this means that either `x` is zero or there exists some positive multiples `r₁` and `r₂` of `x` and `0` respectively such that `r₁ * x = r₂ * 0`. However, as `r₂ * 0` is always zero, it means `r₁ * x` must be zero, therefore `x` itself must be zero. Therefore, the theorem essentially states that a vector is in the same ray as the zero vector if and only if it is the zero vector itself.

For any strict ordered commutative semiring R, additive commutative monoid and R-module M, and any x in M, x and 0 are in the same ray if and only if x is the zero element of M.


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

This theorem states that for any type `α`, predicate `p` on `α`, and filter `f` on `α`, the property of "it is not the case that there frequently exists an `x` in `f` such that `p x` holds" is equivalent to "for all `x` frequently in `f`, `p x` does not hold". Mathematically speaking, this theorem is expressing a property about negation and quantifiers in the context of filters.

For any type `α`, predicate `p` on `α`, and filter `f` on `α`, the property "there is no dense subset of `f` on which `p` holds" is equivalent to "for all `x` in the dense subset of `f`, `p x` does not hold".


theorem Polynomial.annIdealGenerator_eq_zero_iff :
    ∀ {𝕜 : Type u_1} {A : Type u_2} [inst : Field 𝕜] [inst_1 : Ring A] [inst_2 : Algebra 𝕜 A] {a : A},
      Polynomial.annIdealGenerator 𝕜 a = 0 ↔ Polynomial.annIdeal 𝕜 a = ⊥ :=
  by sorry

This theorem states that for any field `𝕜`, ring `A`, and algebra structure over `𝕜` and `A`, and for any element `a` in `A`, the monic generator of the annihilating ideal of `a` is zero if and only if the annihilating ideal of `a` is the zero ideal. Here, the annihilating ideal of `a` is the set of all polynomials `p` in `𝕜[X]` such that when `p` is evaluated at `a`, the result is zero. The monic generator of this ideal is a specific polynomial `g` such that the principal ideal generated by `g` is equal to the annihilating ideal, and `g` is chosen to be monic if possible. The zero ideal, denoted by `⊥`, is the ideal that contains only the zero polynomial.

For any field `𝕜`, ring `A`, and algebra structure over `𝕜` and `A`, the monic generator of the annihilating ideal of an element `a` in `A` is zero if and only if the annihilating ideal of `a` is the zero ideal.


theorem WithTop.add_eq_top : ∀ {α : Type u} [inst : Add α] {a b : WithTop α}, a + b = ⊤ ↔ a = ⊤ ∨ b = ⊤ := by sorry

The theorem `WithTop.add_eq_top` states that for any type `α` endowed with an addition operation and any two elements `a` and `b` of the type `WithTop α` (which is the type `α` extended with an additional element `⊤`), the sum `a + b` equals to `⊤` if and only if either `a` equals `⊤` or `b` equals `⊤`. In other words, in the extended type `WithTop α`, the only way you can get `⊤` as the result of addition operation is if at least one of the operands is `⊤` itself.

In the type `WithTop α`, for any `α` with addition operation, `a + b = ⊤` if and only if `a = ⊤` or `b = ⊤`.


theorem Mathlib.GroupTheory.Submonoid.Order._auxLemma.2 :
    ∀ {M : Type u_1} [inst : AddMonoid M] [inst_1 : Preorder M]
      [inst_2 : CovariantClass M M (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] {a : M},
      (a ∈ AddSubmonoid.nonneg M) = (0 ≤ a) :=
  by sorry

The theorem `Mathlib.GroupTheory.Submonoid.Order._auxLemma.2` states that for any type `M` that has an addition operation (i.e., is an `AddMonoid`), a preorder (i.e., a relation that is reflexive and transitive), and a covariance condition (i.e., if `x ≤ y`, then `z + x ≤ z + y` for any `z`), an element `a` of `M` is in the submonoid of nonnegative elements if and only if `a` is greater than or equal to `0`.

For any AddMonoid type M with a preorder and covariance condition, an element a belongs to the submonoid of nonnegative elements if and only if a ≥ 0.


theorem CompactExhaustion.mem_find :
    ∀ {X : Type u_1} [inst : TopologicalSpace X] (K : CompactExhaustion X) (x : X),
      x ∈ K (CompactExhaustion.find K x) :=
  by sorry

This theorem states that for any type `X` equipped with a topological space structure and any compact exhaustion `K` of `X`, every element `x` of `X` is an element of `K` at the minimal natural number `n` such that `x` is in `K n`. In other words, `x` belongs to the set `K` at the smallest `n` for which it is possible.

For any compact exhaustion $K$ of a topological space $X$ and any point $x \in X$, there exists the smallest natural number $n$ such that $x \in K_n$.


AEMeasurable.indicator

theorem AEMeasurable.indicator :
    ∀ {α : Type u_2} {β : Type u_3} {m0 : MeasurableSpace α} [inst : MeasurableSpace β] {f : α → β}
      {μ : MeasureTheory.Measure α} [inst_1 : Zero β],
      AEMeasurable f μ → ∀ {s : Set α}, MeasurableSet s → AEMeasurable (Set.indicator s f) μ :=
  by sorry

The `AEMeasurable.indicator` theorem states that for any types `α` and `β`, given a measure space `m0` on `α` and a `MeasurableSpace β`, a function `f` from `α` to `β`, a measure `μ` on `α`, and an instance of `Zero β`, if the function `f` is almost everywhere measurable with respect to the measure `μ`, then for any set `s` of `α` that is a measurable set, the function resulting from the application of the set indicator function to `s` and `f` is also almost everywhere measurable with respect to the measure `μ`. In other words, if a function is almost everywhere measurable, then the indicator function on any measurable set of the function's domain is also almost everywhere measurable.

Given a measure space, a measurable function, and a measurable set, the indicator function of the set applied to the function is almost everywhere measurable if the function is.


theorem AlternatingMap.map_zero :
    ∀ {R : Type u_1} [inst : Semiring R] {M : Type u_2} [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {N : Type u_3}
      [inst_3 : AddCommMonoid N] [inst_4 : Module R N] {ι : Type u_7} (f : M [⋀^ι]→ₗ[R] N) [inst_5 : Nonempty ι],
      f 0 = 0 :=
  by sorry

This theorem, `AlternatingMap.map_zero`, states that for any semiring `R`, an additively commutative monoid `M` that is also an `R`-module, an additively commutative monoid `N` that is also an `R`-module, and any type `ι`, given a linear map `f` from the `ι`-fold wedge product of `M` to `N` (which is an alternating multilinear map), if `ι` is nonempty, then the application of `f` to the zero element of the `ι`-fold wedge product of `M` is the zero element of `N`. In other words, applying an alternating multilinear map to zero yields zero.

For any semiring `R`, additively commutative `R`-modules `M` and `N`, and an alternating multilinear map `f` from the `ι`-fold wedge product of `M` to `N`, if `ι` is nonempty, then `f(∧⁰ x:\_ | i:ι) 0 = 0`, where `∧⁰` denotes the `ι`-fold wedge product.


theorem Multiset.erase_subset :
    ∀ {α : Type u_1} [inst : DecidableEq α] (a : α) (s : Multiset α), Multiset.erase s a ⊆ s := by sorry

The theorem `Multiset.erase_subset` states that for any type `α` that has decidable equality, and any element `a` of type `α` and multiset `s` of elements of type `α`, the multiset resulting from erasing `a` from `s` is a subset of `s`. In other words, removing an element from a multiset always results in a multiset that is a subset of the original one.

For any type `α` with decidable equality and any multiset `s` of `α` and element `a` in `α`, the multiset obtained by erasing `a` from `s` is a subset of `s`.


theorem BoxIntegral.Prepartition.disjoint_coe_of_mem :
    ∀ {ι : Type u_1} {I J₁ J₂ : BoxIntegral.Box ι} (π : BoxIntegral.Prepartition I),
      J₁ ∈ π → J₂ ∈ π → J₁ ≠ J₂ → Disjoint ↑J₁ ↑J₂ :=
  by sorry

This theorem states that for any type `ι`, and any three boxes `I`, `J1`, and `J2` in the Euclidean space of dimension `ι`, if we have a prepartition `π` of the box `I`, and if `J1` and `J2` are elements of this prepartition and are distinct, then `J1` and `J2` are disjoint. In other words, the intersection of `J1` and `J2` is the bottom element of the lattice (the empty set, in the context of sets of points in Euclidean space).

Given a prepartition `π` of a box `I` in Euclidean space of dimension `ι`, if `J1` and `J2` are distinct elements of `π`, then `J1 ∩ J2` is the empty set.


theorem Finset.card_ne_zero_of_mem : ∀ {α : Type u_1} {s : Finset α} {a : α}, a ∈ s → s.card ≠ 0 := by sorry

This theorem asserts that for any type `α`, any finite set `s` of `α`, and any element `a` of `α`, if `a` belongs to `s`, then the cardinality (or size) of `s` is not zero. In other words, if a set contains at least one element, its size is not zero.

For any finite set `s` of type `α` and any element `a` in `s`, the cardinality of `s` is non-zero if `a` is a member of `s`.


/-- A version of `Complex.cpow_nat_mul` with RHS that matches `Complex.cpow_mul`.

The assumptions on the arguments are needed
because the equality fails, e.g., for `x = -I`, `n = 2`, `y = 1/2`.  -/
theorem Complex.cpow_nat_mul' :
    ∀ {x : ℂ} {n : ℕ},
      -Real.pi < ↑n * Complex.arg x → ↑n * Complex.arg x ≤ Real.pi → ∀ (y : ℂ), x ^ (↑n * y) = (x ^ n) ^ y :=
  by sorry

This theorem states that for any complex number `x` and any natural number `n`, if the product of `n` and the argument of `x` is strictly greater than `-π` and less than or equal to `π`, then for any other complex number `y`, the expression `x` raised to the power of the product of `n` and `y` is equal to `x` raised to the power of `n`, which is then raised to the power of `y`. However, this theorem requires specific constraints on the arguments because the equality does not hold for all values. For example, it fails when `x` equals `-I`, `n` equals `2`, and `y` equals `1/2`.

For complex numbers `x` and natural number `n`, if the argument of `x` times `n` lies between `-π` and `π`, then `x^(n*y)` equals `(x^n)^y`.