theorem Monotone.strictMono_of_injective :
    ∀ {α : Type u} {β : Type v} [inst : Preorder α] [inst_1 : PartialOrder β] {f : α → β},
      Monotone f → Function.Injective f → StrictMono f :=
  by sorry

This theorem states that for any types `α` and `β` with preorder `α` and partial order `β`, and any function `f` from `α` to `β`, if `f` is both monotone and injective, then `f` is strictly monotone.

In other words, if a function `f` satisfies two properties - first, being monotone, meaning that if an element `a` of type `α` is less than or equal to another element `b` of `α`, then `f(a)` is less than or equal to `f(b)`; and second, being injective, meaning that if `f(a)` equals `f(b)`, then `a` must equal `b` - then `f` is strictly monotone, which means that if `a < b`, then `f(a) < f(b)`.

If `f` is a function from a preordered type `α` to a partially ordered type `β` that is both monotone and injective, then it is strictly monotone.


Measurable.piecewise

theorem Measurable.piecewise :
    ∀ {α : Type u_1} {β : Type u_2} {s : Set α} {f g : α → β} {m : MeasurableSpace α} {mβ : MeasurableSpace β}
      {x : DecidablePred fun x => x ∈ s},
      MeasurableSet s → Measurable f → Measurable g → Measurable (Set.piecewise s f g) :=
  by sorry

The theorem `Measurable.piecewise` states that for any types `α` and `β`, a set `s` of type `α`, functions `f` and `g` mapping from `α` to `β`, and measurable spaces `m` over `α` and `mβ` over `β`, if the set membership of `s` is a decidable predicate, and if the set `s` is measurable, and both functions `f` and `g` are measurable, then the `piecewise` function which is equal to `f` on the set `s`, and equal to `g` on the complement of `s`, is also measurable. In other words, creating a function that operates differently on a measurable set and its complement preserves measurability.

If a measurable set and its complement are given, and the set membership is decidable, then the piecewise function that is measurable on the set and another measurable function on its complement is also measurable.


theorem isOpen_exterior :
    ∀ {α : Type u_3} [inst : TopologicalSpace α] {s : Set α} [inst_1 : AlexandrovDiscrete α], IsOpen (exterior s) := by
  sorry

This theorem states that for any set `s` in a topological space `α`, if the topological space is Alexandrov-discrete, then the exterior of the set `s` is open. Here, the "exterior" of a set is defined as the intersection of all its neighborhoods, and a space is Alexandrov-discrete if every intersection of open sets is open. The assertion is that, under these conditions, the "exterior" of any set is always an open set.

In an Alexandrov-discrete topological space, the exterior of any set is open.


theorem Polynomial.coeff_derivative :
    ∀ {R : Type u} [inst : Semiring R] (p : Polynomial R) (n : ℕ),
      Polynomial.coeff (Polynomial.derivative p) n = Polynomial.coeff p (n + 1) * (↑n + 1) :=
  by sorry

The theorem `Polynomial.coeff_derivative` states that for any semiring `R`, given any polynomial `p` from `R` and a natural number `n`, the coefficient of `X^n` in the derivative of `p` is equal to the coefficient of `X^(n+1)` in `p` multiplied by `(n+1)`. In other words, if `p` is a polynomial, then the coefficient of the `n`-th term in the derivative of `p` is the same as the coefficient of the `(n+1)`-th term in `p`, scaled by `(n+1)`. This corresponds to the power rule of differentiation in calculus.

The coefficient of the `n`-th term in the derivative of a polynomial `p` equals the coefficient of `X^(n+1)` in `p`, multiplied by `(n+1)`.


theorem Nat.le_div_iff_mul_le' : ∀ {a b c : ℕ}, 0 < b → (a ≤ c / b ↔ a * b ≤ c) := by sorry

This theorem states that for all natural numbers `a`, `b`, and `c`, if `b` is greater than zero, then `a` is less than or equal to `c` divided by `b` if and only if `a` multiplied by `b` is less than or equal to `c`. In other words, the theorem provides a relationship between division and multiplication in the context of inequalities in natural numbers.

For natural numbers `a`, `b`, and `c`, `a ≤ c / b` if and only if `a * b ≤ c`.


theorem isPeriodicPt_mul_iff_pow_eq_one :
    ∀ {G : Type u_1} [inst : Monoid G] {n : ℕ} (x : G), Function.IsPeriodicPt (fun x_1 => x * x_1) n 1 ↔ x ^ n = 1 := by
  sorry

The theorem `isPeriodicPt_mul_iff_pow_eq_one` states that for any type `G` that is a monoid, a point `x` in `G` is a periodic point of the function `f(x_1) = x * x_1` of period `n` if and only if `x` raised to the power `n` is equal to the identity element `1` in `G`. A periodic point here means that applying the function `n` times to `1` results in `1` again, essentially indicating that the function cyclically returns to `1` after `n` applications.

A point in a monoid is periodic of period n for the function x ↦ x * x\_1 if and only if x^n = 1.


theorem MeasureTheory.ae_eq_of_ae_eq_trim :
    ∀ {α : Type u_1} {m m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} {E : Type u_2} {hm : m ≤ m0}
      {f₁ f₂ : α → E}, f₁ =ᶠ[MeasureTheory.Measure.ae (μ.trim hm)] f₂ → f₁ =ᶠ[MeasureTheory.Measure.ae μ] f₂ :=
  by sorry

This theorem states that for any type `α`, given two measurable spaces `m` and `m0` over `α`, a measure `μ`, another type `E`, and a proof `hm` that `m` is a subset of or equal to `m0`, if two functions `f₁` and `f₂` from `α` to `E` are almost everywhere equal with respect to the filter of co-null sets of the trimmed measure `(μ.trim hm)`, then they are also almost everywhere equal with respect to the filter of co-null sets of the original measure `μ`. Here, "almost everywhere equal" is denoted by `=ᶠ[...]`, and means that `f₁` and `f₂` are equal except possibly on a set of measure zero.

Given measurable spaces `m` and `m0` over type `α`, a measure `μ`, and a proof `hm` that `m` is a subset of or equal to `m0`, if functions `f₁` and `f₂` from `α` to `E` are almost everywhere equal with respect to the filter of co-null sets of the trimmed measure `(μ.trim hm)`, then they are also almost everywhere equal with respect to the filter of co-null sets of the original measure `μ`.


theorem List.get_map :
    ∀ {α : Type u_1} {β : Type u_2} (f : α → β) {l : List α} {n : Fin (List.length (List.map f l))},
      List.get (List.map f l) n = f (List.get l { val := ↑n, isLt := ⋯ }) :=
  by sorry

This theorem states that for any function `f` mapping elements of type `α` to type `β`, and any list `l` of type `α`, if we have a valid index `n` into the list obtained by mapping `f` over `l`, then fetching the `n`-th element of the mapped list is equivalent to first fetching the `n`-th element of the original list `l`, and then applying the function `f` to it. The index `n` is a natural number less than the length of the list obtained by applying `f` to each element of the list `l`.

For any function `f` and list `l`, if `n` is a valid index for the list obtained by applying `f` to each element of `l`, then the `n`-th element of the mapped list equals `f` applied to the `n`-th element of the original list.


theorem Set.image2_iInter_subset_right :
    ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {ι : Sort u_4} (f : α → β → γ) (s : Set α) (t : ι → Set β),
      Set.image2 f s (⋂ i, t i) ⊆ ⋂ i, Set.image2 f s (t i) :=
  by sorry

This theorem states that for any types `α`, `β`, and `γ`, an indexing type `ι`, a binary function `f` from `α` and `β` to `γ`, a set `s` of type `α`, and a function `t` from `ι` to the set of `β`, the image under `f` of the set `s` and the intersection over `ι` of the sets `t i` is a subset of the intersection over `ι` of the images under `f` of the set `s` and the sets `t i`. In terms of mathematical notation, this can be written as $f(s, \bigcap_{i} t_i) \subseteq \bigcap_{i} f(s, t_i)$.

For any types `α`, `β`, `γ`, indexing type `ι`, function `f` from `α × β` to `γ`, set `s` of type `α`, and function `t` from `ι` to `β`, the image of `s` under `f` intersecting the images of `t i` is a subset of the intersection of the images of `s` and `t i` for all `i`. In symbols, $f(s) \cap (\bigcap\_{i} f(s, t\_i)) \subseteq \bigcap\_{i} f(s, t\_i)$.


theorem wittStructureInt_vars :
    ∀ (p : ℕ) {idx : Type u_2} [hp : Fact (Nat.Prime p)] [inst : Fintype idx] (Φ : MvPolynomial idx ℤ) (n : ℕ),
      MvPolynomial.vars (wittStructureInt p Φ n) ⊆ Finset.univ ×ˢ Finset.range (n + 1) :=
  by sorry

The theorem `wittStructureInt_vars` states that for any natural number `p`, any type `idx`, any multivariate polynomial `Φ` with coefficients in the set of integers, and any natural number `n`, if `p` is prime and `idx` is a finite type, then the set of variables appearing in the Witt structure of the polynomial `Φ` at the `n`th stage is a subset of the Cartesian product of the universal finite set and the set of natural numbers less than `n + 1`.

For any prime number p, finite type idx, multivariate polynomial Φ with integer coefficients, and natural number n, the variables in the Witt structure of Φ at stage n are contained in the product of the universal finite set and the set {0, ..., n}.


theorem Part.eq_none_iff : ∀ {α : Type u_1} {o : Part α}, o = Part.none ↔ ∀ (a : α), a ∉ o := by sorry

This theorem, `Part.eq_none_iff`, states that for any type `α` and any part `o` of that type `α`, `o` is equal to `Part.none` (the `Part` value with a `False` domain and an empty function) if and only if for all elements `a` of type `α`, `a` is not in `o`. In simpler terms, a part is the 'none' part if no elements of the underlying type are contained in it.

For any type `α` and part `o` of `α`, `o = Part.none` if and only if `o` is empty.


/-- If a predicate is true in a neighbourhood of `x`, then for `y` sufficiently close
to `x` this predicate is true in a neighbourhood of `y`.  -/
theorem Filter.Eventually.eventually_nhds :
    ∀ {X : Type u} {x : X} [inst : TopologicalSpace X] {p : X → Prop},
      (∀ᶠ (y : X) in nhds x, p y) → ∀ᶠ (y : X) in nhds x, ∀ᶠ (x : X) in nhds y, p x :=
  by sorry

The theorem `Filter.Eventually.eventually_nhds` states that in a topological space, if a certain property or condition holds true in a neighborhood of a point `x`, then for all points `y` that are sufficiently close to `x`, this property will also hold true in a neighborhood of `y`. In other words, if a property is locally true at a point, then it's also true at points close to it.

If a property holds in the neighborhood of a point in a topological space, then it holds in the neighborhood of any point sufficiently close to it.


theorem one_div_one : ∀ {G : Type u_3} [inst : DivInvOneMonoid G], 1 / 1 = 1 := by sorry

This theorem states that for any type `G` which has a `DivInvOneMonoid` structure (a structure that includes operations for division and inversion, along with the existence of an identity element 'one'), the division of 'one' by 'one' is always equal to 'one'. It generalizes the familiar rule in arithmetic that anything divided by itself is 'one' to any context where the concept of 'division', 'inversion', and 'one' make sense.

For any type `G` with a `DivInvOneMonoid` structure, `one_div_one` equals `one`.


theorem MeasureTheory.SignedMeasure.integrable_rnDeriv :
    ∀ {α : Type u_1} {m : MeasurableSpace α} (s : MeasureTheory.SignedMeasure α) (μ : MeasureTheory.Measure α),
      MeasureTheory.Integrable (MeasureTheory.SignedMeasure.rnDeriv s μ) μ :=
  by sorry

The theorem `MeasureTheory.SignedMeasure.integrable_rnDeriv` states that for any given `MeasurableSpace` α and a `SignedMeasure` s on α, and for any `Measure` μ on α, the Radon-Nikodym derivative of the `SignedMeasure` s with respect to the `Measure` μ, denoted as `MeasureTheory.SignedMeasure.rnDeriv s μ`, is integrable with respect to μ. In mathematical terms, it means that the function `MeasureTheory.SignedMeasure.rnDeriv s μ` is measurable and has a finite integral over the measure space α with respect to the measure μ.

The Radon-Nikodym derivative of a signed measure with respect to a given measure is integrable with respect to the measure.


theorem Multiset.dedup_le : ∀ {α : Type u_1} [inst : DecidableEq α] (s : Multiset α), Multiset.dedup s ≤ s := by sorry

The theorem `Multiset.dedup_le` states that for any type `α` that has decidable equality, and for any multiset `s` of type `α`, the multiset obtained by deduplicating `s` (`Multiset.dedup s`) is a sub-multiset of `s`. In other words, the multiset that results from removing duplicates from `s` contains only elements that originally existed in `s`, and thus, it must be less than or equal to `s`.

For any type `α` with decidable equality and any multiset `s` of type `α`, `Multiset.dedup s` is a sub-multiset of `s`.


theorem nhdsWithin_hasBasis :
    ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] {p : β → Prop} {s : β → Set α} {a : α},
      Filter.HasBasis (nhds a) p s → ∀ (t : Set α), Filter.HasBasis (nhdsWithin a t) p fun i => s i ∩ t :=
  by sorry

The theorem `nhdsWithin_hasBasis` states that for any types `α` and `β` and any topological space on `α`, given a predicate `p` on `β`, a function `s` from `β` to sets of `α`, and a point `a` in `α`, if the neighborhood filter (`nhds a`) has a basis defined by `p` and `s`, then for any set `t` of `α`, the "neighborhood within" filter (`nhdsWithin a t`) also has a basis defined by `p` and the intersection between `s i` and `t` for every `i` in `β` fulfilling the predicate `p`. In simple terms, this theorem says that if a neighborhood filter of a point has a certain basis, then the basis for the filter of the neighborhood within a particular set is composed by the intersection of this set with the sets of the original basis.

If a neighborhood filter at a point in a topological space has a basis given by a predicate and a function, then the neighborhood filter within a set has a basis given by the intersection of the set with the basis elements fulfilling the predicate.


theorem lowerClosure_singleton : ∀ {α : Type u_1} [inst : Preorder α] (a : α), lowerClosure {a} = LowerSet.Iic a := by
  sorry

This theorem, `lowerClosure_singleton`, states that for any type `α` that has a preorder relation, and for any element `a` of type `α`, the lower closure of the set containing only `a` is equivalent to the principal lower set of `a`. In other words, for any element `a`, the smallest set that contains `a` and all elements less than or equal to `a` is the same set as the set of all elements less than or equal to `a`.

For any preordered type `α` and element `a` in `α`, the lower closure of the singleton set `{a}` equals the principal lower set of `a`.


theorem Finsupp.coe_le_coe :
    ∀ {ι : Type u_1} {α : Type u_2} [inst : Zero α] [inst_1 : LE α] {f g : ι →₀ α}, ⇑f ≤ ⇑g ↔ f ≤ g := by sorry

This theorem states that for any types `ι` and `α`, where `α` has a zero and a less-than-or-equal-to (`≤`) operation, and for any two functions `f` and `g` from `ι` to `α` that have finite support (`ι →₀ α`), the pointwise application of `f` is less than or equal to the pointwise application of `g` if and only if `f` is less than or equal to `g`. In other words, the ordering of the functions `f` and `g` is the same as the ordering of their pointwise applications.

For functions `f` and `g` from type `ι` to type `α` with finite support, where `α` is equipped with a zero `0` and a `≤` relation, the pointwise application `∀ i, f i ≤ g i` if and only if `f ≤ g`.


theorem Finset.prod_eq_zero_iff :
    ∀ {α : Type u_3} {β : Type u_4} {s : Finset α} {f : α → β} [inst : CommMonoidWithZero β] [inst_1 : Nontrivial β]
      [inst_2 : NoZeroDivisors β], (Finset.prod s fun x => f x) = 0 ↔ ∃ a ∈ s, f a = 0 :=
  by sorry

The theorem `Finset.prod_eq_zero_iff` states that for any type `α`, a second type `β` that is a commutative monoid with zero, has a nontrivial element, and has no zero divisors, a finite set `s` of type `α`, and a function `f` from `α` to `β`, the product of `f x` for all `x` in `s` is equal to zero if and only if there exists an element `a` in `s` such that `f a` equals zero.

For any commutative monoid with zero, having a nontrivial zero and no zero divisors, a function from a finite set to this monoid, and the product of images of set elements, equals zero if and only if there exists an element in the set mapping to the zero element.


/-- An element of `R` is algebraic, when viewed as an element of the `R`-algebra `A`.  -/
theorem isAlgebraic_algebraMap :
    ∀ {R : Type u} {A : Type v} [inst : CommRing R] [inst_1 : Ring A] [inst_2 : Algebra R A] [inst_3 : Nontrivial R]
      (x : R), IsAlgebraic R ((algebraMap R A) x) :=
  by sorry

This theorem states that for any element `x` from a commutative ring `R`, when `x` is viewed as an element of an `R`-algebra `A` via the algebraic embedding `algebraMap R A`, it is considered to be algebraic over `R`. In mathematical terms, `x` is a root of a nonzero polynomial with coefficients in `R`. The theorem holds under the assumption that `R` is nontrivial, that is, `R` contains at least two distinct elements.

For any commutative ring `R` with at least two elements and any `x` in an `R`-algebra `A` via the algebraic embedding `algebraMap R A`, `x` is algebraic over `R`.


theorem CategoryTheory.NatIso.naturality_1 :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂}
      [inst_1 : CategoryTheory.Category.{v₂, u₂} D] {F G : CategoryTheory.Functor C D} {X Y : C} (α : F ≅ G)
      (f : X ⟶ Y),
      CategoryTheory.CategoryStruct.comp (α.inv.app X) (CategoryTheory.CategoryStruct.comp (F.map f) (α.hom.app Y)) =
        G.map f :=
  by sorry

This theorem states that for any two categories 'C' and 'D', and any two functors 'F' and 'G' from 'C' to 'D', if 'α' is a natural isomorphism between 'F' and 'G', then for any morphism 'f' from object 'X' to 'Y' in 'C', the composition of the inverse of the application of 'α' at 'X' with the composition of the mapping of 'f' by 'F' and the application of 'α' at 'Y', equals the mapping of 'f' by 'G'. In essence, this theorem encapsulates the naturality condition of a natural isomorphism in category theory.

For any categories 'C' and 'D', functors 'F' and 'G' from 'C' to 'D', and natural isomorphism α between F and G: for all objects X and Y in C and morphism f from X to Y, α⁻¹∘F(f)∘α(Y) = G(f).


theorem interior_univ : ∀ {X : Type u} [inst : TopologicalSpace X], interior Set.univ = Set.univ := by sorry

The theorem `interior_univ` states that for all types `X` which have a topology defined on them, the interior of the universal set is equal to the universal set itself. In simpler terms, it says that the largest open subset of the set containing all elements is the set of all elements itself. This is true for any type `X` and any topological space `X`. In standard mathematical notation, if `X` is a topological space, then `interior(X) = X`.

For any topological space X, the interior of the universal set X is equal to X.


/-- A product of a function `f : Fin (n + 1) → β` over all `Fin (n + 1)`
is the product of `f (Fin.last n)` plus the remaining product  -/
theorem Fin.prod_univ_castSucc :
    ∀ {β : Type u_2} [inst : CommMonoid β] {n : ℕ} (f : Fin (n + 1) → β),
      (Finset.prod Finset.univ fun i => f i) = (Finset.prod Finset.univ fun i => f (Fin.castSucc i)) * f (Fin.last n) :=
  by sorry

The theorem `Fin.prod_univ_castSucc` states that for any function `f` from the finite set `Fin (n + 1)` to a type `β` that forms a commutative monoid, the product of `f` over all elements of `Fin (n + 1)` is equal to the product of `f` over all elements in the form `Fin.castSucc i` multiplied by `f` evaluated at the last element of `Fin (n + 1)`. Here, `Fin (n + 1)` represents the finite set of natural numbers less than `n + 1`, `Fin.castSucc` is a function that embeds a number in `Fin n` into `Fin (n + 1)`, and `Fin.last n` stands for the greatest value in `Fin (n + 1)`. Essentially, it verifies the product of the function values over the entire set can be partitioned into the product over the embedded lower index set and the function value at the last element.

For any commutative monoid-valued function `f` on `Fin (n + 1)`, the product of `f` over all elements equals the product over `Fin.castSucc` elements multiplied by `f` evaluated at `Fin.last (n + 1)`.


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

This theorem states that for any two finite sets `s` of type `α` and `t` of type `β`, the Cartesian product of `s` and `t` when coerced to a set is equivalent to the Cartesian product of the coerced `s` and `t`. In mathematical terms, given two finite sets S and T, the theorem asserts that $(S \times T)$ is the same as $(S) \times (T)$.

For any finite sets `s` of type `α` and `t` of type `β`, the coerced Cartesian product `(s : Set α) × (t : Set β)` is equivalent to the naive Cartesian product `(s : Set α) ×↑ (t : Set β)`.


theorem Ordinal.IsNormal.bsup_eq :
    ∀ {f : Ordinal.{u} → Ordinal.{max u v}},
      Ordinal.IsNormal f → ∀ {o : Ordinal.{u}}, Ordinal.IsLimit o → (Ordinal.bsup o fun x x_1 => f x) = f o :=
  by sorry

This theorem states that for all normal ordinal functions `f` and for every limit ordinal `o`, the supremum of the family of ordinals indexed by the set of ordinals less than `o` (where each element is given by the function `f`) is equal to `f o`. In other words, if a function `f` is normal and `o` is a limit ordinal, then the supremum of the function values for ordinals less than `o` equals the function value at `o`. This theorem is an important result related to the behavior of strictly increasing and order-continuous functions on limit ordinals.

For every normal function `f` and limit ordinal `o`, `f o` is the supremum of the values `{f x | x < o}` in the ordered structure of ordinals.


IsChain.directedOn

theorem IsChain.directedOn :
    ∀ {α : Type u_1} {r : α → α → Prop} {s : Set α} [inst : IsRefl α r], IsChain r s → DirectedOn r s := by sorry

This theorem states that for any type `α`, any relation `r` on `α`, and any set `s` of `α`, if `r` is a reflexive relation (meaning for all `x` in `α`, `r x x` holds) and `s` is a chain with respect to `r` (meaning for all `x` and `y` in `s`, either `x` is related to `y`, `y` is related to `x`, or `x` and `y` are the same), then `s` is also directed with respect to `r`. A set is directed with respect to a relation if, for any two elements in the set, there exists a third element in the set that is related to both of them.

If `r` is a reflexive relation on type `α` and `s` is a chain of `α` with respect to `r`, then `s` is a directed set with respect to `r`.


theorem List.erase_cons_head :
    ∀ {α : Type u_1} [inst : BEq α] [inst_1 : LawfulBEq α] (a : α) (l : List α), List.erase (a :: l) a = l := by sorry

This theorem states that for any type `α`, given an instance of binary equality (`BEq`) for `α` and an instance of lawful binary equality (`LawfulBEq`), for any element `a` of type `α` and any list `l` of type `α`, when `a` is appended at the head of `l` to form a new list, and then `a` is erased from this new list, the resulting list is equal to the original list `l`. In other words, "erasing" the head of a list returns the tail of the list.

For any type `α` with instances of binary equality and lawful binary equality, appending and then erasing the head element of a list `l` of type `α` results in the original list `l`. In symbols, `append (a :: l) (erase a (a :: l)) ≡ l`.


theorem isOpen_sUnion :
    ∀ {X : Type u} [inst : TopologicalSpace X] {s : Set (Set X)}, (∀ t ∈ s, IsOpen t) → IsOpen (⋃₀ s) := by sorry

The theorem `isOpen_sUnion` states that for any type `X` with a topological space structure and a set `s` of subsets of `X`, if all the subsets contained in `s` are open in the topological space, then the union of all subsets in `s` (denoted as `⋃₀ s`) is also open in the same topological space. In more mathematical language, given a set `s` of open subsets of a topological space `X`, the union of the elements of `s` is also an open set in `X`.

If every subset in a collection of open subsets of a topological space is open, then their union is also open.


theorem self_eq_neg :
    ∀ (R : Type u_2) (M : Type u_5) [inst : Semiring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M]
      [inst_3 : NoZeroSMulDivisors R M] [inst : CharZero R] {v : M}, v = -v ↔ v = 0 :=
  by sorry

This theorem is named `self_eq_neg` and states that for any semiring `R`, any additive commutative group `M`, and any module `M` over `R`, given the conditions that there are no zero scalar multipliers or divisors in `R` and `M`, and `R` has characteristic zero, a vector `v` in `M` is equal to its own negation if and only if `v` is the zero vector. In mathematical notation, this can be represented as `∀v ∈ M, v = -v ↔ v = 0`.

For any semiring R with no zero scalar multipliers or divisors and characteristic zero, and any additive commutative group M with no zero divisors as an R-module, every vector v in M satisfies v = -v if and only if v is the zero vector.


theorem Cubic.of_a_eq_zero :
    ∀ {R : Type u_1} {P : Cubic R} [inst : Semiring R],
      P.a = 0 →
        Cubic.toPoly P = Polynomial.C P.b * Polynomial.X ^ 2 + Polynomial.C P.c * Polynomial.X + Polynomial.C P.d :=
  by sorry

This theorem, `Cubic.of_a_eq_zero`, states that for any type `R` that is a semiring and a cubic polynomial `P` of type `R`, if the coefficient of the cubic term `P.a` is zero, then the cubic polynomial is equivalent to the polynomial comprised of the remaining terms. Specifically, this polynomial is constructed by multiplying the coefficient of the quadratic term `P.b` by `X` squared, adding the product of the linear term coefficient `P.c` and `X`, and finally adding the constant term `P.d`. This polynomial is achieved by applying the `Polynomial.C` function to each of the coefficients.

If the cubic coefficient of a polynomial P over a semiring R is zero, then P is equivalent to the quadratic polynomial obtained by multiplying the quadratic coefficient by X^2, adding the linear coefficient times X, and adding the constant coefficient.


Submodule.FG.map

theorem Submodule.FG.map :
    ∀ {R : Type u_1} {M : Type u_2} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {P : Type u_3}
      [inst_3 : AddCommMonoid P] [inst_4 : Module R P] (f : M →ₗ[R] P) {N : Submodule R M},
      Submodule.FG N → Submodule.FG (Submodule.map f N) :=
  by sorry

The theorem `Submodule.FG.map` states that for any semiring `R`, two additively commutative monoids `M` and `P` with module structures over `R`, a linear map `f` from `M` to `P`, and a finitely generated submodule `N` of `M`, the image of `N` under `f` (represented by `Submodule.map f N`) is also a finitely generated submodule of `P`. In other words, a finitely generated submodule remains finitely generated when mapped using a linear transformation.

Given a semiring R, additively commutative monoids M and P with R-module structures, a linear map f from M to P, and a finitely generated submodule N of M, the image of N under f is also a finitely generated submodule of P.


theorem BoxIntegral.Box.le_iff_bounds :
    ∀ {ι : Type u_1} {I J : BoxIntegral.Box ι}, I ≤ J ↔ J.lower ≤ I.lower ∧ I.upper ≤ J.upper := by sorry

This theorem states that, for any two boxes `I` and `J` in a given type `ι`, `I` is less than or equal to `J` if and only if the lower bound of `J` is less than or equal to the lower bound of `I` and the upper bound of `I` is less than or equal to the upper bound of `J`. In other words, one box is considered "smaller" than another if its bounds are contained within the bounds of the other.

For boxes I and J in a type ι, I ≤ J if and only if inf I ≤ inf J and sup I ≤ sup J.


theorem Set.sInter_singleton : ∀ {α : Type u_1} (s : Set α), ⋂₀ {s} = s := by sorry

This theorem states that for any set `s` of type `α`, the intersection over the singleton collection containing just `s` is equal to `s` itself. In mathematical terms, for all sets `s`, the intersection of the elements of the singleton set `{s}` is equal to `s`.

For any set `s`, the intersection of the singleton set `{s}` is equal to `s`.


theorem IsCompact.elim_nhds_subcover :
    ∀ {X : Type u} [inst : TopologicalSpace X] {s : Set X},
      IsCompact s → ∀ (U : X → Set X), (∀ x ∈ s, U x ∈ nhds x) → ∃ t, (∀ x ∈ t, x ∈ s) ∧ s ⊆ ⋃ x ∈ t, U x :=
  by sorry

The theorem `IsCompact.elim_nhds_subcover` states that for any type `X` equipped with a topology and any compact set `s` of type `X`, if for every point `x` in `s`, `U x` is a neighborhood of `x` (i.e., `U x` belongs to the neighborhood filter of `x`), then there exists a subset `t` of `s` such that every point in `s` is in the union of the sets `U x` for `x` in `t`. In other words, the set `s` can be covered by a subcollection of the neighborhoods `U x`, where `x` ranges over the points in the compact set `s`. This theorem captures one of the fundamental properties of compact sets in topology: every open cover has a finite subcover.

Given a compact set `s` in a topological space `X` such that for each `x` in `s`, `U x` is a neighborhood of `x`, there exists a finite subcover `t` of `{U x | x ∈ s}` that covers `s`.


theorem Int.cast_lt : ∀ {α : Type u_3} [inst : OrderedRing α] [inst_1 : Nontrivial α] {m n : ℤ}, ↑m < ↑n ↔ m < n := by
  sorry

This theorem states that for any given ordered ring `α` and for any two integers `m` and `n`, the casting of `m` to `α` is less than the casting of `n` to `α` if and only if `m` is less than `n`. This theorem essentially establishes that the inequality relationship between two integers is preserved when they are cast into an ordered ring.

For any ordered ring `α` and integers `m` and `n`, `m < n` if and only if `cast_int α m < cast_int α n`.


MeasureTheory.HasFiniteIntegral.mono

theorem MeasureTheory.HasFiniteIntegral.mono :
    ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α}
      [inst : NormedAddCommGroup β] [inst_1 : NormedAddCommGroup γ] {f : α → β} {g : α → γ},
      MeasureTheory.HasFiniteIntegral g μ → (∀ᵐ (a : α) ∂μ, ‖f a‖ ≤ ‖g a‖) → MeasureTheory.HasFiniteIntegral f μ :=
  by sorry

This theorem states that for any types `α`, `β`, and `γ`, where `α` is a measurable space and `μ` is a measure on `α`, if `β` and `γ` form normed additive commutative groups and `f` is a map from `α` to `β` and `g` is a map from `α` to `γ`, if `g` has a finite integral over `μ` and almost everywhere in `α` the norm of `f` at a point is less than or equal to the norm of `g` at that point, then `f` also has a finite integral over `μ`. In mathematical terms, it states that if $\int \|\mathbf{g}(a)\| d\mu < \infty$ and $\|\mathbf{f}(a)\| \leq \|\mathbf{g}(a)\|$ almost everywhere, then $\int \|\mathbf{f}(a)\| d\mu < \infty$.

If `μ` is a measure on a measurable space `α`, `f: α → β` and `g: α → γ` are measurable functions with `β` and `γ` normed additive commutative groups, `g` has finite integral over `μ`, and almost everywhere `||f(x)|| ≤ ||g(x)||`, then `f` also has a finite integral over `μ` with respect to the norm of its values.


theorem measurable_nnnorm :
    ∀ {α : Type u_1} [inst : MeasurableSpace α] [inst_1 : NormedAddCommGroup α] [inst_2 : OpensMeasurableSpace α],
      Measurable nnnorm :=
  by sorry

The theorem `measurable_nnnorm` states that for any type `α` which has a `MeasurableSpace` structure and is also a normed additive commutative group with an open measurable space structure, the non-negative real-valued norm (`nnnorm`) function is measurable. In other words, given a measurable set in the set of non-negative real numbers, the preimage under the `nnnorm` function is a measurable set in the given measurable space `α`.

For any normed additive commutative group `α` with an open measurable space structure that is also a type with a `MeasurableSpace` structure, the non-negative real-valued norm function is measurable.


theorem Submodule.map_equiv_eq_comap_symm :
    ∀ {R : Type u_1} {R₂ : Type u_3} {M : Type u_5} {M₂ : Type u_7} [inst : Semiring R] [inst_1 : Semiring R₂]
      [inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid M₂] [inst_4 : Module R M] [inst_5 : Module R₂ M₂]
      {τ₁₂ : R →+* R₂} {τ₂₁ : R₂ →+* R} [inst_6 : RingHomInvPair τ₁₂ τ₂₁] [inst_7 : RingHomInvPair τ₂₁ τ₁₂]
      (e : M ≃ₛₗ[τ₁₂] M₂) (K : Submodule R M), Submodule.map (↑e) K = Submodule.comap (↑(LinearEquiv.symm e)) K :=
  by sorry

The theorem `Submodule.map_equiv_eq_comap_symm` states that for any two semi-rings `R` and `R₂`, with associated `AddCommMonoid` structures `M` and `M₂` and also Module structures over `R` and `R₂`, and given two ring homomorphisms `τ₁₂` and `τ₂₁` between these rings that form an inverse pair, then for any linear equivalence `e` between `M` and `M₂` and a submodule `K` of `M`, the image of `K` under the map induced by `e` is equal to the inverse image of `K` under the map induced by the inverse of `e`.

For any semi-rings R and R₂, ring homomorphisms τ₁₂ and τ₂₁ forming an inverse pair, Module structures M and M₂ over R and R₂, and linear equivalence e between M and M₂, the image of a submodule K of M under e equals the inverse image of K under e⁻¹.


theorem Multiset.card_singleton : ∀ {α : Type u_1} (a : α), Multiset.card {a} = 1 := by sorry

The theorem `Multiset.card_singleton` states that for any type `α` and any element `a` of that type, the cardinality (or size) of the multiset consisting of just that element `{a}` is 1. In other words, a multiset containing only one element has a cardinality of 1, regardless of the type or value of the element.

For any type `α` and element `a` of type `α`, the multiset `{a}` has cardinality 1.


theorem MulOpposite.continuous_unop : ∀ {M : Type u_1} [inst : TopologicalSpace M], Continuous MulOpposite.unop := by
  sorry

The theorem `MulOpposite.continuous_unop` states that for any type `M` which has a topological space structure, the function `MulOpposite.unop` is continuous. The function `MulOpposite.unop` takes an element from the multiplicative opposite (`MulOpposite`) of `M` and returns an element of `M`. In the context of topology, a function is said to be continuous if the preimage of any open set is also an open set. Thus, in this case, for any open set in `M`, the preimage under `MulOpposite.unop` is an open set in `Mᵐᵒᵖ`.

The function `MulOpposite.unop` from the multiplicative opposite of a topological space `M` to `M` is continuous.


theorem CategoryTheory.Limits.coprod.inl_desc :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {W X Y : C}
      [inst_1 : CategoryTheory.Limits.HasBinaryCoproduct X Y] (f : X ⟶ W) (g : Y ⟶ W),
      CategoryTheory.CategoryStruct.comp CategoryTheory.Limits.coprod.inl (CategoryTheory.Limits.coprod.desc f g) = f :=
  by sorry

The theorem `CategoryTheory.Limits.coprod.inl_desc` states that, in any category `C` with a binary coproduct of `X` and `Y`, for any two morphisms `f` from `X` to `W` and `g` from `Y` to `W`, the composition of the inclusion map from the first component of the coproduct (`CategoryTheory.Limits.coprod.inl`) and the morphism induced by `f` and `g` (`CategoryTheory.Limits.coprod.desc f g`) is equal to `f`. In other words, this shows that the coproduct behaves as expected when mapping from one of its components.

In any category with binary coproducts, the inclusion map from the first component of the coproduct to the coproduct and the composition of the morphisms from each component to a third object are equal. That is, `inl ∘ f = f` in the coproduct `X + Y` for morphisms `f : X → W` and `inl : X → X + Y`.


theorem CategoryTheory.Functor.op_comp_isSheaf :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂}
      [inst_1 : CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor C D) {A : Type u₃}
      [inst_2 : CategoryTheory.Category.{v₃, u₃} A] (J : CategoryTheory.GrothendieckTopology C)
      (K : CategoryTheory.GrothendieckTopology D) [inst_3 : CategoryTheory.Functor.IsContinuous F J K]
      (G : CategoryTheory.Sheaf K A), CategoryTheory.Presheaf.IsSheaf J (CategoryTheory.Functor.comp F.op G.val) :=
  by sorry

This theorem states that for any categories `C`, `D`, and `A`, with respective Grothendieck topologies `J` and `K`, if a functor `F` from `C` to `D` is continuous with respect to these topologies, and if `G` is a sheaf on `D` with values in `A` with respect to `K`, then the composition of the opposite of `F` with the presheaf associated with `G` is a sheaf on `C` with respect to `J`. This is a statement about how sheaves and continuous functors interact within the context of category theory and Grothendieck topologies.

If functor F from category C to D is continuous with respect to Grothendieck topologies J and K, and G is a sheaf on D with values in A with respect to K, then the composition of the opposite of F and the presheaf associated with G is a sheaf on C with respect to J.


/-- Taking a sum over `s : Finset α` is the same as adding the value on a single element
`f a` to the sum over `s.erase a`.

See `Multiset.sum_map_erase` for the `Multiset` version. -/
theorem Finset.add_sum_erase :
    ∀ {α : Type u_3} {β : Type u_4} [inst : AddCommMonoid β] [inst_1 : DecidableEq α] (s : Finset α) (f : α → β)
      {a : α}, a ∈ s → (f a + Finset.sum (Finset.erase s a) fun x => f x) = Finset.sum s fun x => f x :=
  by sorry

The theorem `Finset.add_sum_erase` states that for any given finite set `s` of a type `α` and a function `f` from `α` to a type `β` (where `β` has an additive commutative monoid structure), and any element `a` of the set `s` (which equality can be decided), the sum of the function `f` over the set `s` is the same as the sum of the function `f` over the set `s` with `a` removed, plus the value of the function `f` at `a`. In mathematical terms, if $\sum_{x \in s} f(x)$ is the sum of `f(x)` for all `x` in `s`, then $\sum_{x \in s} f(x) = f(a) + \sum_{x \in s \setminus \{a\}} f(x)$, where `a` is in `s`.

For a finite set `s` of type `α` and a function `f` from `α` to an additive commutative monoid `β`, the sum of `f` over `s` equals the sum of `f` over `s` without the element `a` in `s`, plus `f(a)`. In mathematical notation, $\sum\_{x \in s} f(x) = f(a) + \sum\_{x \in s \setminus \{a\}} f(x)$.


theorem Set.eq_of_subset_of_card_le :
    ∀ {α : Type u} {s t : Set α} [inst : Fintype ↑s] [inst_1 : Fintype ↑t],
      s ⊆ t → Fintype.card ↑t ≤ Fintype.card ↑s → s = t :=
  by sorry

The theorem `Set.eq_of_subset_of_card_le` states that for any two sets `s` and `t` of some type `α`, if `s` is a subset of `t` and the cardinality (or the number of elements) of `t` is less than or equal to the cardinality of `s`, then `s` must be equal to `t`. In other words, if `s` is a subset of `t` and there are no more elements in `t` than in `s`, then `s` and `t` must contain exactly the same elements. This theorem is defined under the condition that the power sets of `s` and `t` (denoted by `↑s` and `↑t` respectively) are finite types, meaning they have a finite number of elements.

If `s` is a subset of `t` and the cardinality of `t` is less than or equal to that of `s`, then `s` and `t` have the same elements. (Assuming `s` and `t` have finite power sets.)


theorem Homeomorph.image_symm :
    ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] (h : X ≃ₜ Y),
      Set.image ⇑(Homeomorph.symm h) = Set.preimage ⇑h :=
  by sorry

The theorem `Homeomorph.image_symm` states that for any homeomorphism `h` between two types `X` and `Y` that are endowed with topological spaces, the image of a set under the inverse homeomorphism `h⁻¹` is the same as the preimage of the set under the original homeomorphism `h`. In other words, if we take any set from `Y`, find its image in `X` using the inverse of `h`, it would be the same as taking the preimage of the set in `X` using `h`. This establishes a certain symmetry property of images and preimages under homeomorphisms.

For any homeomorphism between topological spaces, the image of a set under its inverse is equal to the preimage of that set.


/-- All ideals in a division (semi)ring are trivial.  -/
theorem Ideal.eq_bot_or_top : ∀ {K : Type u} [inst : DivisionSemiring K] (I : Ideal K), I = ⊥ ∨ I = ⊤ := by sorry

This theorem states that for any given ideal `I` in a division semiring `K`, `I` is either a bottom element (denoted by `⊥`, which represents the smallest ideal, typically {0}) or a top element (denoted by `⊤`, which represents the whole ring itself). In other words, in a division semiring, all ideals are trivial; they're either the whole ring or just the zero element.

In a division semiring, every ideal is either the whole ring or the zero ideal.


theorem Rat.normalize_eq :
    ∀ {num : ℤ} {den : ℕ} (den_nz : den ≠ 0),
      Rat.normalize num den den_nz =
        { num := num / ↑(Nat.gcd (Int.natAbs num) den), den := den / Nat.gcd (Int.natAbs num) den, den_nz := ⋯,
          reduced := ⋯ } :=
  by sorry

This theorem states that, for any integer `num` and any non-zero natural number `den`, the rational number obtained by normalizing `num` over `den` is equal to the rational number whose numerator is `num` divided by the greatest common divisor (gcd) of the absolute value of `num` and `den`, and whose denominator is `den` divided by the same gcd. Here, the normalization process involves dividing both the numerator and the denominator by their gcd to ensure that the resulting rational number is in its simplest or reduced form.

For any integer `num` and non-zero natural number `den`, the rational number `num / gcd(abs(num), den)` is equal to the rational number `(num / abs(num)) / (den / gcd(abs(num), den))`, where `gcd` denotes the greatest common divisor.


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

The theorem `Equiv.symm_image_image` states that for any types `α` and `β`, and any equivalence relation `e` between `α` and `β`, and for any set `s` of type `α`, the image of the image of `s` under `e` and its inverse `e.symm` is equal to `s` itself. In other words, applying an equivalence transformation to a set and then the reverse transformation brings us back to the original set. This theorem is a formal restatement of the intuitive idea that equivalence transformations are reversible.

For any equivalence relation `e` on types `α` and `β`, and any set `s` of type `α`, the image of `s` under `e` and then the image of that result under `e.symm` equals `s`.


theorem Finsupp.single_eq_pi_single :
    ∀ {α : Type u_1} {M : Type u_5} [inst : Zero M] [inst_1 : DecidableEq α] (a : α) (b : M),
      (⇑fun₀ | a => b) = Pi.single a b :=
  by sorry

The theorem `Finsupp.single_eq_pi_single` asserts that for any types `α` and `M` with `M` having an instance of `Zero` and `α` having decidable equality, for any element `a` of type `α` and any element `b` of type `M`, the function `fun₀` applied to `a` yielding `b` is equal to the function `Pi.single` applied to `a` and `b`. The function `Pi.single a b` is a function that maps `a` to `b` and every other element of the type `α` to zero. The function `fun₀ | a => b` is a function that only has a non-zero value at `a`, where it equals `b`. Hence, this theorem establishes the equivalence of these two functions that are defined differently but behave the same way.

For any type `α` with decidable equality and any type `M` with `Zero`, the function `fun₀ a := b` is equal to the function `Pi.single a b` for all `a : α` and `b : M`.


theorem toIocDiv_eq_of_sub_zsmul_mem_Ioc :
    ∀ {α : Type u_1} [inst : LinearOrderedAddCommGroup α] [hα : Archimedean α] {p : α} (hp : 0 < p) {a b : α} {n : ℤ},
      b - n • p ∈ Set.Ioc a (a + p) → toIocDiv hp a b = n :=
  by sorry

This theorem, `toIocDiv_eq_of_sub_zsmul_mem_Ioc`, states that for any type `α` that forms a linearly ordered additive commutative group with the Archimedean property, given a positive element `p`, and any two elements `a` and `b` of the group and any integer `n`, if the result of subtracting `n` times `p` from `b` belongs to the left-open right-closed interval from `a` to `a + p`, then the unique integer associated with `b` such that this multiple of `p`, subtracted from `b`, is in the same left-open right-closed interval- as defined by the function `toIocDiv`, is equal to `n`.

For any Archimedean additive commutative group type `α` with positive element `p`, if `n` is an integer such that `n * p` belongs to the left-open right-closed interval from `a` to `a + p`, then `toIocDiv a (b - n * p) = n`.


theorem ContinuousLinearEquiv.apply_symm_apply :
    ∀ {R₁ : Type u_1} {R₂ : Type u_2} [inst : Semiring R₁] [inst_1 : Semiring R₂] {σ₁₂ : R₁ →+* R₂} {σ₂₁ : R₂ →+* R₁}
      [inst_2 : RingHomInvPair σ₁₂ σ₂₁] [inst_3 : RingHomInvPair σ₂₁ σ₁₂] {M₁ : Type u_4} [inst_4 : TopologicalSpace M₁]
      [inst_5 : AddCommMonoid M₁] {M₂ : Type u_6} [inst_6 : TopologicalSpace M₂] [inst_7 : AddCommMonoid M₂]
      [inst_8 : Module R₁ M₁] [inst_9 : Module R₂ M₂] (e : M₁ ≃SL[σ₁₂] M₂) (c : M₂),
      e ((ContinuousLinearEquiv.symm e) c) = c :=
  by sorry

This theorem states that for any semirings `R₁` and `R₂` with ring homomorphisms `σ₁₂` and `σ₂₁` forming an inverse pair, and any types `M₁` and `M₂` that are topological spaces, additive commutative monoids, and modules over `R₁` and `R₂` respectively, and for any continuous linear equivalence `e` between `M₁` and `M₂`, the application of `e` after the application of the inverse of `e` to any element `c` of `M₂` results in `c`. In other words, applying a continuous linear equivalence and its inverse in succession is the identity operation on `M₂`. The proof for this mathematical statement is not shown here.

For any continuous linear equivalence between topological semimodules over commutative semirings with inverse homomorphisms, the composition of the equivalence and its inverse is the identity.


theorem hasFDerivAtFilter_iff_tendsto :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {f : E → F}
      {f' : E →L[𝕜] F} {x : E} {L : Filter E},
      HasFDerivAtFilter f f' x L ↔ Filter.Tendsto (fun x' => ‖x' - x‖⁻¹ * ‖f x' - f x - f' (x' - x)‖) L (nhds 0) :=
  by sorry

The theorem `hasFDerivAtFilter_iff_tendsto` states that for any nontrivially normed field `𝕜`, normed additive commutative groups `E` and `F`, and a function `f` mapping `E` to `F`, a derivative `f'` of `f` at a point `x` in the domain `E` exists with respect to a filter `L` if and only if the function, which maps `x'` to the norm of the difference between `x'` and `x` divided by the norm of the difference between `f` at `x'` and `f` at `x` minus `f'` applied to the difference between `x'` and `x`, tends to the neighborhood of zero under the filter `L`. Here, the term "neighborhood of zero" is defined in the context of topological spaces, and `HasFDerivAtFilter` represents the existence of a derivative at a point with respect to a filter.

A function between two normed additive commutative groups has a derivative at a point with respect to a filter if and only if the function value of the difference quotient, evaluated at points close to that point according to the filter, tends to zero.


theorem TopCat.mono_iff_injective : ∀ {X Y : TopCat} (f : X ⟶ Y), CategoryTheory.Mono f ↔ Function.Injective ⇑f := by
  sorry

This theorem states that for any two objects `X` and `Y` in the category of topological spaces (`TopCat`), a morphism `f` (which in this context is a continuous function) from `X` to `Y` is a monomorphism in the category theory sense if and only if it is injective as a function. In other words, a continuous map between topological spaces is a category-theoretic monomorphism precisely when it has the property that equal outputs imply equal inputs.

A continuous function between topological spaces is a monomorphism in the category of topological spaces if and only if it is an injective function.


/-- Uses `left` co(ntra)variant. -/
theorem Left.neg_pos_iff :
    ∀ {α : Type u} [inst : AddGroup α] [inst_1 : LT α]
      [inst_2 : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x < x_1] {a : α}, 0 < -a ↔ a < 0 :=
  by sorry

This theorem, named `Left.neg_pos_iff`, states that for any type `α`, assuming it is an additive group and has a defined 'less than' operation such that it is left-covariant (i.e., the operation respects the order when an element is added on the left), then a negative `a` is greater than zero if and only if `a` is less than zero. In simpler terms, it is stating that a number is negative if and only if its negation is positive, under the assumptions of `α` being an additive group with a left-covariant 'less than' operation.

For any additive group type `α` with a left-covariant 'less than' relation, `a < 0` if and only if `-a > 0`.


theorem Polynomial.coeff_C_mul_X_pow :
    ∀ {R : Type u} [inst : Semiring R] (x : R) (k n : ℕ),
      Polynomial.coeff (Polynomial.C x * Polynomial.X ^ k) n = if n = k then x else 0 :=
  by sorry

This theorem, named `Polynomial.coeff_C_mul_X_pow`, states that for any semiring `R`, any element `x` of `R`, and any natural numbers `k` and `n`, the coefficient of `X^n` in the polynomial formed by multiplying the constant polynomial `x` with `X` raised to the power `k` (i.e., `Polynomial.C x * Polynomial.X ^ k`) is `x` if `n` equals `k` and `0` otherwise. In other words, this polynomial has `x` as the coefficient of `X^k` and `0` as the coefficient of `X^n` for any `n` not equal to `k`.

For any semiring `R`, the coefficient of `X^k` in the product of the constant polynomial `x` in `R` and `X^k` is `x`, while the coefficient of `X^n` for `n ≠ k` is `0`.


/-- **Formula for the Number of Combinations**  -/
theorem Finset.card_powersetCard :
    ∀ {α : Type u_1} (n : ℕ) (s : Finset α), (Finset.powersetCard n s).card = Nat.choose s.card n := by sorry

This is a theorem stating the formula for the number of combinations. For any given type `α`, natural number `n`, and finite set `s` of type `α`, the cardinality of the power set of `s` with subsets of cardinality `n` (represented by `Finset.powersetCard n s`) is equal to the binomial coefficient of `s`'s cardinality choose `n`, denoted by `Nat.choose s.card n`. In essence, it is specifying the count of all possible `n`-element subsets that can be formed from an `n`-element set `s`.

The cardinality of the set of subsets of a finite type `α` with cardinality `n` is equal to the binomial coefficient `Nat.choose n (cardinality of the set)`.


/-- **The Jordan decomposition theorem**: Given a signed measure `s`, there exists a pair of
mutually singular measures `μ` and `ν` such that `s = μ - ν`. In this case, the measures `μ`
and `ν` are given by `s.toJordanDecomposition.posPart` and
`s.toJordanDecomposition.negPart` respectively.

Note that we use `MeasureTheory.JordanDecomposition.toSignedMeasure` to represent the
signed measure corresponding to
`s.toJordanDecomposition.posPart - s.toJordanDecomposition.negPart`.  -/
theorem MeasureTheory.SignedMeasure.toSignedMeasure_toJordanDecomposition :
    ∀ {α : Type u_1} [inst : MeasurableSpace α] (s : MeasureTheory.SignedMeasure α),
      MeasureTheory.JordanDecomposition.toSignedMeasure (MeasureTheory.SignedMeasure.toJordanDecomposition s) = s :=
  by sorry

**The Jordan Decomposition Theorem**: In the context of a measurable space `α`, this theorem states that for any given signed measure `s`, it is possible to find a pair of mutually singular measures `μ` and `ν` such that `s` can be expressed as the difference `μ - ν`. Here, `μ` and `ν` correspond to the positive and negative parts, respectively, of the Jordan Decomposition of `s`. The function `MeasureTheory.JordanDecomposition.toSignedMeasure` is used to construct the signed measure associated with the Jordan Decomposition, i.e., the difference of the positive part and the negative part of the Jordan Decomposition of `s`. The theorem asserts the equality between this constructed signed measure and the original signed measure `s`.

Given a signed measure `s` on a measurable space `α`, there exist mutually singular measures `μ` and `ν` such that `s = μ - ν`.


theorem Sym.coe_injective : ∀ {α : Type u_1} {n : ℕ}, Function.Injective Sym.toMultiset := by sorry

The theorem `Sym.coe_injective` states that for any type `α` and any natural number `n`, the function `Sym.toMultiset` is injective. In other words, for any two elements of Sym of size `n`, if their mappings to `Multiset α` (derived via the function `Sym.toMultiset`) are the same, then the two original elements of Sym are also the same. This means that the `Sym.toMultiset` function does not map different Sym elements to the same Multiset, thereby preserving the uniqueness of Sym elements in the multiset representation.

The `Sym.toMultiset` function maps distinct elements in `Sym` to distinct multisets.


theorem Quiver.reverse_reverse :
    ∀ {V : Type u_2} [inst : Quiver V] [h : Quiver.HasInvolutiveReverse V] {a b : V} (f : a ⟶ b),
      Quiver.reverse (Quiver.reverse f) = f :=
  by sorry

The theorem `Quiver.reverse_reverse` states that for any type `V` that has a structure of a `Quiver` and an involution on the reversal operation, given any two objects `a` and `b` in this `Quiver` and a morphism `f` from `a` to `b`, applying the `reverse` operation twice on the morphism `f` (which flips its direction) returns the original morphism `f`. In other words, reversing the direction of a reversed morphism brings it back to its original form. This theorem essentially encapsulates the mathematical property that reversal is an involution (a function that is its own inverse).

For any object pair `a` and `b` in a quiver `V` with an involution on reversal, and any morphism `f` from `a` to `b`, we have `reverse (reverse f) = f`.


HasMFDerivAt.mdifferentiableAt

theorem HasMFDerivAt.mdifferentiableAt :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {H : Type u_3} [inst_3 : TopologicalSpace H] {I : ModelWithCorners 𝕜 E H}
      {M : Type u_4} [inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] {E' : Type u_5}
      [inst_6 : NormedAddCommGroup E'] [inst_7 : NormedSpace 𝕜 E'] {H' : Type u_6} [inst_8 : TopologicalSpace H']
      {I' : ModelWithCorners 𝕜 E' H'} {M' : Type u_7} [inst_9 : TopologicalSpace M'] [inst_10 : ChartedSpace H' M']
      {f : M → M'} {x : M} [Is : SmoothManifoldWithCorners I M] [I's : SmoothManifoldWithCorners I' M']
      {f' : TangentSpace I x →L[𝕜] TangentSpace I' (f x)}, HasMFDerivAt I I' f x f' → MDifferentiableAt I I' f x :=
  by sorry

This theorem states that given a smooth manifold with corners `I` and `I'` over a non-trivially normed field `𝕜`, if there is a function `f` from manifold `M` to `M'` that has a manifold derivative `f'` at a point `x` in `M` (i.e., `HasMFDerivAt I I' f x f'`), then `f` is differentiable at `x` in the manifold sense (i.e., `MDifferentiableAt I I' f x`). In other words, having a manifold derivative implies manifold differentiability.

A smooth manifold function `f` with manifold derivatives at a point `x` implies `f` is differentiable at `x` in the manifold sense.


theorem EuclideanDomain.mul_div_cancel :
    ∀ {R : Type u} [inst : EuclideanDomain R] (a : R) {b : R}, b ≠ 0 → a * b / b = a := by sorry

This theorem states that for any type `R` that forms a Euclidean domain, for any elements `a` and `b` in `R` such that `b` is not zero, the operation of multiplying `a` and `b` together and then dividing by `b` will always yield `a`. Essentially, it's a restatement of the usual algebraic rule that if you multiply something and then divide by the same non-zero number, you get the original number back.

For any Euclidean domain `R` and elements `a, b` in `R` with `b ≠ 0`, we have `a * (1 / b) = a`.


theorem upperBounds_mono_set :
    ∀ {α : Type u} [inst : Preorder α] ⦃s t : Set α⦄, s ⊆ t → upperBounds t ⊆ upperBounds s := by sorry

The theorem `upperBounds_mono_set` states that for any type `α` which has a preorder (a reflexive and transitive binary relation), if one set `s` is a subset of another set `t`, then the set of upper bounds of `t` is a subset of the set of upper bounds of `s`. In more detail, an element `x` is an upper bound of a set if each element `a` in the set is less than or equal to `x`. Therefore, if `s` is a subset of `t`, every upper bound for `t` will also be an upper bound for `s`.

If `α` is a type with a preorder and `s` is a subset of `t`, then the set of upper bounds of `s` is included in the set of upper bounds of `t`.


theorem sub_sub_sub_cancel_left : ∀ {G : Type u_3} [inst : AddCommGroup G] (a b c : G), c - a - (c - b) = b - a := by
  sorry

The theorem `sub_sub_sub_cancel_left` states that for any type `G` that forms an additive commutative group, for any elements `a`, `b`, `c` in `G`, the result of the operation `c - a - (c - b)` equals to `b - a`. This can be interpreted in terms of subtraction as: subtracting `a` from `c`, and then subtracting the result from `c - b` yields the same result as simply subtracting `a` from `b`.

For any additive commutative group (G, +), and elements a, b, c in G, we have c - a - (c - b) = b - a.


TopologicalSpace.CompactOpens.isOpen

theorem TopologicalSpace.CompactOpens.isOpen :
    ∀ {α : Type u_1} [inst : TopologicalSpace α] (s : TopologicalSpace.CompactOpens α), IsOpen ↑s := by sorry

The theorem `TopologicalSpace.CompactOpens.isOpen` states that for any type `α` with a topological space structure, if `s` is a set in the `CompactOpens` of `α`, then `s` is an open set in the ambient topological space on `α`. Here, the `CompactOpens` of a topological space refers to the collection of open sets that are compact.

A compact open set in a topological space is an open set.


theorem Fin.forall_iff_succAbove :
    ∀ {n : ℕ} {p : Fin (n + 1) → Prop} (i : Fin (n + 1)),
      (∀ (j : Fin (n + 1)), p j) ↔ p i ∧ ∀ (j : Fin n), p (Fin.succAbove i j) :=
  by sorry

This theorem states that for any natural number `n`, any predicate `p` on 'finite numbers' less than or equal to `n + 1`, and any 'finite number' `i` less than or equal to `n + 1`, the predicate `p` holds for all 'finite numbers' less than or equal to `n + 1` if and only if `p` holds for `i` and for all 'finite numbers' `j` less than `n`, `p` holds for the result of the function `Fin.succAbove i j`. Here, `Fin.succAbove i j` is a function that 'embeds' a 'finite number' `j` from a set of size `n` into a set of size `n + 1`, preserving the order but placing a 'hole' at the position `i`.

For any natural number `n`, predicate `p` on finite numbers up to `n+1`, and finite number `i` <= `n+1`, `p` holds for all finite numbers up to `n+1` if and only if `p(i)` holds and for all `j` < `n`, `p` holds for `Fin.succAbove i j`.


theorem List.count_cons :
    ∀ {α : Type u_1} [inst : DecidableEq α] (a b : α) (l : List α),
      List.count a (b :: l) = List.count a l + if a = b then 1 else 0 :=
  by sorry

This theorem, `List.count_cons`, states that for any type `α` that has decidable equality and for any elements `a` and `b` of this type and a list `l` of elements of the same type, the count of the element `a` in the list formed by consing `b` to `l` i.e., `b :: l`, is equal to the count of `a` in the original list `l` plus 1 if `a` is equal to `b`, and plus 0 otherwise. In other words, it determines how the count of an element in a list changes when a new element is added to the front of the list. If the new element is same as the one being counted, it increases the count by one, otherwise the count remains the same.

For any type `α` with decidable equality and list `l` of elements `α`, the count of an element `a` in the list `b :: l` is `if a = b then succ (count a l) else count a l`.


theorem lt_or_ge : ∀ {α : Type u} [inst : LinearOrder α] (a b : α), a < b ∨ a ≥ b := by sorry

This theorem, `lt_or_ge`, states that for any given type `α` that has a linear order, for any two elements `a` and `b` of type `α`, `a` is either less than `b` or `a` is greater than or equal to `b`. This is a fundamental property of linearly ordered sets, expressing that any two elements in such a set can be compared, and either one is less than the other or they are equal or the first one is greater.

For all linearly ordered types `α` and elements `a` and `b` of type `α`, either `a < b` or `a >= b`.


theorem Nat.factorization_one : Nat.factorization 1 = 0 := by sorry

The theorem `Nat.factorization_one` asserts that the prime factorization of the number 1 is equal to zero. In other words, the number 1 does not have any prime factors, and hence the function `Nat.factorization` when applied to 1 yields zero, indicating that there are no prime factors to count.

The theorem asserts that the prime factorization of 1 in the natural numbers is the empty product.


theorem induced_id : ∀ {α : Type u_1} [t : TopologicalSpace α], TopologicalSpace.induced id t = t := by sorry

The theorem `induced_id` states that for any type `α` equipped with a topology `t`, the topology induced by the identity function `id` on `α` is the same as the original topology `t`. This means that applying the identity function does not change the topological structure of the space `α`.

The identity function preserves the topology on a space, i.e., the topology induced by the identity function on a topological space is equal to the original topology.


theorem LE.le.gt_iff_ne : ∀ {α : 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, for any two elements `a` and `b` of type `α`, if `a` is less than or equal to `b`, then `a` is strictly less than `b` if and only if `b` is not equal to `a`. In other words, the only way `a` can be strictly less than `b` is if `a` and `b` are not the same element, given that `a` is less than or equal to `b`. This is a basic property of ordered sets.

In an ordered set, for all elements `a` and `b`, if `a ≤ b` then `a < b` if and only if `a ≠ b`.


theorem continuous_inner :
    ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E],
      Continuous fun p => ⟪p.1, p.2⟫_𝕜 :=
  by sorry

This theorem states that for any type `𝕜` and `E`, where `𝕜` is a ring-completeness-like structure, `E` is a normed commutative additive group, and `E` is an inner product space over `𝕜`, the inner product of any pair of elements in `E` is a continuous function. In mathematical terms, it means the inner product operation is continuous in this inner product space.

Given a ring-completeness-like structure `𝕜`, a normed commutative additive group `E` over `𝕜`, and an inner product space `E` over `𝕜`, the inner product is a continuous function on `E × E`.


theorem RingHom.finiteType_is_local : RingHom.PropertyIsLocal @RingHom.FiniteType := by sorry

The theorem `RingHom.finiteType_is_local` states that the property of a ring homomorphism being of 'FiniteType' is local. This means that for a given ring homomorphism from ring A to ring B, if every localization of ring A at a prime ideal has the ring homomorphism property of 'FiniteType', then the original ring homomorphism also has the 'FiniteType' property. In other words, if B is finitely generated as an A-algebra for all localizations of A at a prime ideal, then B is finitely generated as an A-algebra.

If every localization of a ring homomorphism from ring A to ring B preserves finiteness of types, then the homomorphism itself has finite type.


theorem Mathlib.GroupTheory.Subgroup.Basic._auxLemma.1 :
    ∀ {S : Type u_5} {G : Type u_6} [inst : InvolutiveInv G] {x : SetLike S G} [inst_1 : InvMemClass S G] {H : S}
      {x_1 : G}, (x_1⁻¹ ∈ H) = (x_1 ∈ H) :=
  by sorry

The theorem states that for any types `S` and `G`, given that `G` has an involution, and `S` is a set-like structure over `G` that supports membership operation, for any element `H` of `S` and any element `x_1` of `G`, `x_1` being an element of `H` is equivalent to its inverse `x_1⁻¹` being an element of `H`. In other words, in the context of a group with involutive inversion, an element is in a subgroup if and only if its inverse is also in the subgroup.

In a group with involutive inversion, an element is in a subset if and only if its inverse is in the subset.


theorem Function.leftInverse_invFun :
    ∀ {α : Sort u_1} {β : Sort u_2} [inst : Nonempty α] {f : α → β},
      Function.Injective f → Function.LeftInverse (Function.invFun f) f :=
  by sorry

The theorem `Function.leftInverse_invFun` states that for any types `α` and `β` and a function `f` from `α` to `β`, if `α` is nonempty and `f` is an injective function, then the inverse function `Function.invFun f` is a left inverse to `f`. In other words, if `f` is a function that does not map different elements of `α` to the same element of `β`, then applying `f` and then its inverse will return the original value for all elements in `α`, i.e., `(Function.invFun f) ∘ f = id`.

If `f` is an injective function from a nonempty `α` to `β`, then `Function.invFun f ∘ f = id`.


theorem Set.Iic_top : ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : OrderTop α], Set.Iic ⊤ = Set.univ := by sorry

This theorem states that for any type `α` that has a preorder and a top order (an order where there is a greatest element), the left-infinite right-closed interval `Set.Iic ⊤` (which is the set of all elements that are less than or equal to the greatest element in the type) is equal to the universal set `Set.univ` (the set containing all elements of `α`). In terms of mathematical language, it means that for any set with a preorder and a greatest element ⊤, the interval (-∞, ⊤] corresponds to the whole set.

For any type with a preorder and a top element, the left-open, right-closed interval [bottom, top] equals the universal set. (Here, bottom denotes the least element in the preorder, which may or may not exist, and top denotes the greatest element.)


theorem Ordinal.bsup_le :
    ∀ {o : Ordinal.{u}} {f : (b : Ordinal.{u}) → b < o → Ordinal.{max u v}} {a : Ordinal.{max u v}},
      (∀ (i : Ordinal.{u}) (h : i < o), f i h ≤ a) → Ordinal.bsup o f ≤ a :=
  by sorry

The theorem `Ordinal.bsup_le` states that for any ordinal `o`, function `f` from a smaller ordinal to another ordinal, and ordinal `a`, if for all `i` less than `o`, `f(i)` is less than or equal to `a`, then the supremum of the family of ordinals indexed by the ordinals less than `o` (computed by `Ordinal.bsup o f`) is also less than or equal to `a`. In other words, if all ordinals in a family are bounded above by `a`, then the least upper bound (supremum) of the family, obtained by `Ordinal.bsup`, is also bounded above by `a`.

For any ordinal `o`, function `f` from a smaller ordinal to an ordinal, and ordinal `a`, if `f(i) ≤ a` for all `i` less than `o`, then `Ordinal.bsup o f ≤ a`.


theorem Multiset.count_inter :
    ∀ {α : Type u_1} [inst : DecidableEq α] (a : α) (s t : Multiset α),
      Multiset.count a (s ∩ t) = min (Multiset.count a s) (Multiset.count a t) :=
  by sorry

This theorem is about multisets in a given type `α` which has decidable equality. It states that for any element `a` in type `α`, and any two multisets `s` and `t` of type `α`, the multiplicity of the element `a` in the intersection of `s` and `t` is equal to the minimum of its multiplicity in `s` and its multiplicity in `t`. In other words, the number of occurrences of the element `a` in the intersection of two multisets is the same as the smallest number of occurrences of `a` in either of the original multisets.

For multisets $s$ and $t$ over a type $\alpha$ with decidable equality, the multiplicity of any element $a$ in their intersection equals the minimum of its multiplicity in $s$ and its multiplicity in $t$.


theorem Nat.boddDiv2_eq : ∀ (n : ℕ), Nat.boddDiv2 n = (Nat.bodd n, Nat.div2 n) := by sorry

The theorem `Nat.boddDiv2_eq` states that for any natural number `n`, the function `Nat.boddDiv2` on `n` returns a pair: the first element of the pair is the result of the function `Nat.bodd` on `n` (which checks if `n` is odd), and the second element is the result of the function `Nat.div2` on `n` (which calculates the greatest integer less than or equal to `n/2`). In other words, the `Nat.boddDiv2` function simultaneously calculates and returns whether a number is odd and its integer division by 2.

For any natural number `n`, the function `Nat.boddDiv2` returns a pair `(Nat.bodd n, Nat.div2 n)`.


theorem abs_eq_zero :
    ∀ {α : Type u_1} [inst : AddGroup α] [inst_1 : LinearOrder α]
      [inst_2 : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] {a : α}
      [inst_3 : CovariantClass α α (Function.swap fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1], |a| = 0 ↔ a = 0 :=
  by sorry

The theorem `abs_eq_zero` states that for any type `α` that is an additive group, a linear order, and possesses two specific covariance properties with respect to addition and order, the absolute value of an element `a` of type `α` equals zero if and only if `a` itself equals zero. In other words, within this mathematical structure, the only element whose absolute value is zero is the zero element itself.

For any additive group, linear order type `α` with specific covariance properties, absolute value of `a` in `α` equals zero if and only if `a` is the zero element.


theorem eq_zero_of_ne_zero_of_mul_right_eq_zero :
    ∀ {M : Type u_2} [inst : MonoidWithZero M] [inst_1 : NoZeroDivisors M] {x y : M}, x ≠ 0 → y * x = 0 → y = 0 := by
  sorry

This theorem states that for any type `M` that is a `MonoidWithZero` and `NoZeroDivisors`, given two elements `x` and `y` of this type, if `x` is not zero and the product of `y` and `x` is zero, then `y` must be zero. In plain language, in a multiplication scenario where we have non-zero divisors and the product with a non-zero number results in zero, the other factor must be zero.

If `M` is a `MonoidWithZero` and `NoZeroDivisors` type, then for all non-zero `x` in `M`, if `x * y = 0`, then `y = 0`.


theorem Filter.HasBasis.to_hasBasis' :
    ∀ {α : Type u_1} {ι : Sort u_4} {ι' : Sort u_5} {l : Filter α} {p : ι → Prop} {s : ι → Set α} {p' : ι' → Prop}
      {s' : ι' → Set α},
      Filter.HasBasis l p s →
        (∀ (i : ι), p i → ∃ i', p' i' ∧ s' i' ⊆ s i) → (∀ (i' : ι'), p' i' → s' i' ∈ l) → Filter.HasBasis l p' s' :=
  by sorry

This theorem states that for any type `α`, index types `ι` and `ι'`, a filter `l` on `α`, two predicates `p` and `p'` on `ι` and `ι'` respectively, and two functions `s` and `s'` from `ι` and `ι'` to sets of `α` respectively, if `l` has a basis characterized by `p` and `s`, and for every index `i` of type `ι` for which `p i` holds, there exists an index `i'` of type `ι'` such that `p' i'` holds and `s' i'` is a subset of `s i`, and for every index `i'` of type `ι'` for which `p' i'` holds, `s' i'` belongs to `l`, then `l` also has a basis characterized by `p'` and `s'`. This theorem is about the transferability of basis properties in the context of filters.

If a filter on a type has a basis characterized by a predicate and a function, and for each index satisfying the predicate there exists another index with the same property and the function mapping to a subset, and conversely every index satisfying the second predicate is in the filter, then the filter has an equivalent basis given by the second predicate and function.


theorem pow_card_eq_one : ∀ {G : Type u_1} [inst : Group G] [inst_1 : Fintype G] {x : G}, x ^ Fintype.card G = 1 := by
  sorry

The theorem `pow_card_eq_one` states that for any finite group `G` and any element `x` of `G`, the element `x` raised to the power of the cardinality (or size) of `G` (denoted by `Fintype.card G`) equals the group's identity element. In mathematical terms, given a finite group `G` with `n` elements (where `n` is the number of elements in `G`), for all `x` in `G`, `x^n = 1`, where `1` is the identity element in `G`.

For any finite group G and any of its elements x, x raised to the power of the group's cardinality equals the identity element. (x^(Fintype.card G) = 1)


theorem Metric.vadd_closedBall :
    ∀ {G : Type v} {X : Type w} [inst : PseudoMetricSpace X] [inst_1 : AddGroup G] [inst_2 : AddAction G X]
      [inst_3 : IsometricVAdd G X] (c : G) (x : X) (r : ℝ), c +ᵥ Metric.closedBall x r = Metric.closedBall (c +ᵥ x) r :=
  by sorry

The theorem `Metric.vadd_closedBall` states that for any pseudometric space `X`, any additive group `G`, any action of `G` on `X`, and any isometric vector addition in `X`, for any elements `c` in `G`, `x` in `X`, and any real number `r`, the vector addition of `c` and the closed ball centered at `x` with radius `r` in `X` is equal to the closed ball in `X` centered at the vector addition of `c` and `x` with the same radius `r`. In other words, adding a vector to all points in a closed ball is equivalent to shifting the center of the ball by the same vector.

For any pseudometric space X, additive group G acting on X, and isometric vector addition, the closed ball centered at x in X with radius r is equal to the closed ball centered at c × x in X with radius r, where c is an element of G.


Measurable.ite

/-- This is slightly different from `Measurable.piecewise`. It can be used to show
`Measurable (ite (x=0) 0 1)` by
`exact Measurable.ite (measurableSet_singleton 0) measurable_const measurable_const`,
but replacing `Measurable.ite` by `Measurable.piecewise` in that example proof does not work.  -/
theorem Measurable.ite :
    ∀ {α : Type u_1} {β : Type u_2} {f g : α → β} {m : MeasurableSpace α} {mβ : MeasurableSpace β} {p : α → Prop}
      {x : DecidablePred p},
      MeasurableSet {a | p a} → Measurable f → Measurable g → Measurable fun x_1 => if p x_1 then f x_1 else g x_1 :=
  by sorry

This theorem, `Measurable.ite`, states that for any two types `α` and `β`, any two functions `f` and `g` from `α` to `β`, any measurable space `m` on `α`, any measurable space `mβ` on `β`, and any decidable predicate `p` on `α`, if the set `{a | p a}` is a measurable set, and if both functions `f` and `g` are measurable, then the function which takes an input `x_1` and outputs `f x_1` if `p x_1` is true, else outputs `g x_1`, is also measurable. This theorem is slightly different from `Measurable.piecewise` and can be used to show that functions like `Measurable (ite (x=0) 0 1)` are measurable.

If `p` is a decidable predicate on measurable space `(α, m)`, `f` and `g` are measurable functions from `α` to `β`, and the set `{a | p a}` is measurable, then the function `x ↦ if p x then f x else g x` is measurable from `(α, m)` to `(β, mβ)`.


theorem Mathlib.MeasureTheory.Constructions.Cylinders._auxLemma.13 :
    ∀ {ι : Type u_1} {α : ι → Type u_2} (s : Finset ι) (S : Set ((i : { x // x ∈ s }) → α ↑i)) (f : (i : ι) → α i),
      (f ∈ MeasureTheory.cylinder s S) = ((fun i => f ↑i) ∈ S) :=
  by sorry

This theorem states that for any type `ι`, a function `α` from `ι`, a finite set `s` of indices of type `ι`, a set `S` of functions from indices in `s` to `α` and a function `f` from `ι` to `α`, the function `f` being in the cylinder of `s` and `S` (which is the preimage of a set `S` of `∀ i : s, α i` by the projection from `∀ i, α i` to `∀ i : s, α i`) is equivalent to the function that maps each index in `s` to `f` of that index being in `S`. This essentially provides a condition to check if a function is in the cylinder set for given `s` and `S`.

For any type `ι`, function `α : ι → Type`, finite set `s ⊆ ι`, set `S ⊆ ∀ i : s, α i`, and function `f : ι → α`, `f` is in the cylinder of `s` and `S` if and only if `{i | i ∈ s ∧ f i ∈ S}` equals `s`.


theorem multiplicity.multiplicity_le_multiplicity_iff :
    ∀ {α : Type u_1} {β : Type u_2} [inst : Monoid α] [inst_1 : Monoid β] [inst_2 : DecidableRel fun x x_1 => x ∣ x_1]
      [inst_3 : DecidableRel fun x x_1 => x ∣ x_1] {a b : α} {c d : β},
      multiplicity a b ≤ multiplicity c d ↔ ∀ (n : ℕ), a ^ n ∣ b → c ^ n ∣ d :=
  by sorry

The theorem `multiplicity.multiplicity_le_multiplicity_iff` states that for any two types `α` and `β` with `Monoid` structures, and `DecidableRel` relations defined on them as the divisibility relation, given any elements `a` and `b` of type `α`, and `c` and `d` of type `β`, the multiplicity of `a` in `b` is less than or equal to the multiplicity of `c` in `d` if and only if for all natural numbers `n`, if `a` raised to the power `n` divides `b`, then `c` raised to the power `n` divides `d`. Here, the multiplicity of one element in another is defined as the largest natural number `n` such that the first element raised to the power `n` divides the second.

The theorem `multiplicity.multiplicity_le_multiplicity_iff` in Lean 4 states that for `Monoid` types `α` and `β` with decidable divisibility relations, the multiplicity of `a` in `b` is less than or equal to the multiplicity of `c` in `d` if and only if for all natural numbers `n`, `a^n` divides `b` implies `c^n` divides `d`.


Filter.EventuallyConst.comp

theorem Filter.EventuallyConst.comp :
    ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {l : Filter α} {f : α → β},
      Filter.EventuallyConst f l → ∀ (g : β → γ), Filter.EventuallyConst (g ∘ f) l :=
  by sorry

The theorem `Filter.EventuallyConst.comp` states that for any types `α`, `β`, and `γ`, and any filter `l` on `α` and functions `f` from `α` to `β` and `g` from `β` to `γ`, if the function `f` is eventually constant along the filter `l`, then the composition of `g` and `f` (denoted as `g ∘ f`) is also eventually constant along the filter `l`. Essentially, this theorem indicates that the property of being "eventually constant" is preserved under function composition.

If a function `f : α → β` is eventually constant along a filter `l` on `α`, then the composition `g ∘ f` of `g : β → γ` with `f` is also eventually constant along `l`.


SimpleGraph.Reachable.refl

theorem SimpleGraph.Reachable.refl : ∀ {V : Type u} {G : SimpleGraph V} (u : V), SimpleGraph.Reachable G u u := by sorry

This theorem states that for any type `V` and any simple graph `G` with vertices of type `V`, every vertex `u` in `G` is reachable from itself. In other words, there exists a walk (possibly empty) in graph `G` that starts and ends at the same vertex `u`. This is an aspect of the reflexivity property in reachability in graphs.

For any simple graph `G` with vertices of type `V`, every vertex `u` in `G` is reachable from itself. Equivalently, there exists a walk of length 0 or more in `G` starting and ending at any vertex `u`.


theorem Finset.Icc_subset_Icc :
    ∀ {α : Type u_2} [inst : Preorder α] [inst_1 : LocallyFiniteOrder α] {a₁ a₂ b₁ b₂ : α},
      a₂ ≤ a₁ → b₁ ≤ b₂ → Finset.Icc a₁ b₁ ⊆ Finset.Icc a₂ b₂ :=
  by sorry

This theorem, `Finset.Icc_subset_Icc`, states that for any type `α` which is equipped with a preorder and a locally finite order, and for any elements `a₁`, `a₂`, `b₁`, `b₂` of `α`, if `a₂` is less than or equal to `a₁` and `b₁` is less than or equal to `b₂`, then the finite set of elements `x` such that `a₁ ≤ x` and `x ≤ b₁` is a subset of the finite set of elements `x` such that `a₂ ≤ x` and `x ≤ b₂`. In other words, if the starting and ending elements of one closed interval are respectively greater than or equal to the starting and ending elements of another closed interval, then the first interval is contained within the second.

For any locally finite preordered type `α` and elements `a₁ ≤ a₂`, `b₁ ≤ b₂` in `α`, the interval `[a₁, b₁]` is contained in the interval `[a₂, b₂]`.


theorem Subgroup.Normal.mem_comm_iff :
    ∀ {G : Type u_1} [inst : Group G] {H : Subgroup G}, Subgroup.Normal H → ∀ {a b : G}, a * b ∈ H ↔ b * a ∈ H := by
  sorry

This theorem states that for any group `G` and any subgroup `H` of `G`, if `H` is a normal subgroup, then for any two elements `a` and `b` of `G`, `a * b` is in `H` if and only if `b * a` is in `H`. Here `*` denotes the group operation in `G`. This means, in the context of group theory, that the product of `a` and `b` belongs to the subgroup `H` if and only if the product of `b` and `a` (i.e., the order of multiplication is reversed) also belongs to `H`.

If `H` is a normal subgroup of group `G`, then for all `a, b` in `G`, `a * b` is in `H` if and only if `b * a` is in `H`.


theorem MeasureTheory.SimpleFunc.coe_add :
    ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] [inst_1 : Add β] (f g : MeasureTheory.SimpleFunc α β),
      ↑(f + g) = ↑f + ↑g :=
  by sorry

This theorem states that for any two simple functions `f` and `g`, which are defined over a measurable space `α` and take values in an additive space `β`, the measure of the sum `f + g` equals to the sum of their respective measures. In other words, the measure of the sum of two simple functions is the sum of their measures. This property is fundamental in measure theory and integral calculus.

For simple functions `f` and `g` on measurable space `α` with values in an additive space `β`, their sum `f + g` has the same measure as the sum of their individual measures.


theorem Sum.Lex.inl_le_inl_iff :
    ∀ {α : Type u_1} {β : Type u_2} [inst : LE α] [inst_1 : LE β] {a b : α},
      toLex (Sum.inl a) ≤ toLex (Sum.inl b) ↔ a ≤ b :=
  by sorry

This theorem states that for any two objects `a` and `b` of a certain type `α`, the inequality of `toLex (Sum.inl a)` and `toLex (Sum.inl b)` is equivalent to the inequality of `a` and `b` themselves. Here, `toLex` is a function that just renames its input as the Lex type, `Sum.inl` is a function that injects its input into the left component of a sum type, and `≤` denotes a general notion of "less than or equal to". The theorem holds in the context where `α` and `β` are any types, and `α` has a specified "less than or equal to" relation.

For any type `α` with a "less than or equal to" relation, and for all objects `a` and `b` of type `α`, `toLex (Sum.inl a) ≤ toLex (Sum.inl b)` if and only if `a ≤ b`.


theorem PosNum.mul_to_nat : ∀ (m n : PosNum), ↑(m * n) = ↑m * ↑n := by sorry

This theorem states that for all positive numbers `m` and `n`, the natural number equivalent of the product of `m` and `n` is equal to the product of the natural number equivalents of `m` and `n`. In other words, multiplication in the domain of positive numbers and then conversion to natural numbers preserves the same result as conversion to natural numbers first and then multiplication.

For all positive integers m and n, the conversion of m \* n to natural numbers is equal to the natural number equivalent of m multiplied by the natural number equivalent of n.


theorem Fintype.card_ulift : ∀ (α : Type u_4) [inst : Fintype α], Fintype.card (ULift.{u_5, u_4} α) = Fintype.card α :=
  by sorry

The theorem `Fintype.card_ulift` states that for any type `α` that is a finite set (or `Fintype`), the cardinality (or the number of elements) of the type `ULift.{u_5, u_4} α` is equal to the cardinality of the type `α`. Here, `ULift.{u_5, u_4} α` represents a type that is equivalent to `α` but lives in a different universe of types. Hence, this theorem highlights that lifting a type to a different universe does not change its cardinality.

The cardinality of a finite type `α` is equal to the cardinality of `ULift.{u_5, u_4} α`.


theorem differentiableAt_inv :
    ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {x : 𝕜}, DifferentiableAt 𝕜 (fun x => x⁻¹) x ↔ x ≠ 0 := by sorry

The theorem `differentiableAt_inv` states that for any point `x` in a non-trivially normed field `𝕜`, the function `f(x) = x⁻¹` (the reciprocal function) is differentiable at `x` if and only if `x` is not zero. This means that the reciprocal function has a derivative at any point `x` that is not zero, and it does not have a derivative at `x = 0`.

The reciprocal function is differentiable at a point in a non-trivially normed field if and only if that point is non-zero.


theorem NNReal.coe_sub : ∀ {r₁ r₂ : NNReal}, r₂ ≤ r₁ → ↑(r₁ - r₂) = ↑r₁ - ↑r₂ := by sorry

This theorem states that for any two non-negative real numbers `r₁` and `r₂`, if `r₂` is less than or equal to `r₁`, then the real number coercion of the difference between `r₁` and `r₂` (that is `r₁ - r₂`) is equal to the difference between the real number coercions of `r₁` and `r₂` (that is `↑r₁ - ↑r₂`). Essentially, it's saying that subtraction behaves the same way in the set of all non-negative real numbers as it does in the set of all real numbers, when the second number is less than or equal to the first.

For all non-negative real numbers `r₁` and `r₂` with `r₂ ≤ r₁`, the real number coercion of `r₁ - r₂` equals `↑r₁ - ↑r₂`.


theorem mem_nonZeroDivisors_of_ne_zero :
    ∀ {M : Type u_2} [inst : MonoidWithZero M] [inst_1 : NoZeroDivisors M] {x : M}, x ≠ 0 → x ∈ nonZeroDivisors M := by
  sorry

This theorem states that for any MonoidWithZero `M` (a type of mathematical structure that combines the features of a group with zero and a monoid) and given that `M` has no zero divisors (no pair of non-zero elements that multiply to zero), if `x` is an element of `M` and `x` is not zero, then `x` belongs to the submonoid of non-zero divisors of `M`. In simple words, any non-zero element in a monoid with zero and no zero divisors is a non-zero divisor.

In a MonoidWithZero without zero divisors, every non-zero element is a non-zero divisor.


Filter.Tendsto.dist

theorem Filter.Tendsto.dist :
    ∀ {α : Type u} {β : Type v} [inst : PseudoMetricSpace α] {f g : β → α} {x : Filter β} {a b : α},
      Filter.Tendsto f x (nhds a) →
        Filter.Tendsto g x (nhds b) → Filter.Tendsto (fun x => dist (f x) (g x)) x (nhds (dist a b)) :=
  by sorry

This theorem states that for any two functions `f` and `g` from a type `β` to a pseudometric space `α`, if `f` tends to `a` and `g` tends to `b` (for some `a, b` in `α`) as `x` varies in a filter `x`, then the distance between `f(x)` and `g(x)` also tends to the distance between `a` and `b`. In other words, as we get closer to `x` in the filter, the distance between the images of `x` under `f` and `g` approaches the distance between `a` and `b`. This theorem relates the notion of convergence in pseudometric spaces with the notion of convergence in filters.

Given functions `f` and `g` from a filter `x` on type `β` to a pseudometric space `α`, if `f x` converges to `a` and `g x` converges to `b`, then `distance(a, b) ≤ limit-inf (distance(f x, g x))`.


theorem Set.subset_pi_eval_image :
    ∀ {ι : Type u_1} {α : ι → Type u_2} (s : Set ι) (u : Set ((i : ι) → α i)),
      u ⊆ Set.pi s fun i => Function.eval i '' u :=
  by sorry

The theorem `Set.subset_pi_eval_image` states that for any set `s` of indices `ι`, and any set `u` of dependent functions from `ι` to some types `α i`, the set `u` is a subset of the set of dependent functions `f : Πa, π a` such that for each index `i` in `s`, `f i` belongs to the image of the function `Function.eval i` applied to `u`. In other words, for each function in `u`, each of its evaluations at indices in `s` is still in the image of `u` under the evaluation at that index.

For any set `s` of indices `ι` and dependent functions `u : Πi, α i`, `u` is a subset of the set of functions `f : Πa, π a` such that for all `i` in `s`, `f i` is in the image of `Function.eval i` applied to `u`.


/-- The diameter of a singleton vanishes  -/
theorem EMetric.diam_singleton : ∀ {α : Type u} [inst : PseudoEMetricSpace α] {x : α}, EMetric.diam {x} = 0 := by sorry

The theorem `EMetric.diam_singleton` states that in any pseudoemetric space, the diameter of a singleton set (a set containing only one element) always equals zero. In other words, for any type `α` and element `x` of `α`, when `α` is considered as a pseudoemetric space, the diameter of the set containing only `x` is zero.

In any pseudometric space, the diameter of a singleton set is 0.


theorem AlgebraicTopology.DoldKan.P_f_idem :
    ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
      {X : CategoryTheory.SimplicialObject C} (q n : ℕ),
      CategoryTheory.CategoryStruct.comp ((AlgebraicTopology.DoldKan.P q).f n) ((AlgebraicTopology.DoldKan.P q).f n) =
        (AlgebraicTopology.DoldKan.P q).f n :=
  by sorry

This theorem, named `AlgebraicTopology.DoldKan.P_f_idem`, states that for any category `C` of type `u_1` that also satisfies the `CategoryTheory.Category` and `CategoryTheory.Preadditive` conditions, and any simplicial object `X` in `C`, for any natural numbers `q` and `n`, the composition of the `n`-th morphism of the `q`-th Dold-Kan correspondence with itself is equal to the `n`-th morphism of the `q`-th Dold-Kan correspondence itself. In other words, the operation `f n` in the `q`-th Dold-Kan correspondence is idempotent when composed with itself.

For any simplicial object X in a preadditive category C, the `n`-th morphism of the `q`-th Dold-Kan correspondence with itself is equal to the `n`-th morphism of the `q`-th Dold-Kan correspondence in C. (i.e., the `f n` operation is idempotent in the `q`-th Dold-Kan correspondence.)


theorem Polynomial.natTrailingDegree_le_of_ne_zero :
    ∀ {R : Type u} {n : ℕ} [inst : Semiring R] {p : Polynomial R},
      Polynomial.coeff p n ≠ 0 → Polynomial.natTrailingDegree p ≤ n :=
  by sorry

The theorem `Polynomial.natTrailingDegree_le_of_ne_zero` asserts that for any type `R` which forms a semiring, any natural number `n`, and any polynomial `p` over `R`, if the coefficient of `X^n` in `p` is non-zero, then the natural trailing degree of `p` is less than or equal to `n`. The natural trailing degree of a polynomial is defined as the lowest degree of the polynomial's non-zero terms, with a default value of 0 if there is no such term (i.e., in the case of the zero polynomial). Thus, this theorem essentially states that the natural trailing degree of a non-zero polynomial is at most the degree of any term with a non-zero coefficient.

For any semiring `R`, natural number `n`, and polynomial `p` over `R` with a non-zero coefficient for `X^n`, the natural trailing degree of `p` is less than or equal to `n`.


theorem Mathlib.Analysis.Calculus.ContDiff.Basic._auxLemma.8 :
    ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {E : Type uE} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {F : Type uF} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {f : E → F}
      {n : ℕ∞}, ContDiff 𝕜 n f = ContDiffOn 𝕜 n f Set.univ :=
  by sorry

This theorem states that for any type `𝕜` which forms a nontrivially normed field, types `E` and `F` which both form normed additive commutative groups and normed spaces over `𝕜`, a function `f` from `E` to `F`, and a natural number or infinity `n`, the function `f` is continuously differentiable to degree `n` across the entire space if and only if it is continuously differentiable to degree `n` on the universal set `Set.univ` of `E` (which includes all elements of `E`). In other words, the function `f` is continuously differentiable everywhere.

For any normed field `𝕜`, normed additive commutative groups and normed spaces `E` and `F` over `𝕜`, and a continuously differentiable function `f` from `E` to `F` of degree `n`, `f` is continuously differentiable to degree `n` everywhere if and only if it is continuously differentiable to degree `n` on the universal set of `E`.


theorem Mathlib.Analysis.Calculus.ContDiff.Basic._auxLemma.1 :
    ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {E : Type uE} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {F : Type uF} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {f : E → F}
      {n : ℕ}, iteratedFDeriv 𝕜 n f = iteratedFDerivWithin 𝕜 n f Set.univ :=
  by sorry

This theorem states that for any nontrivially normed field `𝕜`, any normed additive commutative group `E` and `F` which are also normed spaces over `𝕜`, any function `f` from `E` to `F`, and any natural number `n`, the `n`-th iterated Fréchet derivative of `f` over the entire domain `E` (as represented by `Set.univ`) is equal to the `n`-th iterated Fréchet derivative of `f` within the universal set. In other words, taking the Fréchet derivative over the whole space or within the universal set gives the same result.

For any nontrivially normed field `𝕜`, any normed additive commutative groups `E` and `F` over `𝕜`, and any continuous function `f` from `E` to `F`, the `n`-th iterated Frechet derivative of `f` over the entire domain `E` equals its `n`-th iterated Frechet derivative within the universal set `Set.univ`.


theorem Fintype.card_le_one_iff : ∀ {α : Type u_1} [inst : Fintype α], Fintype.card α ≤ 1 ↔ ∀ (a b : α), a = b := by
  sorry

The theorem `Fintype.card_le_one_iff` states that for any type `α` that is a finite type (fintype), the cardinality of `α`, i.e., the number of elements in `α`, is less than or equal to one if and only if all elements `a` and `b` in `α` are equal. In other words, a finite type has at most one distinct element if and only if any two elements in the type are the same.

A finite type `α` has at most one element if and only if all its elements are equal. (Equivalently, the cardinality of a finite type `α` is less than or equal to one if and only if `α` is a singleton.)


theorem Nat.le_mul_of_pos_left : ∀ {n : ℕ} (m : ℕ), 0 < n → m ≤ n * m := by sorry

This theorem states that for any natural numbers `n` and `m`, if `n` is greater than 0, then `m` is less than or equal to the product of `n` and `m`. Essentially, this means that for any non-zero natural number `n`, multiplying it with another natural number `m` (which could be zero) can never result in a value smaller than `m`.

For all natural numbers n and m, if n > 0 then m <= n * m.


theorem Fin.val_lt_last : ∀ {n : ℕ} {i : Fin (n + 1)}, i ≠ Fin.last n → ↑i < n := by sorry

This theorem states that for any natural number `n` and any value `i` from the finite set `Fin (n + 1)`, if `i` is not equal to the greatest value of `Fin (n+1)`, represented by `Fin.last n`, then the actual numerical value of `i` (obtained by using the coersion function `↑i`) is strictly less than `n`.

For any natural number `n` and `i` in `Fin (n + 1)`, if `i` is not the last element of `Fin (n+1)`, then `↑i` is strictly less than `n`.


theorem Polynomial.card_roots' :
    ∀ {R : Type u} [inst : CommRing R] [inst_1 : IsDomain R] (p : Polynomial R),
      Multiset.card (Polynomial.roots p) ≤ Polynomial.natDegree p :=
  by sorry

The theorem `Polynomial.card_roots'` states that for any polynomial `p` over a type `R` that is a commutative ring and an integral domain, the cardinality (or number of elements considering their multiplicities) of the multiset of roots of `p` is less than or equal to the natural degree of `p`. The natural degree of a polynomial is the degree of the polynomial treated as a natural number, with the degree of the zero polynomial defined as 0.

The number of roots (counting multiplicities) of a polynomial over a commutative ring and integral domain does not exceed its degree.


theorem Filter.hasBasis_coclosedCompact :
    ∀ {X : Type u} [inst : TopologicalSpace X],
      Filter.HasBasis (Filter.coclosedCompact X) (fun s => IsClosed s ∧ IsCompact s) compl :=
  by sorry

This theorem states that for any type `X` with a topological space structure, the filter `Filter.coclosedCompact X` has a basis. The basis consists of the complements of sets that satisfy two conditions: the set is closed and the set is compact. In other words, given any element in the `Filter.coclosedCompact X`, we can find a closed and compact set whose complement is contained in the original element. This is important as it provides a way to understand and manipulate elements of the `Filter.coclosedCompact` in terms of more easily-understood closed and compact sets.

The filter of coclosed and compact sets in a topological space has a basis consisting of closed and compact sets.


LipschitzWith.locallyLipschitz

/-- A Lipschitz function is locally Lipschitz.  -/
theorem LipschitzWith.locallyLipschitz :
    ∀ {α : Type u} {β : Type v} [inst : PseudoEMetricSpace α] [inst_1 : PseudoEMetricSpace β] {f : α → β} {K : NNReal},
      LipschitzWith K f → LocallyLipschitz f :=
  by sorry

This theorem states that a Lipschitz continuous function is also locally Lipschitz continuous. In more detail, it says that for any pseudometric spaces `α` and `β`, and any function `f` from `α` to `β`, if `f` is Lipschitz continuous with some nonnegative real constant `K` (i.e., the distance between `f(x)` and `f(y)` is less than or equal to `K` times the distance between `x` and `y` for all `x` and `y`), then `f` is also locally Lipschitz continuous. Being locally Lipschitz continuous means that for every point `x` in the domain, there exists a neighborhood around `x` such that within this neighborhood, `f` is Lipschitz continuous with some constant.

A Lipschitz continuous function is locally Lipschitz continuous.


theorem add_self_eq_zero :
    ∀ {R : Type u_1} [inst : NonAssocSemiring R] [inst_1 : NoZeroDivisors R] [inst_2 : CharZero R] {a : R},
      a + a = 0 ↔ a = 0 :=
  by sorry

This theorem states that for any type `R` that is a non-associative semiring, with no zero divisors and of characteristic zero, an element `a` of `R` will satisfy the equation `a + a = 0` if and only if `a` is zero. In other words, within such a structure, the only element that, when added to itself, results in zero is the zero element itself.

In a non-associative semiring of characteristic zero with no zero divisors, an element is zero if and only if it satisfies the equation `a + a = 0`.


theorem SetTheory.PGame.grundyValue_eq_iff_equiv_nim :
    ∀ {G : SetTheory.PGame} [inst : SetTheory.PGame.Impartial G] {o : Ordinal.{u_1}},
      SetTheory.PGame.grundyValue G = o ↔ G ≈ SetTheory.PGame.nim o :=
  by sorry

This theorem in set theory, specifically in the study of combinatorial games, states that for any impartial game `G` (a game where the allowable moves depend only on the position and not on which of the two players is currently moving), the Grundy value of `G` is equal to an ordinal `o` if and only if `G` is equivalent to a game of nim with `o` stones. Here equivalence means that the two games have the same outcome under optimal play. Nim is a particular type of game where players alternately take one or more stones from a single pile, with the player taking the last stone winning. The Grundy value of an impartial game is a kind of "nim-value" which measures how the game behaves under the mex (minimum excludant) operation.

For any impartial game G in set theory, its Grundy value equals an ordinal o if and only if G is equivalent to a game of Nim with o stones under optimal play.