IsCoveringMap.isSeparatedMap

theorem IsCoveringMap.isSeparatedMap :
    ∀ {E : Type u_1} {X : Type u_2} [inst : TopologicalSpace E] [inst_1 : TopologicalSpace X] {f : E → X},
      IsCoveringMap f → IsSeparatedMap f :=
  by sorry

The theorem states that for any two types `E` and `X`, both equipped with topological spaces, if a function `f` from `E` to `X` is a covering map, then it is also a separated map. In other words, in a covering map, any two distinct points in `E` with the same image in `X` can be separated by open neighborhoods. This quantifies over all possible mappings and topological spaces for the types `E` and `X`.

Given types `E` and `X` with topological spaces, if `f` is a covering map from `E` to `X`, then for any distinct points `x, y` in `E` with `f(x) = f(y)`, there exist open neighborhoods `U` of `x` and `V` of `y` such that `U ∩ V = ∅`.


Set.IsPWO.union

theorem Set.IsPWO.union :
    ∀ {α : Type u_2} [inst : Preorder α] {s t : Set α}, Set.IsPWO s → Set.IsPWO t → Set.IsPWO (s ∪ t) := by sorry

This theorem states that for any type `α` with a preorder structure, if two sets `s` and `t` are partially well-ordered — that is, any infinite sequence in these sets contain a monotone subsequence of length 2 — then the union of `s` and `t` is also partially well-ordered.

If `α` is a type with a preorder structure and `s` and `t` are partially well-ordered sets, then the union of `s` and `t` is also partially well-ordered.


theorem Polynomial.map_sum :
    ∀ {R : Type u} {S : Type v} [inst : Semiring R] [inst_1 : Semiring S] (f : R →+* S) {ι : Type u_1}
      (g : ι → Polynomial R) (s : Finset ι),
      Polynomial.map f (Finset.sum s fun i => g i) = Finset.sum s fun i => Polynomial.map f (g i) :=
  by sorry

The theorem `Polynomial.map_sum` states that for any semirings `R` and `S`, ring homomorphism `f` from `R` to `S`, function `g` from an arbitrary type `ι` to a polynomial in `R`, and a finite set `s` of type `ι`, mapping the sum of the polynomials generated by `g` over the elements of `s` is the same as summing the mapped polynomials over the elements of `s`. In mathematical terms, this is equivalent to the statement that the operation of mapping a polynomial commutes with the operation of summing polynomials: \[\text{Polynomial.map}\ f \left(\sum_{i\in s} g(i)\right) = \sum_{i\in s} \text{Polynomial.map}\ f\ (g(i)).\]

The theorem asserts that for any semirings R and S, ring homomorphism f, and function g from an arbitrary type ι to polynomials in R, the mapping of the sum of g(i) over a finite set s equals the sum of the mapped polynomials g(i) over s: Polynomial.map f (∑i∈s g i) = ∑i∈s Polynomial.map f (g i).


theorem one_div_div : ∀ {α : Type u_1} [inst : DivisionMonoid α] (a b : α), 1 / (a / b) = b / a := by sorry

This theorem, named `one_div_div`, states that for any type `α` that forms a Division Monoid, given any two elements `a` and `b` of type `α`, the expression `1 / (a / b)` is equal to `b / a`. In simple mathematical terms, it states that one divided by the result of `a` divided by `b` is equal to `b` divided by `a`. This theorem holds true for all division monoids, which are algebraic structures with an operation mimicking division.

For any division monoid `α`, the expressions `1 / (a / b)` and `b / a` are equal for all `a` and `b` in `α`.


theorem Mathlib.Data.Finmap._auxLemma.16 :
    ∀ {α : Type u} {β : α → Type v} {s₁ s₂ : AList β},
      (AList.toFinmap s₁ = AList.toFinmap s₂) = List.Perm s₁.entries s₂.entries :=
  by sorry

This theorem, named `Mathlib.Data.Finmap._auxLemma.16`, states that for any two `AList` types `s₁` and `s₂` parameterized by types `α` and `β`, the condition for `s₁` being mapped to a `Finmap` type being equal to `s₂` being mapped to a `Finmap` type, is equivalent to the list of entries of `s₁` being a permutation of the list of entries of `s₂`. Here, `α` is any type and `β` is a type that depends on `α`. In other words, the theorem establishes a correspondence between equality of `Finmap` representations of two `ALists` and the permutation relation of their entries.

For `AList` types `s₁` and `s₂` parameterized by types `α` and `β`, the `Finmap` representations of `s₁` and `s₂` are equal if and only if the lists of their entries are permutations of each other.


theorem Submodule.mul_induction_on :
    ∀ {R : Type u} [inst : CommSemiring R] {A : Type v} [inst_1 : Semiring A] [inst_2 : Algebra R A]
      {M N : Submodule R A} {C : A → Prop} {r : A},
      r ∈ M * N → (∀ m ∈ M, ∀ n ∈ N, C (m * n)) → (∀ (x y : A), C x → C y → C (x + y)) → C r :=
  by sorry

This theorem, `Submodule.mul_induction_on`, establishes a form of mathematical induction for the multiplication operation on submodules of an algebra over a commutative semiring. Specifically, given two submodules `M` and `N` of an algebra `A` over a commutative semiring `R`, and a property `C` that applies to elements of `A`, if every product of an element from `M` and an element from `N` satisfies `C`, and `C` is preserved under addition, then `C` is true for all elements of the submodule generated by the product of `M` and `N`.

Given submodules M and N of a commutative semiring algebra A, if every m ∈ M and n ∈ N satisfy property C on their product, and property C is additively closed, then property C holds for all elements of the submodule generated by the products of M and N.


/-- **Legendre's Theorem**

The multiplicity of a prime in `n!` is the sum of the quotients `n / p ^ i`. This sum is expressed
over the finset `Ico 1 b` where `b` is any bound greater than `log p n`.  -/
theorem Nat.Prime.multiplicity_factorial :
    ∀ {p : ℕ},
      Nat.Prime p →
        ∀ {n b : ℕ},
          Nat.log p n < b → multiplicity p (Nat.factorial n) = ↑(Finset.sum (Finset.Ico 1 b) fun i => n / p ^ i) :=
  by sorry

**Legendre's Theorem**

For any prime number `p` and natural numbers `n` and `b`, where the logarithm of `n` in base `p` is less than `b`, the highest power of `p` that divides `n!` (the factorial of `n`) is equal to the sum of the quotients of `n` divided by `p` to the power `i`, where `i` ranges over the elements of the set of natural numbers between `1` and `b` (exclusive). Here `b` is any bound greater than `log p n`.

For any prime number `p` and natural numbers `n` and `b` with `log_p n < b`, the highest power of `p` dividing `n!` equals the sum of the quotients `\frac{n}{p^i}` for `i` in the range `1` to `b`.


theorem CategoryTheory.ShortComplex.SnakeInput.L₀X₂ToP.proof_1 :
    ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Abelian C]
      (S : CategoryTheory.ShortComplex.SnakeInput C),
      CategoryTheory.CategoryStruct.comp S.v₀₁.τ₂ S.L₁.g = CategoryTheory.CategoryStruct.comp S.L₀.g S.v₀₁.τ₃ :=
  by sorry

The theorem `CategoryTheory.ShortComplex.SnakeInput.L₀X₂ToP.proof_1` states that for any category `C`, which is an abelian category, and a given short complex `S` in `C`, the composition of the morphisms `S.v₀₁.τ₂` and `S.L₁.g` is equal to the composition of the morphisms `S.L₀.g` and `S.v₀₁.τ₃`. In the context of category theory, this essentially means that we have commutativity between these two paths of morphisms in the short complex `S`.

For any short complex `S` in an abelian category `C`, the compositions `S.v₀₁.τ₂ ∘ S.L₁.g` and `S.L₀.g ∘ S.v₀₁.τ₃` are equal.


theorem IsClosed.vadd_left_of_isCompact :
    ∀ {α : Type u} {β : Type v} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] [inst_2 : AddGroup α]
      [inst_3 : AddAction α β] [inst_4 : ContinuousNeg α] [inst_5 : ContinuousVAdd α β] {s : Set α} {t : Set β},
      IsClosed t → IsCompact s → IsClosed (s +ᵥ t) :=
  by sorry

The theorem `IsClosed.vadd_left_of_isCompact` states that for any two types `α` and `β` with `α` being an additive group and `β` an additive action of `α`, given topological spaces over `α` and `β`, and provided that the negation in `α` and vector addition in `β` are continuous functions, if `s` is a compact set in `α` and `t` is a closed set in `β`, then the vector addition of `s` and `t` (denoted as `s +ᵥ t`) is also a closed set in `β`. This theorem links the concepts of compactness and closedness under the operation of vector addition.

If `α` is an additive group, `β` is an additive action of `α`, and negation and vector addition in `β` are continuous, then the Minkowski sum of a compact set in `α` and a closed set in `β` is a closed set in `β`.


theorem Ordinal.nat_le_card : ∀ {o : Ordinal.{u_3}} {n : ℕ}, ↑n ≤ Ordinal.card o ↔ ↑n ≤ o := by sorry

This theorem states that for any ordinal `o` and natural number `n`, the cardinality of the ordinal `o` is greater than or equal to the natural number `n` if and only if the ordinal `o` is greater than or equal to the natural number `n` when both are considered as ordinals. In other words, a natural number is less than or equal to the cardinality of an ordinal if and only if it is also less than or equal to the ordinal itself when they are both cast to ordinals.

For any ordinal `o` and natural number `n`, `o` has cardinality greater than or equal to `n` if and only if `o` is greater than or equal to `n` as ordinals.


theorem div_mul_comm : ∀ {α : Type u_1} [inst : DivisionCommMonoid α] (a b c : α), a / b * c = c / b * a := by sorry

This theorem states that for any type `α` that is a Division Commutative Monoid, and for any three elements `a`, `b`, and `c` of this type, the operation of dividing `a` by `b`, then multiplying the result by `c`, is equivalent to the operation of dividing `c` by `b`, then multiplying the result by `a`. In other words, the order of `a` and `c` can be swapped in this combination of division and multiplication operations.

For any Division Commutative Monoid `α`, and elements `a`, `b`, and `c` in `α`, `(a / b) * c = c / b * a`.


theorem CategoryTheory.Arrow.comp_left :
    ∀ {T : Type u} [inst : CategoryTheory.Category.{v, u} T] {X Y Z : CategoryTheory.Arrow T} (f : X ⟶ Y) (g : Y ⟶ Z),
      (CategoryTheory.CategoryStruct.comp f g).left = CategoryTheory.CategoryStruct.comp f.left g.left :=
  by sorry

This theorem, named `CategoryTheory.Arrow.comp_left`, establishes a property about the composition of morphisms in the arrow category of a given category `T`. Specifically, for any three objects `X`, `Y`, `Z` in the arrow category of `T`, and given two morphisms `f` and `g` such that `f` goes from `X` to `Y` and `g` goes from `Y` to `Z`, the left component of the composition of `f` and `g` (denoted as `(CategoryTheory.CategoryStruct.comp f g).left`) is equal to the composition of the left components of `f` and `g` (denoted as `CategoryTheory.CategoryStruct.comp f.left g.left`). In essence, this theorem demonstrates that the composition operation in the arrow category behaves correctly with respect to the left components of its morphisms.

In the arrow category of a given category, the left component of the composition of two morphisms is equal to the composition of their left components.


theorem Nat.Partrec.Code.eval_part : Partrec₂ Nat.Partrec.Code.eval := by sorry

The theorem `Nat.Partrec.Code.eval_part` states that the evaluation function for "partial recursive" natural number codes, `Nat.Partrec.Code.eval`, is a partial recursive function of two arguments. Here, a function is called "partially recursive" if it can be computed by a Turing machine. The function `Nat.Partrec.Code.eval` takes two arguments: a code and a natural number, and it returns a computation which may or may not return a natural number (captured by the `Part` in `Partrec₂`). The theorem shows that this function is computable.

The theorem `Nat.Partrec.Code.eval_part` asserts that the function `Nat.Partrec.Code.eval` defining the evaluation of partial recursive natural number codes is a partial recursive function.


theorem IsLeftRegular.right_of_commute :
    ∀ {R : Type u_1} [inst : Mul R] {a : R}, (∀ (b : R), Commute a b) → IsLeftRegular a → IsRightRegular a := by sorry

This theorem states that for any type `R` equipped with a multiplication operation, if an element `a` of this type commutes with all other elements (that is, for any element `b` from `R`, `a * b = b * a`), and `a` is a left-regular element (meaning that multiplication on the left by `a` is injective), then `a` is also a right-regular element (meaning that multiplication on the right by `a` is also injective).

If `a` is an element of a commutative ring `R` that commutes with all elements and is left-regular, then `a` is right-regular.


Sum.inl.inj

theorem Sum.inl.inj : ∀ {α : Type u} {β : Type v} {val val_1 : α}, Sum.inl val = Sum.inl val_1 → val = val_1 := by sorry

This theorem, `Sum.inl.inj`, asserts that for any types `α` and `β`, and any values `val` and `val_1` of type `α`, if `Sum.inl val` is equal to `Sum.inl val_1`, then `val` must be equal to `val_1`. In simpler terms, it states that the left injection function (`Sum.inl`) of a sum type is injective, meaning that it faithfully represents different values: two different values cannot be mapped to the same result by this function.

For all types `α` and values `val`, `val_1` of type `α`, if `Sum.inl val = Sum.inl val_1` in the type `Sum α`, then `val = val_1`.


ContinuousLinearEquiv.hasFDerivAt

theorem ContinuousLinearEquiv.hasFDerivAt :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {x : E}
      (iso : E ≃L[𝕜] F), HasFDerivAt (⇑iso) (↑iso) x :=
  by sorry

This theorem states that for any nontrivially normed field 𝕜, normed add commutative groups E and F, and normed vector spaces over 𝕜, E and F, if we have a continuous linear equivalence `iso` from E to F, then the function defined by the application of this equivalence `⇑iso` has a derivative at any point `x` in E. This derivative is given by the representation `↑iso` of the continuous linear equivalence. In other words, this theorem asserts that the continuous linear equivalences are differentiable and its derivative is itself at any point in the domain.

For any nontrivially normed field 𝕜, any continuous linear equivalence between normed additive groups of normed vector spaces over 𝕜 is differentiable, and its derivative is given by the representation of the equivalence.


theorem EuclideanDomain.gcd_val :
    ∀ {R : Type u} [inst : EuclideanDomain R] [inst_1 : DecidableEq R] (a b : R),
      EuclideanDomain.gcd a b = EuclideanDomain.gcd (b % a) a :=
  by sorry

This theorem states that for any type `R` that forms a Euclidean domain and has decidable equality, and for any elements `a` and `b` of `R`, the greatest common divisor (gcd) of `a` and `b` is equal to the gcd of `b` modulo `a` and `a`. This is a property of Euclidean domains and is a key part of the Euclidean algorithm for computing the gcd of two elements.

In a Euclidean domain with decidable equality, the gcd of `a` and `b` equals the gcd of `b` modulo `a` and `a`.


Nat.ModEq.rfl

theorem Nat.ModEq.rfl : ∀ {n a : ℕ}, a ≡ a [MOD n] := by sorry

This theorem, `Nat.ModEq.rfl`, states that for any two natural numbers `n` and `a`, `a` is congruent to `a` modulo `n`. In other words, when we divide `a` by `n`, the remainder is the same as if we divide `a` by itself. This is a reflexive property inherent to the modulo operation.

For all natural numbers n and a, a is congruent to a modulo n. (a ≡ a (mod n)).


theorem Dioph.diophFn_vec :
    ∀ {n : ℕ} (f : Vector3 ℕ n → ℕ), Dioph.DiophFn f ↔ Dioph {v | f (v ∘ Fin2.fs) = v Fin2.fz} := by sorry

The theorem `Dioph.diophFn_vec` states that for all natural numbers `n` and a function `f` that maps vectors of length `n` of natural numbers to natural numbers, the function `f` is Diophantine if and only if the set of all functions `v` such that `f` of `v` composed with the successor function equals `v` of the zero function is Diophantine. In simpler terms, a function `f` that takes a vector of natural numbers and returns a natural number is Diophantine exactly when there exists a polynomial such that for any function `v`, `v` is in the set precisely when the polynomial equals zero.

A function mapping vectors of natural numbers to natural numbers is Diophantine if and only if the set of vectors `v` such that applying `f` to `v` and then the successor function equals the zero function is Diophantine in terms of the components of `v`.


theorem Finsupp.mapDomain_support :
    ∀ {α : Type u_1} {β : Type u_2} {M : Type u_5} [inst : AddCommMonoid M] [inst_1 : DecidableEq β] {f : α → β}
      {s : α →₀ M}, (Finsupp.mapDomain f s).support ⊆ Finset.image f s.support :=
  by sorry

The theorem `Finsupp.mapDomain_support` states that for any two types `α` and `β`, any type `M` that forms an additive commutative monoid, any function `f` from `α` to `β`, and any finitely supported function `s` from `α` to `M`, the support of the function obtained by mapping the domain of `s` using `f` is a subset of the image of the support of `s` under the function `f`. Here, the support of a function is a finitely supported function that represents the set of elements in the domain that map to non-zero values. The image of a set under a function is the set of values the function takes on that set.

For any additive commutative monoid M, any function f : α → β, and finitely supported functions s : α → M and t : α → ⊤ with supp s = {x : α | s x ≠ 0} and supp (f ∘ s) ∋ im(x : α | s x ≠ 0), we have im(supp s) ⊆ supp (f ∘ s).


theorem Finset.inter_subset_union : ∀ {α : Type u_1} [inst : DecidableEq α] {s t : Finset α}, s ∩ t ⊆ s ∪ t := by sorry

This theorem states that for any type `α` with decidable equality (meaning that for any two elements `a` and `b` of `α`, whether `a = b` is a decidable proposition), and any two finite sets `s` and `t` of `α`, the intersection of `s` and `t` is a subset of the union of `s` and `t`. In mathematical terms, this can be denoted as: for all sets `s` and `t`, we have `s ∩ t ⊆ s ∪ t`.

For any types `α` with decidable equality and finite sets `s` and `t` of `α`, the intersection of `s` and `t` is a subset of the union of `s` and `t` (i.e., `s ∩ t ⊆ s ∪ t`).


theorem Ne.not_le_or_not_le : ∀ {α : Type u} [inst : PartialOrder α] {a b : α}, a ≠ b → ¬a ≤ b ∨ ¬b ≤ a := by sorry

This theorem states that for any type `α` that has a partial order defined on it, and for any two elements `a` and `b` of type `α`, if `a` is not equal to `b`, then either `a` is not less than or equal to `b` or `b` is not less than or equal to `a`. In other words, when two elements from a partially ordered set are distinct, at least one of them is strictly greater than the other.

For any partially ordered type `α` and elements `a` and `b` of `α`, if `a ≠ b` then neither `a ≤ b` nor `b ≤ a`.


theorem Polynomial.coeff_mirror :
    ∀ {R : Type u_1} [inst : Semiring R] (p : Polynomial R) (n : ℕ),
      Polynomial.coeff (Polynomial.mirror p) n =
        Polynomial.coeff p ((Polynomial.revAt (Polynomial.natDegree p + Polynomial.natTrailingDegree p)) n) :=
  by sorry

The theorem `Polynomial.coeff_mirror` states that for all semiring `R` and any polynomial `p` of type `R`, the coefficient of the `n`-th term of the mirror of `p` is equal to the coefficient of the term corresponding to `revAt (natDegree p + natTrailingDegree p)` of `p`. Here, `Polynomial.mirror p` refers to the polynomial obtained by reversing the coefficients of `p` while preserving its degree, `Polynomial.revAt N` is an involution that returns `N - i` if `i ≤ N` and `i` otherwise, and `natDegree` and `natTrailingDegree` are the degree and trailing degree of the polynomial forced to ℕ, respectively.

For any polynomial `p` over a semiring `R`, the coefficient of the `n`-th term of `p`'s mirror is equal to the coefficient of the term at position `natDegree p + natTrailingDegree p - n` in `p`.


theorem Set.preimage_inr_image_inl : ∀ {α : Type u_1} {β : Type u_2} (s : Set α), Sum.inr ⁻¹' (Sum.inl '' s) = ∅ := by
  sorry

This theorem states that for all sets `s` of some type `α`, the preimage of the image of `s` under the function `Sum.inl` through the function `Sum.inr` equals the empty set. This result arises from the fact that `Sum.inl` and `Sum.inr` are disjoint embedding functions for different types `α` and `β` into the type `Sum α β`. The image of `s` under `Sum.inl` is a set of left `Sum` elements, but the inverse image under `Sum.inr` only relates to right `Sum` elements, hence their intersection is empty.

For all sets `s` of type `α`, the preimage of the image of `s` under `Sum.inl` through `Sum.inr` is the empty set.


theorem LocalRing.mem_maximalIdeal :
    ∀ {R : Type u} [inst : CommSemiring R] [inst_1 : LocalRing R] (x : R),
      x ∈ LocalRing.maximalIdeal R ↔ x ∈ nonunits R :=
  by sorry

This theorem states that for any commutative semiring `R` that also forms a local ring, an element `x` from `R` is a member of the maximal ideal of `R` if and only if `x` is a nonunit in `R`. In other words, the maximal ideal of a local ring is exactly the set of all non-invertible (or nonunit) elements in the ring.

In a commutative local semiring, an element is in the maximal ideal if and only if it is a nonunit.


theorem Primrec.vector_toList : ∀ {α : Type u_1} [inst : Primcodable α] {n : ℕ}, Primrec Vector.toList := by sorry

The theorem `Primrec.vector_toList` states that for any type `α` that is primcodable (i.e., can be encoded and decoded as natural numbers), and any natural number `n`, the function that converts a vector of length `n` of elements of type `α` to a list is primitive recursive. In other words, the operation of converting a vector to a list can be carried out via a sequence of simple computational steps, the number of which is determined by the size of the input vector.

For any primcodable type `α` and natural number `n`, the function converting a vector of length `n` of `α` elements to a list is primitive recursive.


theorem LipschitzWith.mk_one :
    ∀ {α : Type u} {β : Type v} [inst : PseudoMetricSpace α] [inst_1 : PseudoMetricSpace β] {f : α → β},
      (∀ (x y : α), dist (f x) (f y) ≤ dist x y) → LipschitzWith 1 f :=
  by sorry

This theorem, `LipschitzWith.mk_one`, states that for any two types `α` and `β` equipped with pseudo metric spaces, and any function `f` from `α` to `β`, if for every pair of elements `x` and `y` in `α`, the distance between `f(x)` and `f(y)` is less than or equal to the distance between `x` and `y`, then the function `f` is Lipschitz continuous with constant `1`. In mathematical terms, a function `f` is Lipschitz continuous with constant `1` if for all `x, y`, we have `d(f(x), f(y)) ≤ d(x, y)`, where `d` denotes the distance in the respective metric spaces.

If a function between two pseudo metric spaces satisfies the condition that the distance between its images of any two points is less than or equal to the distance between the points themselves, then the function is Lipschitz continuous with constant 1.


theorem IsBezout.span_gcd :
    ∀ {R : Type u} [inst : Ring R] (x y : R) [inst_1 : Submodule.IsPrincipal (Ideal.span {x, y})],
      Ideal.span {IsBezout.gcd x y} = Ideal.span {x, y} :=
  by sorry

The theorem `IsBezout.span_gcd` states that for any ring `R` and any two elements `x` and `y` of the ring, if the ideal generated by `x` and `y` is principal (i.e., it is generated by a single element), then the ideal generated by the greatest common divisor of `x` and `y` is the same as the ideal generated by `x` and `y`. This means that in the context of a Bézout domain (a ring in which every finitely generated ideal is principal), the greatest common divisor of two elements essentially captures the same information as the two original elements with respect to generating ideals.

In a Bézout domain, the ideal generated by two elements is principal if and only if it is generated by their greatest common divisor.


/-- A characterization of `enumOrd`: it is the unique strict monotonic function with range `S`.  -/
theorem Ordinal.eq_enumOrd :
    ∀ {S : Set Ordinal.{u}} (f : Ordinal.{u} → Ordinal.{u}),
      Set.Unbounded (fun x x_1 => x < x_1) S → (StrictMono f ∧ Set.range f = S ↔ f = Ordinal.enumOrd S) :=
  by sorry

The theorem `Ordinal.eq_enumOrd` characterizes the function `enumOrd` in the context of set theory. For any set `S` of ordinals and any function `f` from ordinals to ordinals, if `S` is an unbounded set (where "unbounded" means that for any ordinal, there exists an ordinal in `S` that is not smaller), then `f` is strictly monotonic (i.e., if `a` is less than `b`, then `f(a)` is less than `f(b)`) and the range of `f` equals `S` if and only if `f` is equivalent to the function `enumOrd` applied on `S`. In other words, `enumOrd` is the unique strictly monotonic function whose range is the unbounded set `S` of ordinals.

For any unbounded set S of ordinals, the function f is equal to enumOrd on S if and only if f is a strict monotonic function with range S.


IsMax.grade

theorem IsMax.grade :
    ∀ (𝕆 : Type u_1) {α : Type u_3} [inst : Preorder α] [inst_1 : Preorder 𝕆] [inst_2 : GradeMaxOrder 𝕆 α] {a : α},
      IsMax a → IsMax (grade 𝕆 a) :=
  by sorry

The theorem `IsMax.grade` states that for any type `𝕆`, for any type `α` that is a preordered set, and for any instance of `GradeMaxOrder` relating `𝕆` and `α`, if a given element `a` of type `α` is a maximal element (i.e., no other element in `α` is strictly greater than `a`), then the grade (which, by analogy, is the number of elements one needs to descend to reach the minimal element) of `a` is also a maximal element.

If `α` is a preordered set over type `𝕆` with maximal element `a`, then the grade of `a` is a maximal element among the grades of elements in `α`.


theorem card_nsmul_eq_zero' : ∀ {G : Type u_6} [inst : AddGroup G] {x : G}, Nat.card G • x = 0 := by sorry

The theorem `card_nsmul_eq_zero'` states that for any type `G` that forms an additive group, and for any element `x` in `G`, the cardinality of `G` times `x` equals zero. In other words, if we multiply `x` by the number of elements in `G` (or add `x` to itself that many times), we get the additive identity element, which is zero in the additive group. If `G` is infinite, its cardinality is defined as zero, so this theorem also holds for infinite groups.

For any additive group G and element x in G, the product of the cardinality of G and x is zero.


theorem Equiv.preimage_image : ∀ {α : Type u_1} {β : Type u_2} (e : α ≃ β) (s : Set α), ⇑e ⁻¹' (⇑e '' s) = s := by sorry

The theorem `Equiv.preimage_image` states that for all types `α` and `β`, and for every bijective function `e` from `α` to `β` and any set `s` of type `α`, the pre-image of the image of `s` under the function `e` equals to `s` itself. In other words, if you take a set `s`, map all of its elements to another type via a bijection `e`, and then map the resulting set back via the inverse of `e`, you will get the original set `s` back. This corresponds to the mathematical concept that the pre-image of the image of a set under a bijective function equals the original set.

For every bijective function `e` from type `α` to type `β`, and any set `s` of type `α`, `e''(e(s)) = s`.


theorem gauge_pos :
    ∀ {E : Type u_2} [inst : AddCommGroup E] [inst_1 : Module ℝ E] {s : Set E} {x : E} [inst_2 : TopologicalSpace E]
      [inst_3 : T1Space E], Absorbent ℝ s → Bornology.IsVonNBounded ℝ s → (0 < gauge s x ↔ x ≠ 0) :=
  by sorry

The theorem `gauge_pos` states that for any real vector space `E` (endowed with an additive commutative group structure, a module over the real numbers structure, a topological space structure, and a T1 space structure), a set `s` in `E`, and an element `x` in `E`, if `s` is absorbent and von Neumann bounded, then the Minkowski functional (gauge) of `s` at `x` is greater than zero if and only if `x` is not the zero vector. In other words, the gauge of a nonzero vector under these conditions is always positive.

For any absorbent and von Neumann bounded set `s` in a real vector space `E`, its Minkowski functional at a nonzero vector `x` is positive.


/-- A family `𝓕 : ι → X → α` is equicontinuous iff the function `swap 𝓕 : X → ι → α` is
continuous *when `ι → α` is equipped with the topology of uniform convergence*. This is
very useful for developping the equicontinuity API, but it should not be used directly for other
purposes.  -/
theorem equicontinuous_iff_continuous :
    ∀ {ι : Type u_1} {X : Type u_3} {α : Type u_7} [tX : TopologicalSpace X] [uα : UniformSpace α] {F : ι → X → α},
      Equicontinuous F ↔ Continuous (⇑UniformFun.ofFun ∘ Function.swap F) :=
  by sorry

The theorem `equicontinuous_iff_continuous` states that a family of functions `𝓕 : ι → X → α` is equicontinuous (i.e., it is equicontinuous at each point of `X`) if and only if the function obtained by swapping the arguments of `𝓕` (so it becomes `X → ι → α`) is continuous, when `ι → α` is equipped with the topology of uniform convergence. This concept is particularly beneficial when developing the equicontinuity API, although it is not intended to be used directly for other applications.

A family of functions is equicontinuous if and only if the function obtained by swapping arguments is continuous with respect to uniform convergence of functions.


theorem Submodule.smul_of_tower_mem :
    ∀ {S : Type u'} {R : Type u} {M : Type v} [inst : Semiring R] [inst_1 : AddCommMonoid M] {module_M : Module R M}
      (p : Submodule R M) {x : M} [inst_2 : SMul S R] [inst_3 : SMul S M] [inst_4 : IsScalarTower S R M] (r : S),
      x ∈ p → r • x ∈ p :=
  by sorry

This theorem states that for any types `S`, `R`, and `M`, where `R` is a semiring, `M` is an additive commutative monoid, and `M` is a `R`-Module, given a submodule `p` of `M` over `R`, any element `x` of `M`, and operations of scalar multiplication of `S` on `R` and `M`, if `S`, `R`, and `M` form a scalar tower, then for any scalar `r` from `S`, if `x` is an element of the submodule `p`, then `r` scaled by `x`, denoted as `r • x`, is also an element of the submodule `p`.

In other words, it states that a submodule of a module is closed under scalar multiplication, in the context of a scalar tower. A scalar tower is a situation where scalar multiplication is compatible in a layered manner, i.e., for three types `S`, `R`, and `M`, if `S` and `R` are semirings, `M` is an `R`-module, and there is scalar multiplication of `S` on `R` and `M`, the multiplication `s • (r • m)` is the same as `(s • r) • m` for any `s` in `S`, `r` in `R`, and `m` in `M`.

In a scalar tower of types `S`, `R`, and `M` where `M` is an additive commutative `R`-module, any submodule `p` of `M` is closed under scalar multiplication by elements of `S`.


theorem List.elem_eq_true_of_mem :
    ∀ {α : Type u} [inst : BEq α] [inst_1 : LawfulBEq α] {a : α} {as : List α}, a ∈ as → List.elem a as = true := by
  sorry

The theorem `List.elem_eq_true_of_mem` states that for any type `α` with a defined equality operation (`BEq α`), any lawful B equivalence relation (`LawfulBEq α`), and any element `a` of type `α` and list `as` of type `List α`, if the element `a` belongs to the list `as` (denoted by `a ∈ as`), then the function `List.elem a as` equals `true`. This describes that if an element is in a list, then the list's `elem` function will correctly identify that the element is present.

For any type `α` with equality `BEq α` and lawful B equivalence relation `LawfulBEq α`, if `a ∈ as` then `List.elem a as = true`.


theorem AddMonoid.addOrderOf_eq_one_iff : ∀ {G : Type u_1} [inst : AddMonoid G] {x : G}, addOrderOf x = 1 ↔ x = 0 := by
  sorry

The theorem `AddMonoid.addOrderOf_eq_one_iff` states that for any type `G` that has an additive monoid structure, given an element `x` of `G`, the "additive order" of `x` is equal to 1 if and only if `x` is the additive identity (0) of the monoid. In other words, in any additive monoid, an element has order 1 (the minimal number of times the element needs to be added to itself to reach the identity) if and only if it is the identity element.

For any additive monoid G and its element x, x has additive order 1 if and only if x is the additive identity of G.


theorem Filter.HasBasis.exists_iff :
    ∀ {α : Type u_1} {ι : Sort u_4} {l : Filter α} {p : ι → Prop} {s : ι → Set α},
      Filter.HasBasis l p s →
        ∀ {P : Set α → Prop}, (∀ ⦃s t : Set α⦄, s ⊆ t → P t → P s) → ((∃ s ∈ l, P s) ↔ ∃ i, p i ∧ P (s i)) :=
  by sorry

The theorem `Filter.HasBasis.exists_iff` states that for any type `α`, any type of sorting `ι`, any filter `l` of type `α`, any property `p` of `ι`, and any function `s` from `ι` to a set of `α`, if `l` has a basis given by `p` and `s`, then for any property `P` of a set of `α` that is preserved under taking subsets, there exists a set `s` in `l` such that `P` holds for `s` if and only if there exists an index `i` such that `p` holds for `i` and `P` holds for `s(i)`.

In other words, it translates the existence of a certain property in a filter to an equivalent formulation in terms of its basis.

For any filter `l` on type `α`, property `p` of indices, and set-preserving property `P` on subsets of `α`, if `l` has basis `s` given by `p`, then `P` holds for some element in `l` if and only if there exists an index `i` such that both `p(i)` holds and `P(s(i))` holds.


theorem CategoryTheory.Functor.map_zsmul :
    ∀ {C : Type u_1} {D : Type u_2} [inst : CategoryTheory.Category.{u_4, u_1} C]
      [inst_1 : CategoryTheory.Category.{u_5, u_2} D] [inst_2 : CategoryTheory.Preadditive C]
      [inst_3 : CategoryTheory.Preadditive D] (F : CategoryTheory.Functor C D)
      [inst_4 : CategoryTheory.Functor.Additive F] {X Y : C} {f : X ⟶ Y} {r : ℤ}, F.map (r • f) = r • F.map f :=
  by sorry

This theorem states that for all categories `C` and `D`, if `C` and `D` are preadditive categories and `F` is an additive functor from `C` to `D`, then for all objects `X` and `Y` in `C` and a morphism `f` from `X` to `Y`, and an integer `r`, the functor `F` applied to the morphism `r` times `f` equals `r` times the functor `F` applied to `f`. This is a property that shows the interplay between functors and scalars in additive categories.

For all preadditive categories `C` and `D`, and additive functor `F` from `C` to `D`, given objects `X` and `Y` in `C`, and a morphism `f` from `X` to `Y`, the functor `F` commutes with scalar multiplication, i.e., `F(rf) = r(F(f))`.


theorem Algebra.charP_iff :
    ∀ (K : Type u_1) (L : Type u_2) [inst : Field K] [inst_1 : CommSemiring L] [inst_2 : Nontrivial L]
      [inst_3 : Algebra K L] (p : ℕ), CharP K p ↔ CharP L p :=
  by sorry

The theorem `Algebra.charP_iff` states that for any two types `K` and `L`, where `K` is a field, `L` is a commutative semiring, and `L` is nontrivial and also an algebra over `K`, a natural number `p` is the characteristic of `K` if and only if `p` is the characteristic of `L`. The characteristic of a ring is the smallest positive integer such that multiplying the ring's multiplicative identity by this integer results in the ring's additive identity, if such an integer exists. Otherwise, the characteristic is defined to be zero.

The characteristic of a field `K` is equal to the characteristic of a commutative semiring `L` that is an algebra over `K`, if `L` is a nontrivial commutative semiring.


theorem Nat.mul_dvd_of_dvd_div : ∀ {a b c : ℕ}, c ∣ b → a ∣ b / c → c * a ∣ b := by sorry

This theorem states that for any three natural numbers `a`, `b`, and `c`, if `c` divides `b` and `a` divides the result of `b` divided by `c`, then `c` times `a` must divide `b`. This theorem is a property of divisibility and division in the domain of natural numbers.

If `c` divides `b` and `a` divides `b` divided by `c`, then `c` times `a` divides `b`.


theorem abs_eq_neg_self : ∀ {α : Type u_1} [inst : LinearOrderedAddCommGroup α] {a : α}, |a| = -a ↔ a ≤ 0 := by sorry

This theorem states that for any type `α` that is a linear ordered additive commutative group, for an element `a` of type `α`, the absolute value of `a` is equal to the negative of `a` if and only if `a` is less than or equal to zero. Essentially, it ties the properties of absolute values and negation with the ordering of elements in the group, specifically for non-positive elements.

For any linear ordered additive commutative group type `α` and element `a` of `α`, |a| = -a if and only if a ≤ 0.


theorem Basis.equiv_apply :
    ∀ {ι : Type u_1} {ι' : Type u_2} {R : Type u_3} {M : Type u_6} {M' : Type u_7} [inst : Semiring R]
      [inst_1 : AddCommMonoid M] [inst_2 : Module R M] [inst_3 : AddCommMonoid M'] [inst_4 : Module R M']
      (b : Basis ι R M) (i : ι) (b' : Basis ι' R M') (e : ι ≃ ι'), (Basis.equiv b b' e) (b i) = b' (e i) :=
  by sorry

This theorem states that for any semiring `R`, additively commutative monoids `M` and `M'`, and types `ι` and `ι'`, given a basis `b` for `M` over `R` indexed by `ι`, another basis `b'` for `M'` over `R` indexed by `ι'`, and a bijection `e` between `ι` and `ι'`, applying the equivalence between the two bases to `b i` results in `b'` at the index `e i`. In other words, it shows how elements from one basis get mapped to elements in the other basis under the given bijection between their indices.

Given semirings `R`, additively commutative monoids `M` and `M'`, bases `b: M → ι → R` and `b': M' → ι' → R` for `M` and `M'` over `R`, and a bijection `e: ι ≃ ι'`, we have `b' (e x) = b x` for all `x ∈ ι`.


theorem Nat.modEq_zero_iff : ∀ {a b : ℕ}, a ≡ b [MOD 0] ↔ a = b := by sorry

This theorem establishes a relationship between the modulus operation and equality in natural numbers (ℕ). Specifically, it states that for every pair of natural numbers `a` and `b`, `a` is congruent to `b` modulo 0 if and only if `a` is equal to `b`. In other words, the modulus of `a` divided by `b` is zero only when `a` and `b` are the same number.

For all natural numbers `a` and `b`, `a` is congruent to `b` modulo 0 if and only if `a` equals `b`. In other words, `a % b = 0` if and only if `a = b`.


theorem sInf_lt_iff :
    ∀ {α : Type u_1} [inst : CompleteLinearOrder α] {s : Set α} {b : α}, sInf s < b ↔ ∃ a ∈ s, a < b := by sorry

This theorem states that for any type `α` which has a `CompleteLinearOrder` structure, and for any set `s` of elements of type `α` and any element `b` of type `α`, the infimum (greatest lower bound) of the set `s` is less than `b` if and only if there exists an element `a` in the set `s` such that `a` is less than `b`. In mathematical terms, it is saying that $\inf(s) < b$ if and only if there is some $a \in s$ such that $a < b$.

For any set `s` of elements in a type `α` with a `CompleteLinearOrder` structure and any `α` element `b`, the infimum of `s` is strictly less than `b` if and only if there exists an element `a` in `s` such that `a` is strictly less than `b`.


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

This theorem, `geom_sum₂_mul`, states that for any type `α` equipped with a commutative ring structure, and for any elements `x` and `y` of this type, and a natural number `n`, the sum, over all natural numbers less than `n`, of the product of `x` raised to a given number and `y` raised to the difference between `n - 1` and that number, all multiplied by the difference `x - y`, equals the difference between `x` raised to the `n`th power and `y` raised to the `n`th power. In mathematical notation, this is:
\[
\left(\sum_{i=0}^{n-1} x^i \cdot y^{n-1-i}\right) \cdot (x - y) = x^n - y^n
\]
This is a specific form of the geometric sum formula.

For any commutative ring `α` and natural number `n`, the geometric sum of `x^i * y^(n-1-i)` for `i` from `0` to `n-1` equals `(x^n - y^n) / (x - y)`.


theorem closure_singleton :
    ∀ {X : Type u_1} [inst : TopologicalSpace X] [inst_1 : T1Space X] {x : X}, closure {x} = {x} := by sorry

The theorem `closure_singleton` states that for any type `X` equipped with a topology (represented by `TopologicalSpace X`) and having the T1 separation axiom (`T1Space X`), for any element `x` of `X`, the closure of the singleton set `{x}` is equal to the set `{x}` itself. In other words, in a T1 space, the closure of a set containing a single point is just the set containing that point.

In a T1 topological space, the closure of a singleton set is equal to that set.


theorem Equiv.image_preimage : ∀ {α : Type u_1} {β : Type u_2} (e : α ≃ β) (s : Set β), ⇑e '' (⇑e ⁻¹' s) = s := by sorry

The theorem `Equiv.image_preimage` states that for any two types `α` and `β`, given an equivalence `e` between these types and a set `s` of type `β`, the image under `e` of the preimage under `e` of the set `s` is equal to `s` itself. In other words, if you first apply the inverse of `e` to `s` and then apply `e` to the result, you get back `s`. This theorem is a formal statement of the property that the composition of a function and its inverse yields the original input, in the context of set membership.

For any equivalence relation `e` between types `α` and `β` and set `s` of type `β`, `e''(e⁻¹[s]) = s`. (Here, `e⁻¹[s]` denotes the preimage of `s` under `e`, and `e''` denotes the image of a set under `e`.)


theorem MonoidHom.coe_mk :
    ∀ {M : Type u_4} {N : Type u_5} [inst : MulOneClass M] [inst_1 : MulOneClass N] (f : OneHom M N)
      (hmul : ∀ (x y : M), f.toFun (x * y) = f.toFun x * f.toFun y), ⇑{ toOneHom := f, map_mul' := hmul } = ⇑f :=
  by sorry

This theorem states that for any two types `M` and `N` which both are instances of the `MulOneClass` (meaning they support multiplication and have a multiplicative identity), given a homomorphism `f` from `M` to `N` that preserves the identity, and a proof `hmul` that `f` also preserves multiplication, the function obtained by applying the coercion function `⇑` (which extracts the function part from the homomorphism) to the `MonoidHom` created from `f` and `hmul` is the same as the function obtained by applying `⇑` directly to `f`. In simpler terms, creating a `MonoidHom` from `f` and then extracting the function from it gives us back the original function `f`.

For any homomorphism `f` between multiplicative monoids `M` and `N` preserving identity and multiplication, the extracted function from the `MonoidHom` construction is equal to `f` itself.


theorem FractionalIdeal.spanSingleton_def :
    ∀ {R : Type u_5} [inst : CommRing R] (S : Submonoid R) {P : Type u_6} [inst_1 : CommRing P] [inst_2 : Algebra R P]
      [loc : IsLocalization S P] (x : P),
      FractionalIdeal.spanSingleton S x = { val := Submodule.span R {x}, property := ⋯ } :=
  by sorry

The theorem `FractionalIdeal.spanSingleton_def` states that for any commutative ring `R`, a submonoid `S` of `R`, a commutative ring `P`, an algebra structure on `R` and `P`, and a localization `loc` of `S` in `P`, and for any element `x` of `P`, the fractional ideal generated by `x` (denoted as `FractionalIdeal.spanSingleton S x`) is equal to the set containing the submodule of `R` spanned by `{x}`. This defines the action of `spanSingleton` on a single element of the ring `P`. The property part of the fractional ideal is omitted for brevity.

For any commutative ring `R`, submonoid `S` of `R`, commutative ring `P`, algebra structure on `R` and `P`, localization `loc` of `S` in `P`, and element `x` of `P`, the fractional ideal generated by `x` equals the submodule of `R` spanned by `{x}`.


theorem MeasureTheory.Measure.count_apply :
    ∀ {α : Type u_1} [inst : MeasurableSpace α] {s : Set α},
      MeasurableSet s → ↑↑MeasureTheory.Measure.count s = ∑' (i : ↑s), 1 :=
  by sorry

This theorem states that for any type `α` and any measurable set `s` of `α` (in the given measurable space), the counting measure of `s` is equivalent to the sum of `1` for each element `i` in `s`. In other words, the counting measure of a measurable set is simply the number of elements in the set.

For any measurable set `s` in a given measurable space, the counting measure of `s` equals the cardinality of `s`.


theorem List.pmap_eq_map_attach :
    ∀ {α : Type u} {β : Type v} {p : α → Prop} (f : (a : α) → p a → β) (l : List α) (H : ∀ a ∈ l, p a),
      List.pmap f l H = List.map (fun x => f ↑x ⋯) (List.attach l) :=
  by sorry

This theorem, `List.pmap_eq_map_attach`, states that for any types `α` and `β`, a predicate `p : α → Prop`, a function `f : (a : α) → p a → β`, a list `l` of type `List α`, and a proof `H` that for all elements `a` in `l`, `p a` holds, the process of applying `f` to every element in `l` along with the proof `H` (i.e., `List.pmap f l H`) is equivalent to first attaching each element of `l` to its proof that it belongs to `l` (i.e., `List.attach l`) and then applying `f` to these pairs. The latter process involves applying `f` to the elements and "unpacking" them from the subtype `{x // x ∈ l}` back to the original type `α` using the coercion function `↑x`.

For any type `α`, predicate `p : α → Prop`, function `f : (a : α) → p a → β`, list `l : List α`, and proof `H : ∀ a ∈ l, p a`, `List.pmap f l H` is equivalent to `List.attach l ▸ List.map (λ x ▸ (x, rfl)) (List.map p l) ▸ List.map (λ x, f x rfl) (List.map (λ x, ⟨x, rfl⟩) l)`.


/-- The seminorm of an element in a product space is `≤ r` if and only if the norm of each
component is.  -/
theorem pi_norm_le_iff_of_nonneg' :
    ∀ {ι : Type u_4} {π : ι → Type u_9} [inst : Fintype ι] [inst_1 : (i : ι) → SeminormedGroup (π i)]
      {x : (i : ι) → π i} {r : ℝ}, 0 ≤ r → (‖x‖ ≤ r ↔ ∀ (i : ι), ‖x i‖ ≤ r) :=
  by sorry

This theorem states that for a given element 'x' in a product space, generated over a finite type 'ι' with each component being a seminormed group, the seminorm of 'x' is less than or equal to a non-negative real number 'r' if and only if the norm of each individual component of 'x' is less than or equal to 'r'. In other words, it provides a condition on the seminorm of an element in a product space based on the norms of its individual components.

For an element x in the product of seminormed groups indexed by a finite type ι, the seminorm of x is less than or equal to r if and only if the norm of each component of x is less than or equal to r.


theorem Monoid.CoprodI.Word.equivPair_symm :
    ∀ {ι : Type u_1} {M : ι → Type u_2} [inst : (i : ι) → Monoid (M i)] [inst_1 : (i : ι) → DecidableEq (M i)]
      [inst_2 : DecidableEq ι] (i : ι) (p : Monoid.CoprodI.Word.Pair M i),
      (Monoid.CoprodI.Word.equivPair i).symm p = Monoid.CoprodI.Word.rcons p :=
  by sorry

The theorem `Monoid.CoprodI.Word.equivPair_symm` asserts that for any type `ι`, any function `M` mapping elements of `ι` to types, any monoid structure on each `M i`, any decidable equality on each `M i` and on `ι`, for any `i` in `ι` and any pair `p` in the word pair of the coproduct of monoids `M i`, applying the inverse of the equivalence `Monoid.CoprodI.Word.equivPair` on `p` yields the same result as applying the function `Monoid.CoprodI.Word.rcons` on `p`. Specifically, `Monoid.CoprodI.Word.rcons` forms a word by prepending the `head` of the pair to the `tail`, except if the `head` is the unit element of the monoid, in which case it just returns the `tail`. This theorem asserts that this process of forming a word is in a sense inverse to the operation `Monoid.CoprodI.Word.equivPair`.

For any monoid family `M` over a type `ι`, the inverse of the equivalence `Monoid.CoprodI.Word.equivPair` on a pair in the coproduct of words equals applying the function `Monoid.CoprodI.Word.rcons` to the pair.


theorem isLittleO_pow_pow_of_lt_left :
    ∀ {r₁ r₂ : ℝ}, 0 ≤ r₁ → r₁ < r₂ → (fun n => r₁ ^ n) =o[Filter.atTop] fun n => r₂ ^ n := by sorry

This theorem states that for any real numbers `r₁` and `r₂` with `r₁` nonnegative and less than `r₂`, the function that takes an integer `n` to `r₁^n` is `little o` (is dominated by) the function that takes `n` to `r₂^n` as `n` goes to infinity. In mathematical terms, this means that `r₁^n = o(r₂^n)` as `n → ∞`, which is to say, the growth rate of `r₁^n` is strictly less than the growth rate of `r₂^n` when `r₁ < r₂` and `r₁` is nonnegative.

For any nonnegative real number `r₁` less than `r₂`, `r₁^n = o(r₂^n)` as `n → ∞`.


theorem Cardinal.lift_mk_fin : ∀ (n : ℕ), Cardinal.lift.{u_1, 0} (Cardinal.mk (Fin n)) = ↑n := by sorry

This theorem states that for any natural number `n`, lifting the cardinality of the finite type `Fin n` from universe 0 to any universe `u_1` is equal to `n`. Here, `Fin n` is a type that represents numbers less than `n`, so its cardinality is `n`. The "universe lift operation" on cardinals, denoted by `Cardinal.lift`, allows us to lift a cardinal from a certain universe to a higher one, and `Cardinal.mk` is a function that gives us the cardinal number of a type. The theorem therefore confirms that lifting the cardinality doesn't change the size of the set, even when we change the universe of the set.

The cardinality of the finite type `Fin n` is equal to `Cardinal.lift (Cardinal.mk n)`, where `Cardinal.lift` lifts the cardinality from universe 0 to any universe `u_1`.


theorem isEmpty_iff : ∀ {α : Sort u_1}, IsEmpty α ↔ α → False := by sorry

This theorem, `isEmpty_iff`, states that for any type `α`, the type is `IsEmpty` (i.e., it has no elements) if and only if any function from `α` to `False` (i.e., a function that can't be defined because it can't produce any outputs given inputs from `α`). In other words, a type is empty if there is no possible way to construct an element of that type, which is equivalent to saying there can be no function that produces a `False` value from an element of that type because such elements don't exist.

A type `α` is empty if and only if there exists no function from `α` to `False`.


theorem Set.inv_singleton : ∀ {α : Type u_2} [inst : InvolutiveInv α] (a : α), {a}⁻¹ = {a⁻¹} := by sorry

This theorem states that for any type `α` with an involutive inverse operation (a function which is its own inverse), the inverse of a singleton set containing an element `a` of type `α` is equal to the singleton set containing the inverse of `a`. In mathematical terms, this can be written as `({a}^-1 = {a^-1})` for all `a` in `α`, where `α` is equipped with an involutive inverse operation.

For any type `α` with an involutive inverse operation, the singleton set with inverse element equals the singleton set with the original element: {a^-1} = {x | x = a^-1}.


theorem omegaLimit_mono_right :
    ∀ {τ : Type u_1} {α : Type u_2} {β : Type u_3} [inst : TopologicalSpace β] (f : Filter τ) (ϕ : τ → α → β)
      {s₁ s₂ : Set α}, s₁ ⊆ s₂ → omegaLimit f ϕ s₁ ⊆ omegaLimit f ϕ s₂ :=
  by sorry

The `omegaLimit_mono_right` theorem states that for any types `τ`, `α` and `β` where `β` possesses a topology, any filter `f` over `τ`, and any function `ϕ` mapping from `τ × α` to `β`, if we have two sets `s₁` and `s₂` of type `α` such that `s₁` is a subset of `s₂`, then the ω-limit of `s₁` under `ϕ` with respect to filter `f` is also a subset of the ω-limit of `s₂` under `ϕ` with respect to the same filter `f`. In other words, if an input set is a subset of another, their respective ω-limits follow the same subset relation.

If `s₁ ⊆ s₂` are subsets of `α`, then the ω-limit of `s₁` under a function `ϕ` with respect to filter `f` over `τ` is a subset of the ω-limit of `s₂` under the same function and filter.


theorem OrderIso.isAtom_iff :
    ∀ {α : Type u_1} {β : Type u_2} [inst : PartialOrder α] [inst_1 : PartialOrder β] [inst_2 : OrderBot α]
      [inst_3 : OrderBot β] (f : α ≃o β) (a : α), IsAtom (f a) ↔ IsAtom a :=
  by sorry

The theorem `OrderIso.isAtom_iff` states that for any types `α` and `β`, each equipped with partial order structures and a least element (`OrderBot`), if `f` is an order isomorphism (bijective and order-preserving function) from `α` to `β` and `a` is an element of `α`, then `a` being an atom in `α` is equivalent to `f(a)` being an atom in `β`. In other words, `a` is an atom in `α` (meaning `a` is not the least element and there's no other element between `a` and the least element) if and only if its image under `f`, `f(a)`, is an atom in `β`.

For any order isomorphisms between partially ordered types with least elements, the image of an atom under the function is an atom in the image type.


theorem orderOf_eq_card_of_forall_mem_zpowers :
    ∀ {α : Type u} [inst : Group α] [inst_1 : Fintype α] {g : α},
      (∀ (x : α), x ∈ Subgroup.zpowers g) → orderOf g = Fintype.card α :=
  by sorry

The theorem `orderOf_eq_card_of_forall_mem_zpowers` states that for any type `α` that forms a group (`Group α`) and is finitely enumerable (`Fintype α`), and for any element `g` of this group, if every element `x` of the group is in the subgroup generated by `g` (i.e., every element can be expressed as some power of `g`), then the order of the element `g` (the smallest positive integer `n` such that `g` to the power `n` equals the identity element, or `0` if no such `n` exists) is equal to the number of elements in the group `α`. In other words, when a group element generates all elements in the group, its order equals the size of the group.

If `α` is a finitely enumerable group, then the order of any element `g` generating all elements of `α` is equal to the cardinality of `α`.


theorem Mathlib.Analysis.PSeries._auxLemma.10 : ∀ {p : ℝ}, (Summable fun n => (↑n ^ p)⁻¹) = (1 < p) := by sorry

This theorem, `Mathlib.Analysis.PSeries._auxLemma.10`, states that for any real number `p`, the function `f(n) = (n^p)^-1` is summable if and only if `p` is greater than 1. Here, 'summable' means that the infinite series sum of `f(n)` exists. In mathematical notation, this would be equivalent to saying: the series $\sum_{n=1}^{\infty} n^{-p}$ converges if and only if $p > 1$.

The series $\sum\_{n=1}^{\infty} n^{-p}$ converges if and only if $p > 1$.


theorem Subgroup.IsComplement.equiv_fst_eq_mul_inv :
    ∀ {G : Type u_1} [inst : Group G] {S T : Set G} (hST : Subgroup.IsComplement S T) (g : G),
      ↑((Subgroup.IsComplement.equiv hST) g).1 = g * (↑((Subgroup.IsComplement.equiv hST) g).2)⁻¹ :=
  by sorry

This theorem states that for any group `G` and any sets `S` and `T` of `G`, if `S` and `T` are complements, meaning that the function which multiplies an element of `S` with an element of `T` is a bijection, then for any element `g` of the group, the first component of the equivalence of `g` under the established bijection equals `g` times the inverse of the second component of the equivalence of `g`. In simpler terms, it's saying that if `S` and `T` perfectly cover `G` when multiplied together, then a certain property holds true for every element in the group, specifically concerning the element's representation under the bijection.

For any group `G` and complementary sets `S` and `T` such that the function `x ↦ x * y` is a bijection for all `x ∈ S` and `y ∈ T`, then for all `g ∈ G`, we have `(eq.refl g).1 = g * inv (eq.refl g).2`.


Group.isUnit

theorem Group.isUnit : ∀ {α : Type u} [inst : Group α] (a : α), IsUnit a := by sorry

This theorem states that for any type `α` that forms a group (denoted by `[inst : Group α]`), every element `a` of type `α` is a unit. In mathematical terms, this states that every element of a group has a two-sided inverse, meaning for any element `a` in a group there exists an element `u` such that the multiplication of `a` and `u` (in either order) equals the identity element of the group. This property holds for all groups and is one of the defining characteristics of a group in algebra.

Every element in a group has a two-sided inverse.


theorem SetTheory.PGame.lf_iff_lt :
    ∀ {x y : SetTheory.PGame},
      SetTheory.PGame.Numeric x → SetTheory.PGame.Numeric y → (SetTheory.PGame.LF x y ↔ x < y) :=
  by sorry

The theorem `SetTheory.PGame.lf_iff_lt` states that for any two pre-games `x` and `y`, if both `x` and `y` are numeric pre-games, then `x` is less fuzzy (`LF`) than `y` if and only if `x` is less than `y`. Here, a pre-game is called numeric if for every pair of elements from its left (`L`) and right (`R`) sets, the left element is less than the right one, and all elements of `L` and `R` are numeric themselves. The less fuzzy (`LF`) relation on pre-games is defined such that if `0` is not less than or equal to `x`, then the Left player can win `x` as the first player.

For any numeric pre-games x and y, x is less fuzzy than y if and only if x is strictly less than y.


theorem Finset.eq_univ_of_card :
    ∀ {α : Type u_1} [inst : Fintype α] (s : Finset α), s.card = Fintype.card α → s = Finset.univ := by sorry

This theorem states that for any finite type `α` and any finite set `s` of type `α`, if the cardinality (or the number of elements) of `s` is equal to the cardinality of `α`, then `s` must be the universal set of `α`. In other words, if a set contains as many elements as the entire finite type it is drawn from, it must contain all elements of that type.

If a finite set has the same cardinality as a finite type, then the set is the type's universe.


theorem Filter.exists_lt_of_tendsto_atTop :
    ∀ {α : Type u_3} {β : Type u_4} [inst : SemilatticeSup α] [inst_1 : Preorder β] [inst_2 : NoMaxOrder β] {u : α → β},
      Filter.Tendsto u Filter.atTop Filter.atTop → ∀ (a : α) (b : β), ∃ a' ≥ a, b < u a' :=
  by sorry

The theorem `Filter.exists_lt_of_tendsto_atTop` states that for any function `u` from a type `α` with a semilattice sup structure to a type `β` with a preorder structure and no maximum element, if the function `u` tends to infinity as the input tends to infinity (captured by `Filter.Tendsto u Filter.atTop Filter.atTop`), then for any elements `a` in `α` and `b` in `β`, there exists an element `a'` in `α` such that `a'` is greater than or equal to `a` and `u(a')` is strictly greater than `b`. In other words, if a function tends towards infinity as its input grows, you can always find a large enough input value such that the function value at that input point exceeds any given target.

For any function from a semilattice without a maximum element to a preorder without a maximum element that tends to infinity, there exists an input element greater than any given input such that the function value at the larger input strictly exceeds the given output.


theorem Finset.filter_congr :
    ∀ {α : Type u_1} {p q : α → Prop} [inst : DecidablePred p] [inst_1 : DecidablePred q] {s : Finset α},
      (∀ x ∈ s, p x ↔ q x) → Finset.filter p s = Finset.filter q s :=
  by sorry

The theorem `Finset.filter_congr` states that for any set `s` of elements of an arbitrary type `α`, and two predicates `p` and `q` that are decidable for every element of `α`, if for every element `x` in `s`, `x` satisfies `p` if and only if `x` satisfies `q`, then the set of elements of `s` that satisfy `p` (obtained using the `Finset.filter` function) is equal to the set of elements of `s` that satisfy `q`. In other words, if two conditions `p` and `q` are equivalent for all elements in a given set, filtering the set with either condition will result in the same set.

If `p` and `q` are equivalent predicates on a set `s`, then `Finset.filter s p` equals `Finset.filter s q`.


theorem CategoryTheory.ShortComplex.SnakeInput.δ.proof_2 :
    ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Abelian C]
      (S : CategoryTheory.ShortComplex.SnakeInput C),
      CategoryTheory.CategoryStruct.comp (CategoryTheory.ShortComplex.SnakeInput.L₀' S).f
          (CategoryTheory.CategoryStruct.comp (CategoryTheory.ShortComplex.SnakeInput.φ₁ S) S.v₂₃.τ₁) =
        0 :=
  by sorry

This theorem states that for any category `C` of Abelian type, and any short complex `S`, the composition of the morphism `f` from the short complex `L₀'` of `S` and the composition of the canonical map `φ₁` from `S` and `τ₁` from the third step of `v₂₃` of `S` is equal to zero. In mathematical terms, this corresponds to the condition of exactness in a short exact sequence in the category of chain complexes, where the composition of certain morphisms results in the zero morphism.

For any short complex `S` in an Abelian category `C`, the composition of the morphisms from the first complex in `S` to the third complex in `S` via `τ₁` and `φ₁`, and from the first complex in `S` to the second complex in `S` via `f` from the first complex in `L₀'`, is the zero morphism.


theorem isClosed_induced_iff :
    ∀ {α : Type u_1} {β : Type u_2} [t : TopologicalSpace β] {s : Set α} {f : α → β},
      IsClosed s ↔ ∃ t_1, IsClosed t_1 ∧ f ⁻¹' t_1 = s :=
  by sorry

This theorem states that for any types `α` and `β`, and for any topological space `t` over `β`, a set `s` of type `α` is closed if and only if there exists another set `t_1` such that `t_1` is closed and `t_1` is the preimage of the function `f` from `α` to `β` applied to `s`. In other words, `s` is closed under the topology induced by `f` if there is a closed set in `β` that `f` maps `s` onto.

A set in type `α` is closed with respect to a topology `t` over `β` if and only if it is the preimage under `f` of some closed set in `β`.


theorem Filter.limsSup_le_of_le :
    ∀ {α : Type u_1} [inst : ConditionallyCompleteLattice α] {f : Filter α} {a : α},
      autoParam (Filter.IsCobounded (fun x x_1 => x ≤ x_1) f) _auto✝ →
        (∀ᶠ (n : α) in f, n ≤ a) → Filter.limsSup f ≤ a :=
  by sorry

The theorem `Filter.limsSup_le_of_le` states that for any type `α` that forms a conditionally complete lattice, given any filter `f` on `α` and any element `a` of `α`, if `f` is co-bounded with respect to the order relation `≤` (which is guaranteed by the `autoParam` condition) and every element `n` in the filter `f` is less than or equal to `a` (expressed as `∀ᶠ (n : α) in f, n ≤ a`), then the supremum limit (`limsSup`) of the filter `f` is less than or equal to `a`.

If `α` is a conditionally complete lattice, `f` is a co-bounded filter on `α`, and every `n` in `f` is less than or equal to `a`, then `limsSup(f) ≤ a`.


theorem intervalIntegrable_iff_integrableOn_Ioc_of_le :
    ∀ {E : Type u_3} [inst : NormedAddCommGroup E] {f : ℝ → E} {a b : ℝ} {μ : MeasureTheory.Measure ℝ},
      a ≤ b → (IntervalIntegrable f μ a b ↔ MeasureTheory.IntegrableOn f (Set.Ioc a b) μ) :=
  by sorry

The theorem `intervalIntegrable_iff_integrableOn_Ioc_of_le` states that for all real-valued functions `f` and real numbers `a` and `b` (with `a` less than or equal to `b`), and given a measure `μ`, then the function `f` is interval integrable on the interval from `a` to `b` with respect to the measure `μ` if and only if `f` is integrable on the left-open right-closed interval from `a` to `b` with respect to the measure. Essentially, this theorem establishes an equivalence between the interval integrability of a function and its integrability over a left-open right-closed interval under the condition that the lower bound is less than or equal to the upper bound.

A real-valued function is interval integrable on [a, b] with respect to a measure if and only if it is integrable on the left-open right-closed interval Ioc(a, b) with respect to that measure.


theorem measurable_from_top : ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace β] {f : α → β}, Measurable f := by
  sorry

The theorem `measurable_from_top` states that for any two types `α` and `β` where `β` is a measurable space, and for any function `f` from `α` to `β`, the function `f` is measurable. In other words, for any set in `β` that is measurable, the preimage of that set under `f` is also measurable. This holds regardless of the measurable structure (or even the lack of it) on `α`, hence the name "from top".

If `β` is a measurable space and `f` is a function from type `α` to `β`, then `f` is measurable, meaning for any measurable set `S` in `β`, the preimage `f⁻¹(S)` in `α` is also measurable.


/-- If `B/K` is a nontrivial algebra over a field, and `x` is an element of `K`,
then the minimal polynomial of `algebraMap K B x` is `X - C x`.  -/
theorem minpoly.eq_X_sub_C :
    ∀ {A : Type u_1} (B : Type u_2) [inst : Field A] [inst_1 : Ring B] [inst_2 : Algebra A B] [inst_3 : Nontrivial B]
      (a : A), minpoly A ((algebraMap A B) a) = Polynomial.X - Polynomial.C a :=
  by sorry

This theorem states that if `B/K` is a nontrivial algebra over a field, and `x` is an element of `K`, then the minimal polynomial of the algebraic embedding of `x` into `B` (denoted by `algebraMap K B x`) is `X - C x`. Here, `X` represents the polynomial variable (also known as the indeterminate) and `C x` is the constant polynomial `x`. This result is a fundamental fact about minimal polynomials in field theory and algebra.

The minimal polynomial of the algebraic embedding of an element `x` in a field extension `B/K` is `X - C x`, where `C x` is the constant polynomial equal to `x`.


Nat.ModEq.mul

theorem Nat.ModEq.mul : ∀ {n a b c d : ℕ}, a ≡ b [MOD n] → c ≡ d [MOD n] → a * c ≡ b * d [MOD n] := by sorry

This theorem, `Nat.ModEq.mul`, states that for any natural numbers `n`, `a`, `b`, `c`, `d`, if `a` is equivalent to `b` modulo `n` and `c` is equivalent to `d` modulo `n`, then the product of `a` and `c` is equivalent to the product of `b` and `d` modulo `n`. In mathematical notation, this is saying if a ≡ b (mod n) and c ≡ d (mod n), then a*c ≡ b*d (mod n).

If `a` is congruent to `b` and `c` is congruent to `d` modulo `n`, then `ac` is congruent to `bd` modulo `n`.


Diffeomorph.continuous

theorem Diffeomorph.continuous :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {E' : Type u_3} [inst_3 : NormedAddCommGroup E'] [inst_4 : NormedSpace 𝕜 E']
      {H : Type u_5} [inst_5 : TopologicalSpace H] {H' : Type u_6} [inst_6 : TopologicalSpace H']
      {I : ModelWithCorners 𝕜 E H} {I' : ModelWithCorners 𝕜 E' H'} {M : Type u_9} [inst_7 : TopologicalSpace M]
      [inst_8 : ChartedSpace H M] {M' : Type u_10} [inst_9 : TopologicalSpace M'] [inst_10 : ChartedSpace H' M']
      {n : ℕ∞} (h : Diffeomorph I I' M M' n), Continuous ⇑h :=
  by sorry

This theorem states that for any nontrivially normed field 𝕜, normed additive commutative groups E and E', normed spaces over 𝕜 E and E', topological spaces H and H', models with corners I and I' for 𝕜 with respect to E and H, and I' for 𝕜 with respect to E' and H', topological spaces M and M', charted spaces M and M' with respect to H and H' respectively, and for any natural number or infinity (ℕ∞) n, if there exists a diffeomorphism h between I and I' which maps M to M' with smoothness level n, then the diffeomorphism h is continuous. In other words, a diffeomorphism that maps between two topological spaces is always a continuous function.

For any nontrivially normed fields 𝕜, normed additive commutative groups E and E', topological spaces H and H', and charted spaces M and M' over 𝕜 with respect to H and H' respectively, if there exists a diffeomorphism h between the models of 𝕜 in E and H, and h maps M to M' with smoothness level n, then h is continuous.


theorem List.chain'_singleton : ∀ {α : Type u} {R : α → α → Prop} (a : α), List.Chain' R [a] := by sorry

The theorem `List.chain'_singleton` states that for any type `α` and any binary relation `R` on `α`, the property that `R` holds between adjacent elements in a list is true for a singleton list (a list consisting of single element `a`). In other words, every singleton list satisfies the `Chain'` condition for any given relation, since there are no pairs of adjacent elements to compare.

For any type `α` and binary relation `R` on `α`, the singleton list `[a]` satisfies the `Chain'` condition `R` for all adjacent elements, since `R` holds vacuously.


theorem Filter.tendsto_pi :
    ∀ {ι : Type u_1} {α : ι → Type u_2} {f : (i : ι) → Filter (α i)} {β : Type u_3} {m : β → (i : ι) → α i}
      {l : Filter β}, Filter.Tendsto m l (Filter.pi f) ↔ ∀ (i : ι), Filter.Tendsto (fun x => m x i) l (f i) :=
  by sorry

The theorem `Filter.tendsto_pi` states that for any type `ι`, a function `α` indexed by `ι`, a collection of filters `f` for each type `α i`, a type `β`, a function `m` mapping from `β` to each `α i`, and a filter `l` on `β`, the function `m` tends to the product of the filters `f` as defined by `Filter.pi` with respect to the filter `l` if and only if, for each `i` in `ι`, the function `m` applied to `i` tends to the corresponding filter `f i` with respect to the filter `l`.  In other words, a function's limit with respect to a given filter is the product of the limits of the function applied to each element of the index set, each with respect to their corresponding filters.

For any type `ι`, function `α → β`, filters `f` on `α i`, and filter `l` on `β`, the function `α → Filter β` given by `m ↦ Filter.pi f m` tends to `l` if and only if for all `i` in `ι`, the function `m i` tends to `f i` with respect to `l`.


theorem not_isMin_of_lt : ∀ {α : Type u_1} [inst : Preorder α] {a b : α}, b < a → ¬IsMin a := by sorry

This theorem states that for any type `α` that has a preorder structure (a set equipped with a reflexive and transitive binary relation) and for any two elements `a` and `b` from that type, if `b` is strictly less than `a` then `a` cannot be a minimal element of `α`. Intuitively, this is saying that if there exists an element `b` that is strictly less than `a`, then `a` cannot be the smallest element in the set because there is at least one element `b` that is smaller.

If `α` is a type with a preorder relation and `a` is an element of `α` such that there exists `b` in `α` with `b < a`, then `a` cannot be a minimal element of `α`.


theorem List.eraseP_sublist : ∀ {α : Type u_1} {p : α → Bool} (l : List α), List.Sublist (List.eraseP p l) l := by sorry

The theorem `List.eraseP_sublist` states that for any type `α`, for any predicate function `p : α → Bool`, and any list `l : List α`, the list obtained by removing the first element of `l` that satisfies the predicate `p` (that is, `List.eraseP p l`), is a sublist of `l`. In other words, removing an element from a list (if it satisfies the given predicate), results in a sublist of the original list.

For any type `α`, any predicate `p : α → Bool`, and any list `l : List α`, `List.eraseP p l` is a sublist of `l`.


Units.isOpen

/-- The group of units of a complete normed ring is an open subset of the ring.  -/
theorem Units.isOpen : ∀ {R : Type u_1} [inst : NormedRing R] [inst_1 : CompleteSpace R], IsOpen {x | IsUnit x} := by
  sorry

This theorem states that for any complete normed ring `R`, the set of units in `R` forms an open subset of the ring. Here, a unit is defined as an element in the ring that has a two-sided inverse. An open set, in the context of the topological space associated with the ring, is a set where each point is an interior point. A complete space is a space in which every Cauchy sequence converges to a point in the same space.

The set of units in a complete normed ring forms an open subset of the ring.


theorem Mathlib.Topology.MetricSpace.PiNat._auxLemma.7 :
    ∀ {E : ℕ → Type u_1} {x y : (n : ℕ) → E n} {n : ℕ}, (y ∈ PiNat.cylinder x n) = ∀ i < n, y i = x i := by sorry

The theorem `Mathlib.Topology.MetricSpace.PiNat._auxLemma.7` states that for any set of types `E` indexed by natural numbers, any two sequences `x` and `y` of elements of the types `E` indexed by natural numbers, and any natural number `n`, the condition for `y` to be in the cylinder set of `x` of length `n` is that for every `i` less than `n`, the `i`th element of `y` equals the `i`th element of `x`. In other words, `y` is in the cylinder set of `x` of length `n` if and only if the first `n` elements of `y` and `x` are identical.

For any sequence of types indexed by natural numbers E, and any two sequences x and y of elements from E, the sequence y belongs to the cylinder set of length n around x if and only if the first n elements of y are equal to the first n elements of x.


theorem Sym.map_congr :
    ∀ {α : Type u_1} {β : Type u_2} {n : ℕ} {f g : α → β} {s : Sym α n},
      (∀ x ∈ s, f x = g x) → Sym.map f s = Sym.map g s :=
  by sorry

The theorem `Sym.map_congr` states that for any types `α` and `β`, any natural number `n`, any functions `f` and `g` from `α` to `β`, and any symmetric `n`-tuple `s` of elements of type `α`, if `f` and `g` agree on all elements in `s`, then the result of mapping `f` over `s` using the function `Sym.map` is equal to the result of mapping `g` over `s`. In other words, if two functions agree on the elements of a symmetric `n`-tuple, they induce the same function on the symmetric power of the tuple.

If functions $f$ and $g$ agree on components of a symmetric $n$-tuple $s$ in types $\alpha$ and $\beta$, then the application of the symmetric mapping `Sym.map` to $s$ with functions $f$ and $g$ results in equal outputs: $Sym.map(f)(s) = Sym.map(g)(s)$.


theorem derivWithin_of_isOpen :
    ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {F : Type v} [inst_1 : NormedAddCommGroup F]
      [inst_2 : NormedSpace 𝕜 F] {f : 𝕜 → F} {x : 𝕜} {s : Set 𝕜}, IsOpen s → x ∈ s → derivWithin f s x = deriv f x :=
  by sorry

The theorem `derivWithin_of_isOpen` states that for any nontrivially normed field `𝕜`, any normed additive commutative group `F`, and any function `f` from `𝕜` to `F`, if `s` is an open set in `𝕜` and `x` is an element of `s`, then the derivative of `f` at the point `x` within the set `s` equals the derivative of `f` at the point `x`. This implies that if `x` is in the interior of `s`, the derivative of `f` at `x` does not change whether we consider it within `s` or in the whole space `𝕜`.

If `𝕜` is a nontrivially normed field, `F` is a normed additive commutative group, `f` is a function from `𝕜` to `F`, `s` is an open set in `𝕜`, and `x` is an element of `s`, then the derivative of `f` at `x` within `s` equals the derivative of `f` at `x`.


theorem MeasureTheory.integrable_const_iff :
    ∀ {α : Type u_1} {β : Type u_2} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} [inst : NormedAddCommGroup β]
      {c : β}, MeasureTheory.Integrable (fun x => c) μ ↔ c = 0 ∨ ↑↑μ Set.univ < ⊤ :=
  by sorry

This theorem states that for any types `α` and `β`, a `measurable space α`, a `measure μ` on `α`, and a `normed add commutative group β`, a constant function `c: β` is integrable with respect to the measure `μ` if and only if either the constant function is zero or the measure of the universal set `Set.univ` is less than infinity. In simpler terms, a function that always returns a constant value is integrable if that constant is zero or if the entire space has finite measure.

A constant function from a measurable space to a normed add commutative group is integrable with respect to a measure if and only if the constant value is zero or the measure of the universal set has finite size.


ModelWithCorners.rightInvOn

theorem ModelWithCorners.rightInvOn :
    ∀ {𝕜 : 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),
      Set.RightInvOn (↑(ModelWithCorners.symm I)) (↑I) (Set.range ↑I) :=
  by sorry

This theorem states that for any ModelWithCorners `I` in a nontrivially normed field `𝕜`, with `E` being a normed additive commutative group over `𝕜` and `H` being a topological space, the inverse of `I` (obtained through the function `ModelWithCorners.symm`) is a right inverse to `I` on its range. In other words, for any point `x` in the range of `I`, we have `I (ModelWithCorners.symm I x) = x`.

For any `ModelWithCorners I` in a nontrivially normed field `𝕜`, the function `ModelWithCorners.symm I` is a right inverse to `I` on the range of `I`, i.e., `I (ModelWithCorners.symm I x) = x` for all `x` in the range of `I`.


theorem Ioo_mem_nhdsWithin_Iio' :
    ∀ {α : Type u} [inst : TopologicalSpace α] [inst_1 : LinearOrder α] [inst_2 : ClosedIicTopology α] {a b : α},
      a < b → Set.Ioo a b ∈ nhdsWithin b (Set.Iio b) :=
  by sorry

This theorem states that for any given type `α` that is a topological space and a linear order with a topology closed at `(-∞, c]`, and for any two elements `a` and `b` of this type such that `a` is less than `b`, the open interval from `a` to `b` (denoted `Set.Ioo a b`) is an element of the "neighborhood within" filter at `b` with respect to the left-infinite right-open interval up to `b` (denoted `nhdsWithin b (Set.Iio b)`). In other words, the open interval `(a, b)` is in the filter generated by intersecting the neighbourhood of `b` and the set of all elements less than `b`.

For any topological space and linear order `α` with `α` closed at `(-∞, c]`, and for all `a < b` in `α`, the open interval `(a, b)` is in the neighborhood filter at `b` with respect to the left-infinite right-open interval up to `b`.


theorem MeasureTheory.Measure.sum_cond :
    ∀ {α : Type u_1} {m0 : MeasurableSpace α} (μ ν : MeasureTheory.Measure α),
      (MeasureTheory.Measure.sum fun b => bif b then μ else ν) = μ + ν :=
  by sorry

This theorem, `MeasureTheory.Measure.sum_cond`, states that for any given measurable space 'α' and any two measures 'μ' and 'ν' on that measurable space, the sum of an indexed family of measures, where each measure is 'μ' if the index is true and 'ν' if the index is false, is equal to the sum of 'μ' and 'ν'. This theorem essentially describes a condition under which the sum of a family of measures simplifies to the sum of two measures.

For measurable spaces 'α' and measures 'μ' and 'ν' on it, the sum of an indexed family of measures, where each measure is 'μ' for true indices and 'ν' for false indices, equals the sum of 'μ' and 'ν'.


theorem CliffordAlgebra.involute_ι :
    ∀ {R : Type u_1} [inst : CommRing R] {M : Type u_2} [inst_1 : AddCommGroup M] [inst_2 : Module R M]
      {Q : QuadraticForm R M} (m : M), CliffordAlgebra.involute ((CliffordAlgebra.ι Q) m) = -(CliffordAlgebra.ι Q) m :=
  by sorry

The theorem `CliffordAlgebra.involute_ι` states that for any commutative ring `R`, any additive commutative group `M`, any `R`-module structure on `M`, and any quadratic form `Q` on `M` with coefficients in `R`, if you apply the canonical linear map `CliffordAlgebra.ι Q` on an element `m` of `M` and then apply the grade involution `CliffordAlgebra.involute`, it is equivalent to flipping the sign of the canonical linear map `CliffordAlgebra.ι Q` applied to `m`. In mathematical terms, this can be written as: for all `m` in `M`, the involution of the image of `m` under the canonical linear map is equal to the negative of the image of `m` under the canonical linear map.

For any quadratic form `Q` on an additive commutative group `M` over a commutative ring `R`, and for all `m` in `M`, the involution of `CliffordAlgebra.ι Q(m)` is equal to `-CliffordAlgebra.ι Q(m)`.


theorem RatFunc.liftMonoidWithZeroHom_apply_div :
    ∀ {K : Type u} [inst : CommRing K] [inst_1 : IsDomain K] {L : Type u_1} [inst_2 : CommGroupWithZero L]
      (φ : Polynomial K →*₀ L) (hφ : nonZeroDivisors (Polynomial K) ≤ Submonoid.comap φ (nonZeroDivisors L))
      (p q : Polynomial K),
      (RatFunc.liftMonoidWithZeroHom φ hφ)
          ((algebraMap (Polynomial K) (RatFunc K)) p / (algebraMap (Polynomial K) (RatFunc K)) q) =
        φ p / φ q :=
  by sorry

This theorem states that for any commutative ring `K` and commutative group with zero `L`, given a multiplication-preserving function `φ` from the polynomials over `K` to `L`, which respects the set of non-zero divisors in both structures, then for any two polynomials `p` and `q` in `K`, the result of mapping the ratio of `p` and `q` under the function `RatFunc.liftMonoidWithZeroHom φ hφ` (which lifts the function φ to the field of fractions) is equal to the ratio of φ applied to `p` and `q` separately. In mathematical terms, it states that given a homomorphism that preserves non-zero divisors, the homomorphism commutes with the forming of ratios in the field of fractions.

Given a homomorphism φ from the polynomial ring over a commutative ring to a commutative group that respects non-zero divisors, the ratio of polynomials in the field of fractions is equal to the ratio of their images under φ.


theorem gauge_smul_of_nonneg :
    ∀ {E : Type u_2} [inst : AddCommGroup E] [inst_1 : Module ℝ E] {α : Type u_4} [inst_2 : LinearOrderedField α]
      [inst_3 : MulActionWithZero α ℝ] [inst_4 : OrderedSMul α ℝ] [inst_5 : MulActionWithZero α E]
      [inst_6 : IsScalarTower α ℝ (Set E)] {s : Set E} {a : α}, 0 ≤ a → ∀ (x : E), gauge s (a • x) = a • gauge s x :=
  by sorry

This theorem, referred to as `gauge_smul_of_nonneg`, states that for any real vector space `E` with an additive commutative group structure and a scalar multiplication by real numbers, and for any ordered field `α` that acts on the reals and on `E` with scalar multiplication, if `s` is a set in `E` and `a` is a non-negative element of `α`, then for any element `x` in `E`, the Minkowski functional (or gauge) of the set `s` at a point `a` times `x` is equal to `a` times the Minkowski functional of `s` at `x`. Essentially, it states that scaling a vector by a non-negative scalar in the input of the Minkowski functional for a set corresponds to scaling the output of the functional by the same scalar.

For any real vector space with scalar multiplication, and for any non-negative scalar `a` in an ordered field acting on the reals and the vector space, the Minkowski functional of a set `s` at the point `ax` equals `a` times the Minkowski functional of `s` at `x`.


theorem Mathlib.Data.Multiset.FinsetOps._auxLemma.5 :
    ∀ {α : Type u_1} [inst : DecidableEq α] {s t : Multiset α} {a : α}, (a ∈ Multiset.ndunion s t) = (a ∈ s ∨ a ∈ t) :=
  by sorry

This theorem states that for any type `α` with decidable equality and any elements `s` and `t` of type `Multiset α` and any `a` of type `α`, `a` belongs to the non-duplicating union of `s` and `t` if and only if `a` belongs to `s` or `a` belongs to `t`. In other words, an element `a` is in the non-duplicating union of two multisets `s` and `t` exactly when it is in either `s` or `t`. This theorem basically presents the property of a set union in the context of multisets.

For any type `α` with decidable equality, and multisets `s` and `t` of type `Multiset α`, the non-duplicating union of `s` and `t` equals the set of elements in `s` or `t`.


/-- The complex hyperbolic sine function is everywhere strictly differentiable, with the derivative
`cosh x`.  -/
theorem Complex.hasStrictDerivAt_sinh : ∀ (x : ℂ), HasStrictDerivAt Complex.sinh (Complex.cosh x) x := by sorry

The theorem states that the complex hyperbolic sine function, which is denoted by `Complex.sinh`, is strictly differentiable at every point in the complex plane. Furthermore, the derivative of `Complex.sinh` at any point `x` in the complex plane is given by the complex hyperbolic cosine function evaluated at that point, i.e., `Complex.cosh x`. Strict differentiability means that the difference between the function values at two points approaches the derivative times the difference in points plus a term that goes to zero faster than the difference in points, as the two points approach each other.

The complex hyperbolic sine function `Complex.sinh` is strictly differentiable with derivative `Complex.cosh` throughout the complex plane.


theorem Real.neg_pi_div_two_lt_arcsin : ∀ {x : ℝ}, -(Real.pi / 2) < Real.arcsin x ↔ -1 < x := by sorry

The theorem states that for all real numbers `x`, the negative half of Pi is less than the arcsin of `x` if and only if `-1` is less than `x`. In other words, the arcsin function returns values greater than `-π/2` if and only if the input `x` is greater than `-1`. This theorem sets the lower boundary for the input to the arcsin function in relation to the output range of `-π/2` to `π/2`.

For all real numbers x, arcsin(x) < -π/2 if and only if x < -1.


theorem CategoryTheory.Equivalence.hasTerminal_iff :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂}
      [inst_1 : CategoryTheory.Category.{v₂, u₂} D],
      (C ≌ D) → (CategoryTheory.Limits.HasTerminal C ↔ CategoryTheory.Limits.HasTerminal D) :=
  by sorry

The theorem `CategoryTheory.Equivalence.hasTerminal_iff` asserts that for any two categories `C` and `D` (of type `Type u₁` and `Type u₂`, respectively), if `C` is equivalent to `D` (denoted `C ≌ D`), then `C` has a terminal object if and only if `D` has a terminal object. In category theory, a terminal object in a category is an object that has exactly one morphism going to it from any other object in the category. The equivalence of categories is a relation that expresses that two categories are "essentially the same" in terms of category theory.

If categories `C` and `D` are equivalent, then `C` has a terminal object if and only if `D` has a terminal object.


theorem Ordinal.card_eq_nat : ∀ {o : Ordinal.{u_3}} {n : ℕ}, Ordinal.card o = ↑n ↔ o = ↑n := by sorry

This theorem states that for any ordinal 'o' and natural number 'n', the cardinality of the ordinal 'o' is equal to the natural number 'n' if and only if the ordinal 'o' itself is 'n'. In other words, an ordinal is equal to a natural number if and only if its cardinality is that same number.

For any ordinal 'o' and natural number 'n', 'o' has cardinality equal to 'n' if and only if 'o' is equal to the natural number 'n'.


theorem genericPoint_spec :
    ∀ (α : Type u_1) [inst : TopologicalSpace α] [inst_1 : QuasiSober α] [inst_2 : IrreducibleSpace α],
      IsGenericPoint (genericPoint α) ⊤ :=
  by sorry

The theorem `genericPoint_spec` states that for any type `α`, which is endowed with a topological structure, is quasi-sober, and is an irreducible space, the generic point of `α` is a generic point of the entire space (denoted by `⊤`). In other words, the closure of the set containing only the generic point of `α` is the entire space itself.

The generic point of a quasi-sober, irreducible topological space is its own closure.


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

This theorem states that for any types `α` and `E`, a measurable space `m0` on `α`, an extended nonnegative real number `p`, a measure `μ` on `α`, and a `NormedAddCommGroup` instance on `E`, if a function `f` from `α` to `E` satisfies the `Memℒp` property with respect to `p` and `μ`, then `f` is almost everywhere strongly measurable with respect to `μ`.

In mathematical terms, this says that if `f` is a function from `α` to `E` such that it is almost everywhere strongly measurable and the norm of `f` raised to the power `p` has a finite integral (for `p < ∞`) or the essential supremum of `f` is finite (for `p = ∞`), then `f` is almost everywhere equivalent to the limit of a sequence of simple functions.

If a function from a measurable space to a Normed Additive Commutative Group satisfies the `Memℒp` property with respect to a measure and a p-th power integrable or p-th power essential supremum finite extended real number, then it is almost everywhere equivalent to the limit of a sequence of simple functions.


theorem Finset.nodup_toList : ∀ {α : Type u_1} (s : Finset α), List.Nodup (Finset.toList s) := by sorry

The theorem `Finset.nodup_toList` states that for any type `α` and any finite set `s` of that type, the list produced from the finite set `s` using the `Finset.toList` function contains no duplicates. In other words, any element appears at most once in the list. This is expressed in Lean 4 using the `List.Nodup` property.

For any type `α` and finite set `s` of that type, the list `Finset.toList s` has no repeated elements.


theorem isIntegral_algebraMap :
    ∀ {R : Type u_1} {A : Type u_3} [inst : CommRing R] [inst_1 : Ring A] [inst_2 : Algebra R A] {x : R},
      IsIntegral R ((algebraMap R A) x) :=
  by sorry

The theorem `isIntegral_algebraMap` asserts that for any commutative ring `R`, ring `A`, and algebra structure from `R` to `A`, any element `x` from `R` is integral over `R` when it is mapped to `A` using the algebra map. In other words, if you take any element from the commutative ring `R`, and map it into the ring `A` using the mapping defined by the algebra structure between `R` and `A`, the resulting element in `A` will always be a root of some monic polynomial `p : R[X]`.

For any commutative rings R and A, and algebra structure from R to A, every element x in R is integral over R if and only if its image in A is a root of some monic polynomial in R[X].


theorem Finset.sum_disjUnion :
    ∀ {α : Type u_3} {β : Type u_4} {s₁ s₂ : Finset α} {f : α → β} [inst : AddCommMonoid β] (h : Disjoint s₁ s₂),
      (Finset.sum (Finset.disjUnion s₁ s₂ h) fun x => f x) =
        (Finset.sum s₁ fun x => f x) + Finset.sum s₂ fun x => f x :=
  by sorry

This theorem is stating that for any two disjoint finite sets `s₁` and `s₂` of type `α`, and any function `f` from `α` to `β` where `β` is an additive commutative monoid, the sum of the function `f` over the disjoint union of `s₁` and `s₂` is equal to the sum of `f` over `s₁` plus the sum of `f` over `s₂`. In other words, when computing the sum of `f` over the elements of the disjoint union of `s₁` and `s₂`, we can instead compute the sum of `f` over the elements of `s₁` and `s₂` separately and then add the results together. This is analogous to the principle of inclusion-exclusion in mathematics.

For any additive commutative monoid β and disjoint finite sets s₁ and s₂ of type α, the sum of a function f from α to β over the disjoint union of s₁ and s₂ equals the sum of f over s₁ plus the sum of f over s₂.


StrictConvexOn.neg

/-- **Alias** of the reverse direction of `neg_strictConcaveOn_iff`.

---

A function `-f` is strictly concave iff `f` is strictly convex.  -/
theorem StrictConvexOn.neg :
    ∀ {𝕜 : Type u_1} {E : Type u_2} {β : Type u_5} [inst : OrderedSemiring 𝕜] [inst_1 : AddCommMonoid E]
      [inst_2 : OrderedAddCommGroup β] [inst_3 : SMul 𝕜 E] [inst_4 : Module 𝕜 β] {s : Set E} {f : E → β},
      StrictConvexOn 𝕜 s f → StrictConcaveOn 𝕜 s (-f) :=
  by sorry

This theorem, `StrictConvexOn.neg`, states that for any ordered semiring `𝕜`, any type `E` with an addition operation defining it as a commutative monoid, any type `β` forming an ordered additive group, and any `s` of type `Set E`, if a function `f` mapping `E` to `β` is strictly convex on `s`, then the function `-f` is strictly concave on `s`. In other words, negating a strictly convex function results in a strictly concave function.

If `f : E → β` is strictly convex on a set `s` in an ordered semiring `𝕜` where `E` is a commutative monoid with additive structure, then `-f : E → β` is strictly concave on `s`.


theorem DenseInducing.extend_eq_of_tendsto :
    ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] {i : α → β}
      (di : DenseInducing i) [inst_2 : TopologicalSpace γ] [inst_3 : T2Space γ] {b : β} {c : γ} {f : α → γ},
      Filter.Tendsto f (Filter.comap i (nhds b)) (nhds c) → DenseInducing.extend di f b = c :=
  by sorry

The theorem `DenseInducing.extend_eq_of_tendsto` states that for all types `α`, `β` and `γ` with their respective topological spaces, and given a function `i : α → β` that induces a dense subset, another function `f : α → γ`, and elements `b : β`, `c : γ`, if `f` tends to `c` at the preimage of the neighborhood of `b` under `i`, then the extension of `f` with respect to the dense inducing function `i` at point `b` is equal to `c`. The space `γ` also needs to be a Hausdorff space (`T2Space`), which means any two distinct points in `γ` can be separated by neighbourhoods.

Given a dense function `i : α → β` between Hausdorff spaces `α`, `β`, and `γ`, if `f : α → γ` tends to `c` at the preimages of neighborhoods of `b ∈ β`, then `f`'s extension at `b` is equal to `c`.


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

This theorem states that for any given types `α` and `β`, where `α` and `β` are preordered, and for any elements `a` of type `α` and `b₁, b₂` of type `β`, the pair `(a, b₁)` is less than the pair `(a, b₂)` if and only if `b₁` is less than `b₂`. In other words, when the first elements of the pairs are equal (`a`), the ordering of the pairs is determined solely by the ordering of the second elements (`b₁` and `b₂`).

For any preordered types `α` and `β`, and elements `a` of type `α` and `b₁, b₂` of type `β`, `(a, b₁) < (a, b₂)` if and only if `b₁ < b₂`.


theorem Mathlib.MeasureTheory.Function.LpSeminorm.Basic._auxLemma.1 :
    ∀ {α : Type u_1} {E : Type u_2} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} [inst : NormedAddCommGroup E]
      {f : α → E}, MeasureTheory.Memℒp f 0 μ = MeasureTheory.AEStronglyMeasurable f μ :=
  by sorry

This theorem states that for any measure space `α`, any normed additively commutative group `E`, any measure `μ` on `α`, and any function `f` from `α` to `E`, the property that `f` belongs to the space of `L^p` functions (denoted by `MeasureTheory.Memℒp`) for `p = 0` is equivalent to the property that `f` is almost everywhere strongly measurable (`MeasureTheory.AEStronglyMeasurable`). Here, "almost everywhere strongly measurable" means that `f` is almost everywhere equal to the limit of a sequence of simple functions.

For any measure space `α`, any normed additively commutative group `E`, and any measure `μ` on `α`, the function `f` from `α` to `E` belongs to the space of `L^p` functions for `p = 0` if and only if it is almost everywhere strongly measurable.


/-- The diameter of a subsingleton vanishes.  -/
theorem EMetric.diam_subsingleton :
    ∀ {α : Type u} [inst : PseudoEMetricSpace α] {s : Set α}, Set.Subsingleton s → EMetric.diam s = 0 := by sorry

The theorem `EMetric.diam_subsingleton` states that for any set `s` in a pseudoemetric space `α`, if `s` is a subsingleton set (meaning it has at most one element), then the diameter of `s` is zero. This is to say, in a pseudoemetric space, the maximum distance (or diameter) between any two points in a subsingleton set is zero, which follows naturally as there is at most one point in such a set.

In a pseudometric space, the diameter of a subsingleton set is zero.


/-- If any maximal connected component containing some element j₀ of J is all of J, then J is connected.

The converse of `induct_on_objects`.
 -/
theorem CategoryTheory.IsConnected.of_induct :
    ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] [inst_1 : Nonempty J] {j₀ : J},
      (∀ (p : Set J), j₀ ∈ p → (∀ {j₁ j₂ : J}, (j₁ ⟶ j₂) → (j₁ ∈ p ↔ j₂ ∈ p)) → ∀ (j : J), j ∈ p) →
        CategoryTheory.IsConnected J :=
  by sorry

This theorem states that given a type `J` that forms a category and is nonempty, and an element `j₀` of `J`, if for any set `p` of `J` containing `j₀`, the property holds that if there exists a morphism from `j₁` to `j₂` in the category, then `j₁` is in `p` if and only if `j₂` is in `p`, and every element of `J` is in `p`, then `J` is connected in the category theory sense.

In essence, it's saying that if any maximal connected component containing a certain element `j₀` is the entire set `J`, then `J` is considered to be connected. This is a reverse statement of the `induct_on_objects` theorem.

If a nonempty type `J` forming a category with element `j₀` satisfies the property that every element in `J` is in any set containing `j₀` that contains a morphism between any two elements if and only if they are both in that set, then `J` is connected.


theorem HomogeneousLocalization.zero_val :
    ∀ {ι : Type u_1} {R : Type u_2} {A : Type u_3} [inst : AddCommMonoid ι] [inst_1 : DecidableEq ι]
      [inst_2 : CommRing R] [inst_3 : CommRing A] [inst_4 : Algebra R A] {𝒜 : ι → Submodule R A}
      [inst_5 : GradedAlgebra 𝒜] {x : Submonoid A}, HomogeneousLocalization.val 0 = 0 :=
  by sorry

The theorem `HomogeneousLocalization.zero_val` states that for any graded algebra, represented by an index type `ι`, a commutative ring `R`, a commutative ring `A`, an algebra structure on `A` over `R`, a map `𝒜` from `ι` to submodules of `A` over `R`, and a submonoid `x` of `A`, the value of the homogeneous localization at zero is zero. In other words, the homogeneous localization does not change the zero element in the algebra.

For any graded algebra `A` over a commutative ring `R`, the homogeneous localization of the zero element at any submonoid is still the zero element.


theorem tsum_lt_tsum :
    ∀ {ι : Type u_1} {α : Type u_3} [inst : OrderedAddCommGroup α] [inst_1 : TopologicalSpace α]
      [inst_2 : TopologicalAddGroup α] [inst_3 : OrderClosedTopology α] {f g : ι → α} {i : ι},
      f ≤ g → f i < g i → Summable f → Summable g → ∑' (n : ι), f n < ∑' (n : ι), g n :=
  by sorry

The theorem `tsum_lt_tsum` states that for any types `ι` and `α`, where `α` is an ordered additive commutative group, a topological space, a topological additive group, and has an order-closed topology, if you have two functions `f` and `g` from `ι` to `α` and an element `i` of `ι`, then if `f` is pointwise less than or equal to `g`, `f i` is strictly less than `g i`, and both `f` and `g` are summable (i.e., their infinite sums exist), then the total sum of `f` over all `ι` is strictly less than the total sum of `g` over all `ι`. In other words, it guarantees that when a function is pointwise smaller, its infinite sum will also be smaller.

If `ι` is a type, `α` is an ordered additive commutative group with an order-closed topology, `f` and `g` are functions from `ι` to `α` that are pointwise less than or equal, summable, and `f i` is strictly less than `g i` for all `i` in `ι`, then the sum of `f` over `ι` is strictly less than the sum of `g` over `ι`.


theorem Nat.le_of_add_le_add_right : ∀ {a b c : ℕ}, a + b ≤ c + b → a ≤ c := by sorry

This theorem states that for any natural numbers `a`, `b`, and `c`, if the sum of `a` and `b` is less than or equal to the sum of `c` and `b`, then `a` is less than or equal to `c`. In mathematical terms, for all natural numbers a, b, c, if a + b ≤ c + b, then a ≤ c. This captures an important property of natural numbers with respect to addition and order relations.

If for natural numbers a, b, and c, a + b <= c + b holds, then a <= c.


theorem Real.toNNReal_mono : Monotone Real.toNNReal := by sorry

The theorem `Real.toNNReal_mono` states that the function `Real.toNNReal`, which converts a real number to a non-negative real number (returning `0` if the input is less than `0`), is monotone. This means that for any two real numbers `a` and `b`, if `a` is less than or equal to `b`, then `Real.toNNReal a` is also less than or equal to `Real.toNNReal b`. In other words, the function preserves the order of the real numbers when they are mapped to non-negative real numbers.

For all real numbers `a` and `b` with `a ≤ b`, we have `Real.toNNReal a ≤ Real.toNNReal b`.