theorem associated_mul_unit_left : ∀ {β : Type u_5} [inst : Monoid β] (a u : β), IsUnit u → Associated (a * u) a := by
  sorry

The theorem `associated_mul_unit_left` states that for any type `β` that forms a Monoid, for any elements `a` and `u` of that Monoid, if `u` is a unit (meaning it has a two-sided inverse), then `a * u` and `a` are associated. In the context of a Monoid, two elements are said to be associated if one of them can be obtained by multiplying the other one with a unit on the right.

For any Monoid `β` and elements `a` and `u` in `β` with `u` being a unit, `a * u` is associated with `a`, i.e., there exists a unit `v` such that `a * u = a * (u * v)`.


/-- The gauge evaluated at `0` is always zero (mathematically this requires `0` to be in the set `s`
but, the real infimum of the empty set in Lean being defined as `0`, it holds unconditionally).  -/
theorem gauge_zero : ∀ {E : Type u_2} [inst : AddCommGroup E] [inst_1 : Module ℝ E] {s : Set E}, gauge s 0 = 0 := by
  sorry

This theorem states that the Minkowski functional, or "gauge", evaluated at the zero vector is always zero. This is generally true in mathematics when the zero vector is included in the set `s`. However, in Lean, the theorem holds unconditionally due to the definition of the infimum over an empty set being set to `0`. Therefore, no matter the set `s` in the real vector space `E`, the gauge of `s` at `0` equals `0`.

The Minkowski functional of any set in a real vector space evaluates to 0 at the zero vector.


theorem List.append_cancel_left_eq : ∀ {α : Type u_1} (as bs cs : List α), (as ++ bs = as ++ cs) = (bs = cs) := by sorry

This theorem states that for any type `α` and any three lists `as`, `bs`, and `cs` of that type, appending `as` to `bs` results in the same list as appending `as` to `cs` if and only if `bs` is equal to `cs`. In other words, if the concatenation of `as` and `bs` is the same as the concatenation of `as` and `cs`, it implies that the lists `bs` and `cs` must be the same. The theorem is essentially asserting the cancellation law for list concatenation.

For any type `α` and lists `as : list α`, `bs`, `cs : list α`, if `as ++ bs` = `as ++ cs`, then `bs` = `cs`. (Here, `++` denotes list concatenation in Lean.)


theorem Nat.Linear.Poly.denote_fuse :
    ∀ (ctx : Nat.Linear.Context) (p : Nat.Linear.Poly),
      Nat.Linear.Poly.denote ctx (Nat.Linear.Poly.fuse p) = Nat.Linear.Poly.denote ctx p :=
  by sorry

The theorem `Nat.Linear.Poly.denote_fuse` states that for all natural number linear contexts (`ctx`) and all natural number linear polynomials (`p`), the value of the fused polynomial (`Nat.Linear.Poly.fuse p`) evaluated in the context `ctx` (`Nat.Linear.Poly.denote ctx`) is equal to the value of the original polynomial `p` evaluated in the same context. In other words, fusing a polynomial does not change its value in any given context.

For all natural number linear contexts `ctx` and polynomials `p`, `Nat.Linear.Poly.denote ctx (Nat.Linear.Poly.fuse p) = Nat.Linear.Poly.denote ctx p`.


theorem Polynomial.natDegree_mem_support_of_nonzero :
    ∀ {R : Type u} [inst : Semiring R] {p : Polynomial R}, p ≠ 0 → Polynomial.natDegree p ∈ Polynomial.support p := by
  sorry

The theorem `Polynomial.natDegree_mem_support_of_nonzero` states that for any type `R` with a `Semiring` structure and any non-zero polynomial `p` of type `Polynomial R`, the natural degree of `p` (represented as `Polynomial.natDegree p`) is in the support of `p` (denoted as `Polynomial.support p`). Here, the support of a polynomial is the set of all exponents such that the corresponding coefficient of the term with that exponent in the polynomial is non-zero.

For any non-zero polynomial p of type R in Lean's Polynomial.ynomial structure, the natural degree of p is an element in the support of p.


theorem CategoryTheory.Functor.IsCoverDense.isContinuous :
    ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_5, u_1} C] {D : Type u_2}
      [inst_1 : CategoryTheory.Category.{u_6, u_2} D] (J : CategoryTheory.GrothendieckTopology C)
      (K : CategoryTheory.GrothendieckTopology D) (G : CategoryTheory.Functor C D)
      [inst_2 : CategoryTheory.Functor.IsCoverDense G K] [inst_3 : CategoryTheory.Full G]
      [inst_4 : CategoryTheory.Faithful G],
      CategoryTheory.CoverPreserving J K G → CategoryTheory.Functor.IsContinuous G J K :=
  by sorry

This theorem states that for any two types `C` and `D` that have category structures and any Grothendieck topologies `J` and `K` on `C` and `D` respectively, if a functor `G` from `C` to `D` is cover-dense with respect to topology `K`, full, and faithful, then if `G` is also cover-preserving with respect to topologies `J` and `K`, it is continuous with respect to `J` and `K`. In other words, if a functor preserves coverings and is cover-dense, full, and faithful, it ensures the continuity of the functor under the given Grothendieck topologies.

Given functors G from type C to D with category structures, if G is cover-preserving, cover-dense, full, and faithful between the Grothendieck topologies J on C and K on D, then G is continuous with respect to J and K.


theorem continuous_abs :
    ∀ {G : Type u_2} [inst : TopologicalSpace G] [inst_1 : LinearOrderedAddCommGroup G] [inst_2 : OrderTopology G],
      Continuous abs :=
  by sorry

The theorem `continuous_abs` states that for any type `G` which is a topological space, a linearly ordered additive commutative group, and has an order topology, the function `abs` is continuous. In mathematical terms, this is expressing the fact that the absolute value function is continuous over any linearly ordered additive commutative group that is furnished with an order topology.

The absolute value function is continuous on any linearly ordered additive commutative group endowed with an order topology.


theorem Cardinal.aleph0_le_lift :
    ∀ {c : Cardinal.{u}}, Cardinal.aleph0 ≤ Cardinal.lift.{v, u} c ↔ Cardinal.aleph0 ≤ c := by sorry

The theorem `Cardinal.aleph0_le_lift` states that for any cardinal number `c`, the smallest infinite cardinal, also known as aleph null (`Cardinal.aleph0`), is less than or equal to the universe lifter function (`Cardinal.lift`) applied to `c`, if and only if aleph null is less than or equal to `c` itself. In other words, the inequality between aleph null and `c` is preserved under the universe lifting operation.

For any cardinal number `c`, `Cardinal.aleph0 ≤Cardinal.lift c` if and only if `Cardinal.aleph0 ≤ c`.


theorem Turing.mem_eval :
    ∀ {σ : Type u_1} {f : σ → Option σ} {a b : σ}, b ∈ Turing.eval f a ↔ Turing.Reaches f a b ∧ f b = none := by sorry

This theorem states that for any type `σ` and a state transition function `f : σ → Option σ`, and for any elements `a` and `b` of type `σ`, `b` is in the "completion" of the evaluation of `f` starting from `a` if and only if there is a finite sequence of steps starting from `a` and ending at `b` (possibly with no steps, i.e., `a` equals `b`) such that each step is a valid transition under `f`, and at the end state `b`, the function `f` does not produce a new state (i.e., `f b = none`). This theorem is essentially characterizing the completion of state transitions as sequences of steps that eventually reach a state from which there is no next state under the transition function.

A state `b` is in the completion of the evaluation of the state transition function `f` starting from state `a` if and only if there exists a finite sequence of valid transitions from `a` to `b` such that `f` does not produce a new state at `b`.


theorem PartialEquiv.trans_source :
    ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} (e : PartialEquiv α β) (e' : PartialEquiv β γ),
      (PartialEquiv.trans e e').source = e.source ∩ ↑e ⁻¹' e'.source :=
  by sorry

The theorem `PartialEquiv.trans_source` states that for any three types `α`, `β`, and `γ`, and any two partial equivalences `e` from `α` to `β` and `e'` from `β` to `γ`, the source of the composite partial equivalence `PartialEquiv.trans e e'` is equal to the intersection of the source of `e` and the preimage of the source of `e'` under `e`. This means that the domain of the composed partial equivalence is the set of all elements in the domain of `e` for which the image under `e` also lies in the domain of `e'`.

The source of the composite partial equivalence `PartialEquiv.trans e e'` is equal to the intersection of the source of `e` and the preimage of the source of `e'` under `e`. In other words, the domain of `PartialEquiv.trans e e'` is the subset of the domain of `e` where the image of `e` lies in the domain of `e'`.


theorem Mathlib.Data.Fintype.Basic._auxLemma.4 :
    ∀ {α : Type u_1} [inst : Fintype α] (s : Finset α), (s ⊆ Finset.univ) = True := by sorry

This theorem states that for any type `α` with a finite set of instances (expressed by the typeclass `Fintype α`), any finset `s` of this type is a subset of the universal finite set of the type `α` (denoted by `Finset.univ`). Here, `Finset.univ` is the set that contains all elements of the given type `α`. In other words, every element in the finset `s` is also an element of the universal set of `α`. This is always true for all finite types and finsets of those types.

For any finite type `α` and any finset `s` of type `α`, `s` is a subset of the universal finite set `Finset.univ` of type `α`.


theorem Associated.dvd_iff_dvd_right :
    ∀ {α : Type u_1} [inst : Monoid α] {a b c : α}, Associated b c → (a ∣ b ↔ a ∣ c) := by sorry

This theorem states that, for any three elements `a`, `b`, and `c` in a `Monoid` structure, if `b` and `c` are `Associated` (meaning there exists a unit element such that `b` multiplied by this unit is `c`), then `a` divides `b` if and only if `a` divides `c`. In other words, the `Associated` relationship between `b` and `c` preserves the divisibility relationship with `a`. Here, division is defined in terms of the monoid operation.

For any element `a` and associative elements `b` and `c` in a monoid, `a` divides `b` if and only if `a` divides `c` if and only if `b` is associated with `c` via some unit element.


theorem Real.nnnorm_of_nonneg : ∀ {r : ℝ} (hr : 0 ≤ r), ‖r‖₊ = { val := r, property := hr } := by sorry

This theorem states that for every real number `r` that is non-negative (i.e., greater than or equal to zero), the non-negative norm of `r` (denoted as ‖r‖₊) is equal to the non-negative real number that has `r` as its value and the property that `r` is non-negative. This means that the non-negative norm of a non-negative real number is simply the number itself, wrapped in a structure that explicitly confirms its non-negativity.

For every non-negative real number `r`, the non-negative norm `‖r‖₊` equals `r`.


Filter.HasBasis.lift'

theorem Filter.HasBasis.lift' :
    ∀ {α : Type u_1} {β : Type u_2} {f : Filter α} {h : Set α → Set β} {ι : Sort u_5} {p : ι → Prop} {s : ι → Set α},
      Filter.HasBasis f p s → Monotone h → Filter.HasBasis (Filter.lift' f h) p (h ∘ s) :=
  by sorry

The theorem `Filter.HasBasis.lift'` states that for any types `α` and `β`, any filter `f` on `α`, any function `h` that maps sets of `α` to sets of `β`, any index type `ι`, any basis predicate `p` on `ι`, and any basis function `s` from `ι` to the sets of `α`, if `f` has a basis determined by the predicate `p` and the function `s`, and if the function `h` is monotone, then the filter obtained by lifting `f` along `h` using the function `Filter.lift'` also has a basis determined by the same predicate `p` and the function `h` composed with `s`. In other words, if we have a basis for a filter and a monotone function, we can "lift" the filter along this function and still have a basis, where the basis function is the composition of the original basis function and the monotone function.

If a filter on type `α` has a basis determined by predicate `p` and function `s`, and `h` is a monotone function from sets of `α` to sets of `β`, then the filter obtained by lifting along `h` using `Filter.lift'` also has a basis determined by `p` and the composition of `h` and `s`.


theorem TopologicalSpace.IsSeparable.of_separableSpace :
    ∀ {α : Type u} [t : TopologicalSpace α] [h : TopologicalSpace.SeparableSpace α] (s : Set α),
      TopologicalSpace.IsSeparable s :=
  by sorry

This theorem states that for any type `α` and a set `s` of this type, if `α` is equipped with a topology `t` and is a separable space (as denoted by `TopologicalSpace.SeparableSpace α`), then the set `s` is a separable set in the given topological space. In terms of topology, a separable space means that there exists a countable, dense subset within it. This result guarantees that any subset of such a space is also separable, i.e., it is contained within the closure of some countable set.

In a separable topological space, every subset is separable.


theorem Equiv.Perm.not_mem_support :
    ∀ {α : Type u_1} [inst : DecidableEq α] [inst_1 : Fintype α] {f : Equiv.Perm α} {x : α},
      x ∉ Equiv.Perm.support f ↔ f x = x :=
  by sorry

This theorem states that for any type `α` with decidable equality and finiteness, and any permutation `f` of this type and any element `x` of this type, `x` is not in the support of `f` if and only if `f` of `x` equals `x`. In other words, an element of a set is not in the set of nonfixed points of a permutation if and only if it is left unchanged by the permutation. This support set is determined by the function `f`, where the set consists of elements that do not remain the same after the function `f` is applied.

For any permutation `f` on a type `α` with decidable equality and finite support, an element `x` of `α` is not in the support of `f` if and only if `f(x) = x`.


theorem Function.Injective.tsum_eq :
    ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : AddCommMonoid α] [inst_1 : TopologicalSpace α] {g : γ → β},
      Function.Injective g → ∀ {f : β → α}, Function.support f ⊆ Set.range g → ∑' (c : γ), f (g c) = ∑' (b : β), f b :=
  by sorry

This theorem, `Function.Injective.tsum_eq`, states that given types `α`, `β`, and `γ`, with `α` being an additive commutative monoid and also a topological space, an injective function `g` from `γ` to `β`, and another function `f` from `β` to `α`, if the support of function `f` (the set of points where `f` is not zero) is a subset of the range of function `g` (the set of all possible outputs of `g`), then the sum over `γ` of `f` applied to `g` is equal to the sum over `β` of `f`. In mathematical terms, it states that if $f: \beta \rightarrow \alpha$, $g: \gamma \rightarrow \beta$ is injective and the support of $f$ is contained in the range of $g$, then $\sum_{c \in \gamma} f(g(c)) = \sum_{b \in \beta} f(b)$.

If `α` is an additive commutative monoid and topological space, `γ` is a type, `β` is a type, `α ⊑ β`, `g: γ → β` is injective, and the support of `f: β → α` is contained in the range of `g`, then $\sum_{c ∈ γ} f(g(c)) = \sum_{b ∈ β} f(b)$.


/-- If the angle between two vectors is nonzero, the first vector is nonzero.  -/
theorem Orientation.left_ne_zero_of_oangle_ne_zero :
    ∀ {V : Type u_1} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V]
      [inst_2 : Fact (FiniteDimensional.finrank ℝ V = 2)] (o : Orientation ℝ V (Fin 2)) {x y : V},
      Orientation.oangle o x y ≠ 0 → x ≠ 0 :=
  by sorry

The theorem `Orientation.left_ne_zero_of_oangle_ne_zero` states that for a 2-dimensional real inner product space, if the oriented angle between two vectors is not zero, then the first vector must be non-zero. This is equivalent to saying that if a vector forms a non-zero angle with another vector, then it cannot be the zero vector.

If the oriented angle between two vectors in a 2-dimensional real inner product space is non-zero, then each vector is non-zero.


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

This theorem states that for any type `α` that has decidable equality, and for any elements `a` and `b` of type `α` and a multiset `s` of type `α`, `a` is in the multiset obtained by non-duplicate insertion of `b` into `s` if and only if `a` is equal to `b` or `a` is in `s`. In other words, an element `a` is in the multiset after the non-duplicate insertion of an element `b` if `a` is either the element inserted or was already in the multiset before the insertion.

For any type `α` with decidable equality, and any multiset `s` of type `α` and elements `a, b` of type `α`, `a` is in the multiset `(s : set α) ++ {b}` if and only if `a = b` or `a` is in `s`.


theorem Primrec.nat_add : Primrec₂ fun x x_1 => x + x_1 := by sorry

The theorem `Primrec.nat_add` states that the function of two natural numbers that adds them together is a binary primitive recursive function. In other words, the addition operation for natural numbers can be computed using a sequence of basic arithmetic operations and control structures, such as loops or recursion, that halt after a finite number of steps.

The `Primrec.nat_add` theorem asserts that the addition function on natural numbers is a primitive recursive function.


theorem SubmonoidClass.coe_pow :
    ∀ {M : Type u_6} [inst : Monoid M] {A : Type u_5} [inst_1 : SetLike A M] [inst_2 : SubmonoidClass A M] {S : A}
      (x : ↥S) (n : ℕ), ↑(x ^ n) = ↑x ^ n :=
  by sorry

This theorem, `SubmonoidClass.coe_pow`, states that for any type `M` with a monoid structure, any type `A` that behaves like a set of `M` with a submonoid class, any specific submonoid `S` of `A`, and any element `x` from `S`, the operation of raising `x` to the power of a natural number `n` (denoted `x ^ n`), and then taking the coercion of the result to `M` (denoted `↑(x ^ n)`), is equal to first taking the coercion of `x` to `M` and then raising the result to the power of `n` (denoted `↑x ^ n`). This essentially states the compatibility of the power operation with the coercion from the submonoid to the monoid.

For any monoid `M`, submonoid `S` of a type `A` with the submonoid structure, and `x` in `S`, the coercion of `x^n` to `M` equals the coercion of `x` to `M` raised to the power of `n`.


/-- If `α` is an infinite type, then `α × α` and `α` have the same cardinality.  -/
theorem Cardinal.mul_eq_self : ∀ {c : Cardinal.{u_1}}, Cardinal.aleph0 ≤ c → c * c = c := by sorry

This theorem states that if `α` is an infinite type represented by the cardinal number `c`, then the cardinality of the Cartesian product of `α` with itself (i.e., `α × α`) is the same as the cardinality of `α` itself. More formally, for any cardinal `c` such that `c` is greater than or equal to `ℵ₀` (the smallest infinite cardinal, often associated with the cardinality of the set of natural numbers), the cardinality of `c * c` (the Cartesian product of the set associated with `c` with itself) is equal to `c`.

For any infinite cardinal `c` greater than or equal to `ℵ₀`, the cardinality of `c × c` equals `c`.


theorem CategoryTheory.MorphismProperty.map_subset_iff :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {D : Type u_1}
      [inst_1 : CategoryTheory.Category.{u_2, u_1} D] (P : CategoryTheory.MorphismProperty C)
      (F : CategoryTheory.Functor C D) (Q : CategoryTheory.MorphismProperty D),
      CategoryTheory.MorphismProperty.RespectsIso Q →
        (CategoryTheory.MorphismProperty.map P F ⊆ Q ↔ ∀ (X Y : C) (f : X ⟶ Y), P f → Q (F.map f)) :=
  by sorry

The theorem `CategoryTheory.MorphismProperty.map_subset_iff` states that for any categories `C` and `D`, a morphism property `P` on `C`, a functor `F` from `C` to `D`, and a morphism property `Q` on `D` that respects isomorphisms, the image of `P` under `F` is a subset of `Q` if and only if for all objects `X` and `Y` in `C` and any morphism `f` from `X` to `Y`, if `P` holds on `f`, then `Q` holds on the image of `f` under `F`. In other words, it provides a characterization of when a functor preserves a morphism property in terms of subset inclusion.

For any categories C and D, functor F, morphism properties P on C and Q on D respecting isomorphisms, the image of P under F is a subset of Q if and only if P holds along F's image of morphisms.


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

This theorem states that for all sorts or types `α`, `β`, and `γ`, and given an equivalence `e` between `α` and `β`, and functions `f` from `γ` to `α` and `g` from `γ` to `β`, `f` being equal to the composition of the inverse of `e` and `g` is equivalent to the composition of `e` and `f` being equal to `g`. In simpler terms, it expresses a property of function composition concerning inverse functions under the condition of type equivalence.

For all types `α`, `β`, `γ`, functions `f : γ → α`, `g : γ → β`, and equivalence `e : α ≃ β`, `f = g ?. e ∘ f` if and only if `e ∘ f = g`.


theorem MeasureTheory.inducedOuterMeasure_eq' :
    ∀ {α : Type u_1} {P : Set α → Prop} {m : (s : Set α) → P s → ENNReal} {P0 : P ∅} {m0 : m ∅ P0 = 0}
      (PU : ∀ ⦃f : ℕ → Set α⦄, (∀ (i : ℕ), P (f i)) → P (⋃ i, f i)),
      (∀ ⦃f : ℕ → Set α⦄ (hm : ∀ (i : ℕ), P (f i)), m (⋃ i, f i) ⋯ ≤ ∑' (i : ℕ), m (f i) ⋯) →
        (∀ ⦃s₁ s₂ : Set α⦄ (hs₁ : P s₁) (hs₂ : P s₂), s₁ ⊆ s₂ → m s₁ hs₁ ≤ m s₂ hs₂) →
          ∀ {s : Set α} (hs : P s), ↑(MeasureTheory.inducedOuterMeasure m P0 m0) s = m s hs :=
  by sorry

This theorem is about the equality of an induced outer measure and a given measure function on a particular set. Given a type `α`, a property `P` on sets of `α`, and a measure `m` from the properties of sets to extended nonnegative real numbers (`ENNReal`), that assigns `0` to the empty set, if the following conditions hold:
1. The property `P` is preserved under taking countable unions, i.e., if `P` holds for each set in a sequence of sets, then `P` holds for the union of these sets.
2. The measure of a countable union of sets is at most the sum of the measures of the sets.
3. For any two sets where the first set is a subset of the second and `P` holds for both sets, the measure of the first set is less than or equal to the measure of the second set.

Then, for any set `s` satisfying the property `P`, the induced outer measure of `s` equals the measure `m` of `s`.

If `P` is a countably additive property on sets such that `m(∅) = 0` and `m` is monotonic on `P` sets, then for any `P` set `s`, the induced outer measure of `s` equals `m(s)`.


theorem MeasureTheory.FiniteMeasure.mass_zero_iff :
    ∀ {Ω : Type u_1} [inst : MeasurableSpace Ω] (μ : MeasureTheory.FiniteMeasure Ω),
      MeasureTheory.FiniteMeasure.mass μ = 0 ↔ μ = 0 :=
  by sorry

This theorem states that for any type `Ω` with a measurable space structure and for any finite measure `μ` on `Ω`, the total mass of `μ` is zero if and only if `μ` is the zero measure. In mathematical terms, the total mass of a measure is the measure of the entire space, written as `μ(univ)`. So, this theorem is expressing the idea that a finite measure is the zero measure if and only if the measure of the entire space is zero.

A finite measure `μ` on a measurable space `(Ω, Σ)` is the zero measure if and only if `μ(Ω) = 0`.


theorem multiplicity.finite_int_iff : ∀ {a b : ℤ}, multiplicity.Finite a b ↔ Int.natAbs a ≠ 1 ∧ b ≠ 0 := by sorry

This theorem states that for any two integers `a` and `b`, the multiplicity of `a` in `b` is finite if and only if the absolute value of `a` is not equal to 1 and `b` is not equal to 0. Here, the multiplicity of `a` in `b` refers to the greatest exponent `n` such that `a` to the power of `n` divides `b`. The absolute value of an integer is its value disregarding its sign.

For integers `a` and `b`, the multiplicity of `a` in `b` is finite if and only if `a ≠ 1` and `b ≠ 0`.


theorem Polynomial.Monic.natDegree_eq_zero_iff_eq_one :
    ∀ {R : Type u} [inst : Semiring R] {p : Polynomial R}, Polynomial.Monic p → (Polynomial.natDegree p = 0 ↔ p = 1) :=
  by sorry

The theorem `Polynomial.Monic.natDegree_eq_zero_iff_eq_one` states that for any type `R` that forms a semiring, and for any monic polynomial `p` of type `R`, the natural degree of `p` is zero if and only if `p` equals one. In other words, a monic polynomial in a semiring has a natural degree of zero precisely when the polynomial itself is equal to one.

For any monic polynomial `p` in a semiring R, the natural degree of `p` is equal to zero if and only if `p` equals the constant polynomial 1.


theorem Finset.mem_sup :
    ∀ {α : Type u_7} {β : Type u_8} [inst : DecidableEq β] {s : Finset α} {f : α → Finset β} {x : β},
      x ∈ Finset.sup s f ↔ ∃ v ∈ s, x ∈ f v :=
  by sorry

This theorem states that for any type `α` and `β` with `β` having decidable equality, given a finite set `s` of type `α`, a function `f` mapping each element of `s` to a finite set of type `β`, and an element `x` of type `β`, the element `x` belongs to the supremum of `s` under the function `f` if and only if there exists an element `v` in `s` such that `x` belongs to the finite set that `f` maps `v` to. In other words, `x` is in the supremum of the image of `s` under `f` precisely when `x` is in the image of some element of `s` under `f`.

For any finite set `s` of type `α` and function `f` from `s` to the finite sets of type `β`, an element `x` of type `β` belongs to the supremum of the image of `s` under `f` if and only if there exists `v` in `s` such that `x` is in the image of `v` under `f`.


theorem Nat.le_log_of_pow_le : ∀ {b x y : ℕ}, 1 < b → b ^ x ≤ y → x ≤ Nat.log b y := by sorry

The theorem `Nat.le_log_of_pow_le` states that for all natural numbers `b`, `x`, and `y`, if `b` is greater than 1 and `b` to the power `x` is less than or equal to `y`, then `x` is less than or equal to the logarithm of `y` in base `b`. In mathematical notation, this can be written as: if $1 < b$ and $b^x \leq y$, then $x \leq \log_b y$. This theorem provides a condition under which the power of a base is less than or equal to a given number, and relates the power to the base logarithm of that number.

If $1 < b$ and $b^x \leq y$, then $x \leq \log_b y$. (The logarithm base $b$ of $y$ is less than or equal to $x$.)


AbstractCompletion.funext

theorem AbstractCompletion.funext :
    ∀ {α : Type u_1} [inst : UniformSpace α] (pkg : AbstractCompletion α) {β : Type u_2} [inst_1 : TopologicalSpace β]
      [inst_2 : T2Space β] {f g : pkg.space → β},
      Continuous f → Continuous g → (∀ (a : α), f (pkg.coe a) = g (pkg.coe a)) → f = g :=
  by sorry

This theorem states that for any type `α` that is a Uniform Space and another type `β` which is a topological space with `T2Space` properties (i.e., a Hausdorff space), and given two continuous functions `f` and `g` from the space of abstract completion of `α` to `β`, if they agree on each point `a` of `α` (i.e., `f (pkg.coe a)` is equal to `g (pkg.coe a)` for all `a` in `α`), then the functions `f` and `g` are identical. This is essentially an extensionality property of functions in the context of topological and uniform spaces.

If `α` is a Uniform Space and `β` is a T2Space, and `f` and `g` are continuous functions from the completion of `α` to `β` that agree on all points in `α`, then `f` and `g` are equal.


theorem HasDerivAt.const_mul :
    ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {x : 𝕜} {𝔸 : Type u_2} [inst_1 : NormedRing 𝔸]
      [inst_2 : NormedAlgebra 𝕜 𝔸] {d : 𝕜 → 𝔸} {d' : 𝔸} (c : 𝔸),
      HasDerivAt d d' x → HasDerivAt (fun y => c * d y) (c * d') x :=
  by sorry

The theorem `HasDerivAt.const_mul` states that for any non-trivially normed field `𝕜`, any point `x` in `𝕜`, a normed ring `𝔸`, a normed algebra `𝕜 𝔸`, a function `d : 𝕜 → 𝔸`, its derivative `d' : 𝔸` at `x`, and a constant `c : 𝔸`, if `d` has the derivative `d'` at the point `x`, then the function `fun y => c * d y`, which is the multiplication of the function `d` by the constant `c`, has the derivative `c * d'` at the point `x`. This theorem essentially captures the rule of constants in differentiation, which states that the derivative of a constant times a function is equal to the constant times the derivative of the function.

If `d : ℝ→ℝ^n` is differentiable at `x ∈ ℝ` and `c ∈ ℝ`, then the function `f : ℝ→ℝ^n` defined by `f(y) := c * d(y)` is differentiable at `x` and has derivative `f'(x) = c * d'(x)`.


theorem norm_sum_le :
    ∀ {ι : Type u_9} {E : Type u_10} [inst : SeminormedAddCommGroup E] (s : Finset ι) (f : ι → E),
      ‖Finset.sum s fun i => f i‖ ≤ Finset.sum s fun i => ‖f i‖ :=
  by sorry

The theorem `norm_sum_le` states that for any finite set `s` of type `ι` and any function `f` from `ι` to a type `E` equipped with a seminorm (i.e., a type `E` that is a seminormed additive commutative group), the norm of the sum of `f(i)` over all `i` in `s` is less than or equal to the sum of the norms of `f(i)` for each `i` in `s`. In simpler terms, it says that the norm of the sum of a sequence of vectors is less than or equal to the sum of the norms of the vectors, a principle often encountered in vector spaces or more generally in seminormed groups.

For any finite set `s` and function `f` from `s` to a seminormed additive commutative group `E`, the norm of the sum of `f(i)` for all `i` in `s` is less than or equal to the sum of the norms of `f(i)` for each `i` in `s`.


theorem Polynomial.mirror_natTrailingDegree :
    ∀ {R : Type u_1} [inst : Semiring R] (p : Polynomial R),
      Polynomial.natTrailingDegree (Polynomial.mirror p) = Polynomial.natTrailingDegree p :=
  by sorry

This theorem states that for any semiring `R` and any polynomial `p` over `R`, the natural trailing degree of the mirror of the polynomial `p` is equal to the natural trailing degree of `p` itself. Here, the mirror of a polynomial is defined as the polynomial obtained by reversing the coefficients of `p` and then multiplying by `X` to the power of the natural trailing degree of `p`. The natural trailing degree of a polynomial is the lowest degree of its non-zero terms, with the convention that the natural trailing degree of the zero polynomial is zero.

For any semiring `R` and polynomial `p` over `R`, the natural trailing degrees of `p` and its mirror are equal.


theorem mul_right_mem_nonZeroDivisors_eq_zero_iff :
    ∀ {M : Type u_2} [inst : MonoidWithZero M] {x r : M}, r ∈ nonZeroDivisors M → (x * r = 0 ↔ x = 0) := by sorry

The theorem `mul_right_mem_nonZeroDivisors_eq_zero_iff` asserts that for any type `M` which has a structure of a `MonoidWithZero`, and for any two elements `x` and `r` of `M`, if `r` is a member of the submonoid of non-zero-divisors of `M`, then the product `x * r` equals zero if and only if `x` equals zero.

In other words, this theorem states that within a monoid with zero, when we multiply any element `x` by a non-zero-divisor `r`, the result will be zero only if `x` itself is zero.

In a monoid with zero, if a non-zero-divisor `r` is multiplied with any element `x`, then their product is zero if and only if `x` is zero.


/-- The hypotheses also imply that `G` is initial, see `initial_of_comp_full_faithful'`.  -/
theorem CategoryTheory.Functor.initial_of_comp_full_faithful :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂}
      [inst_1 : CategoryTheory.Category.{v₂, u₂} D] {E : Type u₃} [inst_2 : CategoryTheory.Category.{v₃, u₃} E]
      (F : CategoryTheory.Functor C D) (G : CategoryTheory.Functor D E) [inst_3 : CategoryTheory.Full G]
      [inst_4 : CategoryTheory.Faithful G] [inst_5 : CategoryTheory.Functor.Initial (CategoryTheory.Functor.comp F G)],
      CategoryTheory.Functor.Initial F :=
  by sorry

This theorem states that in the context of Category Theory, given categories `C`, `D`, and `E`, and functors `F : C -> D` and `G : D -> E`, if `G` is a full and faithful functor and the composition of `F` and `G` is initial, then `F` is also an initial functor. The concept of being an "initial" functor relates to the idea that there exists a unique morphism from the initial object to any other object. Similarly, a full functor is one where for any two objects, the function mapping the hom-sets is surjective, while a faithful functor is one where that function is injective.

If functors `F : C -> D`, `G : D -> E`, and `G` is a full and faithful functor with the composition `F ∘ G` being the initial functor from `E` to `D`, then `F` is the initial functor from `C` to `D`.


/-- Changing coordinates between two elements of the maximal atlas gives rise to an element
of the structure groupoid.  -/
theorem StructureGroupoid.compatible_of_mem_maximalAtlas :
    ∀ {H : Type u} {M : Type u_2} [inst : TopologicalSpace H] [inst_1 : TopologicalSpace M] [inst_2 : ChartedSpace H M]
      {G : StructureGroupoid H} {e e' : PartialHomeomorph M H},
      e ∈ StructureGroupoid.maximalAtlas M G →
        e' ∈ StructureGroupoid.maximalAtlas M G → PartialHomeomorph.trans (PartialHomeomorph.symm e) e' ∈ G :=
  by sorry

This theorem states that for any two elements `e` and `e'` in the maximal atlas of a structure groupoid `G` over a charted space `M`, the transition map from `e` to `e'` (obtained by composing the inverse of `e` and `e'`) is an element of the structure groupoid `G`. Here, `H` and `M` are types equipped with a topological structure, `G` is a structure groupoid on `H`, and `e` and `e'` are partial homeomorphisms from `M` to `H`. This theorem is a fundamental property in the theory of differentiable manifolds, ensuring that changing coordinates between any two charts in the maximal atlas yields a differentiable map.

Given two elements `e` and `e'` in the maximal atlas of a structure groupoid `G` over a charted space `M`, the transition map from `e` to `e'` is an element of `G`.


theorem Pell.yn_succ_succ :
    ∀ {a : ℕ} (a1 : 1 < a) (n : ℕ), Pell.yn a1 (n + 2) + Pell.yn a1 n = 2 * a * Pell.yn a1 (n + 1) := by sorry

The theorem `Pell.yn_succ_succ` states that for any natural number `a` greater than 1, and for any natural number `n`, the sum of the `n+2`-th term and the `n`-th term of the Pell `y` sequence for `a` is equal to twice `a` times the `n+1`-th term of the same sequence. This is a recurrence relation for the Pell `y` sequence.

For any natural number `a` greater than 1 and natural number `n`, the `(n+2)`-th term of the Pell `y` sequence for `a` equals twice `a` times the `(n+1)`-th term.


theorem Isometry.ediam_range :
    ∀ {α : Type u} {β : Type v} [inst : PseudoEMetricSpace α] [inst_1 : PseudoEMetricSpace β] {f : α → β},
      Isometry f → EMetric.diam (Set.range f) = EMetric.diam Set.univ :=
  by sorry

The theorem `Isometry.ediam_range` states that for any two pseudoemetric spaces `α` and `β`, and a function `f` from `α` to `β`, if `f` is an isometry (a map preserving the extended distance between pseudoemetric spaces), then the diameter of the set of all outputs of `f` (`Set.range f`) is equal to the diameter of the universal set on `α` (`Set.univ`). This means that an isometric function preserves the diameter of the space in which it operates.

For any isometry `f` between pseudometric spaces `α` and `β`, the diameter of `Set.range f` equals the diameter of `Set.univ α`.


theorem AddMonoid.exponent_dvd :
    ∀ {G : Type u} [inst : AddMonoid G] {n : ℕ}, AddMonoid.exponent G ∣ n ↔ ∀ (g : G), addOrderOf g ∣ n := by sorry

The theorem `AddMonoid.exponent_dvd` states that for every type `G` which is an additive monoid, and for every natural number `n`, the exponent of the additive monoid `G` divides `n` if and only if the order of each element `g` in the group `G` divides `n`. Here, the order of an element `g` refers to the smallest positive integer `n` such that `n` times `g` equals zero, if such an `n` exists. If `n` doesn't exist (i.e., `g` is of infinite order), the order of `g` is conventionally defined as zero. The exponent of an additive group `G` is the smallest positive integer `n` such that `n` times `g` equals zero for all `g` in `G`, if such an `n` exists; otherwise, the exponent is conventionally defined as zero.

For every additive monoid G and natural number n, the exponent of G divides n if and only if the order of every element in G divides n.


theorem Set.eqOn_empty : ∀ {α : Type u_1} {β : Type u_2} (f₁ f₂ : α → β), Set.EqOn f₁ f₂ ∅ := by sorry

The theorem `Set.eqOn_empty` states that for any two functions `f₁` and `f₂` that map from a type `α` to a type `β`, these two functions are equal on an empty set. In other words, no matter what the functions `f₁` and `f₂` are, they are considered equal on the empty set because there are no elements in the set for which they could potentially differ.

For any functions `f₁ : α → β` and `f₂ : α → β` over types `α` and `β`, `f₁ = f₂` holds on the empty set `∅`.


/-- When `p = ∞`, this lemma does not hold without the additional assumption `Nonempty ι` because
the left-hand side simplifies to `0`, while the right-hand side simplifies to `‖b‖₊`. See
`PiLp.nnnorm_equiv_symm_const'` for a version which exchanges the hypothesis `p ≠ ∞` for
`Nonempty ι`.  -/
theorem PiLp.nnnorm_equiv_symm_const :
    ∀ {p : ENNReal} {ι : Type u_2} [inst : Fact (1 ≤ p)] [inst_1 : Fintype ι] {β : Type u_7}
      [inst_2 : SeminormedAddCommGroup β],
      p ≠ ⊤ →
        ∀ (b : β), ‖(WithLp.equiv p (ι → β)).symm (Function.const ι b)‖₊ = ↑(Fintype.card ι) ^ (1 / p).toReal * ‖b‖₊ :=
  by sorry

This theorem states that for any extended nonnegative real number `p` that is not infinity, any type `ι` that is a finite type, and any type `β` that forms a seminormalized additive commutative group, the nonnegative norm of the inverse function under the canonical equivalence between `WithLp p (ι → β)` and `ι → β` applied to the constant function with value `b`, is equal to the cardinality of `ι` raised to the power of the reciprocal of `p` times the nonnegative norm of `b`. This holds when `p` is greater than or equal to 1. However, when `p` is infinity, this theorem does not hold without the additional assumption that `ι` is nonempty because the left-hand side simplifies to `0`, while the right-hand side simplifies to the nonnegative norm of `b`.

For finite types `ι`, nonnegative real number `p ≥ 1`, and additive commutative semigroup `β`, the nonnegative `Lp` norm of the constant function's inverse under the canonical equivalence between `WithLp p (ι → β)` and `ι → β` equals `|ι|^{1/p} * ∥b∥_β`, where `|ι|` is the cardinality of `ι` and `∥b∥_β` is the nonnegative norm of `b` in `β`.


theorem Bool.cond_eq_ite : ∀ {α : Type u_1} (b : Bool) (t e : α), (bif b then t else e) = if b = true then t else e :=
  by sorry

The theorem `Bool.cond_eq_ite` states that for any type `α`, given a boolean value `b` and two values `t` and `e` of type `α`, the conditional construct `bif b then t else e` is equivalent to the identical construct using an explicit equality check: `if b = true then t else e`. In other words, the `bif` construct and the `if...then...else` construct with an explicit equality to `true` are interchangeable in Lean 4 when dealing with boolean values.

For any type `α` and boolean value `b` and values `t` and `e` of type `α`, `bif b then t else e` is equal to `if b = true then t else e`.


List.Subperm.refl

theorem List.Subperm.refl : ∀ {α : Type u_1} (l : List α), List.Subperm l l := by sorry

The theorem `List.Subperm.refl` states that for any given list `l` of some type `α`, the list `l` is a sublist of a permutation of itself. This is a reflexive property of the `Subperm` relationship, indicating that any list is considered to be a "sub-permutation" of itself. It aligns with the mathematical idea that every set is a subset of itself.

For any list `l` of type `α`, `l` is a sublist of some permutation of itself.


Submodule.IsPrincipal.principal

theorem Submodule.IsPrincipal.principal :
    ∀ {R : Type u_1} {M : Type u_4} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
      (S : Submodule R M) [inst_3 : Submodule.IsPrincipal S], ∃ a, S = Submodule.span R {a} :=
  by sorry

This theorem, named `Submodule.IsPrincipal.principal`, states that for any semiring `R`, any additive commutative monoid `M`, and any module `M` over `R`, if `S` is a principal submodule of this module (i.e., `S` is generated by a single element), then there exists an element `a` such that `S` is equal to the span of the singleton set containing `a`. In other words, every principal submodule of a module is the span of some single element.

Every principal submodule of a module over a semiring is generated by a single element.


theorem normal_iff :
    ∀ {F : Type u_1} {K : Type u_2} [inst : Field F] [inst_1 : Field K] [inst_2 : Algebra F K],
      Normal F K ↔ ∀ (x : K), IsIntegral F x ∧ Polynomial.Splits (algebraMap F K) (minpoly F x) :=
  by sorry

This theorem, `normal_iff`, defines the equivalence for a field extension `F` to `K` to be normal. According to this theorem, a field extension is normal if and only if for every element `x` in `K`, two conditions are satisfied: `x` is integral over `F` and the minimal polynomial of `x` over `F`, `minpoly F x`, splits into linear factors under the mapping from `F` to `K` given by the algebra structure. An element `x` is said to be integral over `F` if it is a root of some monic polynomial with coefficients in `F`. A polynomial splits if it is zero or all of its irreducible factors are of degree 1.

A field extension is normal if and only if every element in the larger field is integral and the minimal polynomial over the smaller field splits into linear factors.


theorem tendsto_atTop_isLUB :
    ∀ {α : Type u_1} {ι : Type u_3} [inst : Preorder ι] [inst_1 : TopologicalSpace α] [inst_2 : Preorder α]
      [inst_3 : SupConvergenceClass α] {f : ι → α} {a : α},
      Monotone f → IsLUB (Set.range f) a → Filter.Tendsto f Filter.atTop (nhds a) :=
  by sorry

The theorem `tendsto_atTop_isLUB` states that for any types `α` and `ι` with `α` having a topology and a preorder, and `α` also being a sup-convergence class, given a function `f` from `ι` to `α` and an element `a` of `α`, if `f` is a monotone function and `a` is a least upper bound of the range of `f`, then `f` tends to `a` at the limit towards infinity. In simpler terms, this theorem ensures that for a non-decreasing function with a least upper bound, the function will converge to this bound as the input approaches infinity.

If `α` is a sup-convergence class with a topology and preorder, and `f : ι → α` is a monotone function with `a` as its least upper bound, then `f` converges to `a` as `x` approaches infinity in `ι`.


/-- Characterize the boundedness of a set in terms of the finiteness of its emetric.diameter.  -/
theorem Metric.isBounded_iff_ediam_ne_top :
    ∀ {α : Type u} [inst : PseudoMetricSpace α] {s : Set α}, Bornology.IsBounded s ↔ EMetric.diam s ≠ ⊤ := by sorry

The theorem `Metric.isBounded_iff_ediam_ne_top` establishes a characterization of the boundedness of a set within a pseudometric space. Specifically, it states that for any set `s` in a type `α` under a pseudometric space structure, the set `s` is bounded relative to the ambient bornology on `α` if and only if the emetric (pseudoemetric) diameter of the set `s` is not infinity. In other words, a set is considered bounded in this context if and only if it doesn't have an infinite diameter in the pseudoemetric sense.

A set in a pseudometric space is bounded if and only if its pseudometric diameter is finite.


theorem Order.Iic_pred_of_not_isMin :
    ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : PredOrder α] {a : α},
      ¬IsMin a → Set.Iic (Order.pred a) = Set.Iio a :=
  by sorry

The theorem `Order.Iic_pred_of_not_isMin` states that for any type `α` equipped with a preorder and a predecessor order, and for any element `a` of that type which is not a minimal element (meaning there exists some other element that is strictly less than `a`), the left-closed right-infinite interval ending at `a`'s predecessor (`Set.Iic (Order.pred a)`) is equivalent to the left-open right-infinite interval ending at `a` (`Set.Iio a`). In other words, if `a` is not minimal, then all elements less than or equal to `a`'s predecessor are exactly those elements that are strictly less than `a`.

For any preordered type `α` and `a` not minimal in it, `Set.Iic (Order.pred a)` equals `Set.Iio a`.


theorem CategoryTheory.Limits.biprod.inl_map_assoc :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
      {W X Y Z : C} [inst_2 : CategoryTheory.Limits.HasBinaryBiproduct W X]
      [inst_3 : CategoryTheory.Limits.HasBinaryBiproduct Y Z] (f : W ⟶ Y) (g : X ⟶ Z) {Z_1 : C} (h : Y ⊞ Z ⟶ Z_1),
      CategoryTheory.CategoryStruct.comp CategoryTheory.Limits.biprod.inl
          (CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.biprod.map f g) h) =
        CategoryTheory.CategoryStruct.comp f (CategoryTheory.CategoryStruct.comp CategoryTheory.Limits.biprod.inl h) :=
  by sorry

The theorem `CategoryTheory.Limits.biprod.inl_map_assoc` states that in a category `C` with zero morphisms and binary biproducts, for any objects `W`, `X`, `Y`, `Z`, and `Z_1`, and any morphisms `f : W ⟶ Y`, `g : X ⟶ Z`, and `h : Y ⊞ Z ⟶ Z_1`, the composition of the inclusion morphism into the first summand of the binary biproduct and the composition of the map morphism and `h` is equivalent to the composition of `f` and the composition of the inclusion morphism and `h`. This theorem essentially establishes the associativity of these operations in the context of category theory.

In a category with zero morphisms and binary biproducts, the composition of the inclusion morphism into the first summand and the composition of a map morphism and the inclusion morphism into the second summand is equal to the composition of the map morphism, the inclusion morphism into the second summand, and the given morphism.


theorem CategoryTheory.Limits.imageSubobject_zero_arrow :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C}
      [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] [inst_2 : CategoryTheory.Limits.HasZeroObject C],
      CategoryTheory.Subobject.arrow (CategoryTheory.Limits.imageSubobject 0) = 0 :=
  by sorry

The theorem `CategoryTheory.Limits.imageSubobject_zero_arrow` states that in any category `C` with zero morphisms and zero object, the morphism from the underlying object of the image subobject of the zero morphism to the ambient object `Y` is the zero morphism. This theorem illustrates the fact that the image of the zero morphism in a category with zero morphisms and a zero object is essentially trivial.

In a category with zero morphisms and a zero object, the image of the zero morphism under any object's subobject is the zero morphism.


FreeAddGroup.reduce.min

/-- The second theorem that characterises the function `reduce`: the maximal reduction of
a word only reduces to itself. -/
theorem FreeAddGroup.reduce.min :
    ∀ {α : Type u} {L₁ L₂ : List (α × Bool)} [inst : DecidableEq α],
      FreeAddGroup.Red (FreeAddGroup.reduce L₁) L₂ → FreeAddGroup.reduce L₁ = L₂ :=
  by sorry

The theorem `FreeAddGroup.reduce.min` asserts that, for any type `α` with decidable equality and any lists `L₁` and `L₂` of pairs of elements from `α` and booleans, if `L₂` is reachable from the maximal reduction of `L₁` via the reflexive-transitive closure of the `Red.Step` relation, then the maximal reduction of `L₁` is indeed `L₂`. In other words, the maximal reduction of a word only reduces to itself within the context of the `FreeAddGroup.Red` relation.

If `L₂` is reachable from the maximal reduction of list `L₁` of pairs of elements and booleans from a type `α` with decidable equality via the reflexive-transitive closure of the reduction step relation `Red.Step` in the free additive group, then the maximal reduction of `L₁` equals `L₂`.


theorem Submodule.smul_mem_iff :
    ∀ {S : Type u'} {R : Type u} {M : Type v} [inst : DivisionSemiring S] [inst_1 : Semiring R]
      [inst_2 : AddCommMonoid M] [inst_3 : Module R M] [inst_4 : SMul S R] [inst_5 : Module S M]
      [inst_6 : IsScalarTower S R M] (p : Submodule R M) {s : S} {x : M}, s ≠ 0 → (s • x ∈ p ↔ x ∈ p) :=
  by sorry

This theorem states that for a given division semiring `S`, semiring `R`, and an additive commutative monoid `M`, which are structured such that `M` is an `R`-module and an `S`-module, and `S` acts on `R` which further acts on `M` (forming a scalar tower), then for any submodule `p` of the `R`-module `M`, a scalar `s` in `S`, and an element `x` in `M`, if `s` is not zero, then `s` times `x` belongs to the submodule `p` if and only if `x` belongs to `p`. In simpler terms, a nonzero scalar multiple of an element is in a submodule if and only if the original element is in that submodule.

For an `R`-module `M` over a division semiring `S`, if `p` is an `R`-submodule and `s` is a nonzero scalar in `S`, then `s * x ∈ p` if and only if `x ∈ p` for any `x` in `M`.


theorem Complex.tan_neg : ∀ (x : ℂ), Complex.tan (-x) = -Complex.tan x := by sorry

This theorem states that the complex tangent function is an odd function. Specifically, for any complex number `x`, the value of the complex tangent of `-x` is equal to the negation of the complex tangent of `x`. In mathematical notation, this can be written as `tan(-x) = -tan(x)`.

The complex tangent function is an odd function, that is, `tan(-x) = -tan(x)` for all complex numbers `x`.


/-- Adding a point in the affine span of a set does not change whether that set is collinear.  -/
theorem collinear_insert_iff_of_mem_affineSpan :
    ∀ {k : Type u_1} {V : Type u_2} {P : Type u_3} [inst : DivisionRing k] [inst_1 : AddCommGroup V]
      [inst_2 : Module k V] [inst_3 : AddTorsor V P] {s : Set P} {p : P},
      p ∈ affineSpan k s → (Collinear k (insert p s) ↔ Collinear k s) :=
  by sorry

This theorem states that for any division ring `k`, additive commutative group `V`, and add-torsor `P`, if `p` is a point in the affine span of a set `s`, then the property of `s` being collinear (i.e., all its points lie on a single line, or more formally, the `vectorSpan` of the set has a dimension at most `1`) remains unchanged even if `p` is added to `s`. In other words, inserting a point `p` that is already in the affine span of a set `s` does not affect the collinearity of `s`.

If `s` is a set of points in an additive commutative group `V` over a division ring `k` such that the affine span of `s` has dimension at most 1, then adding any point `p` in the affine span of `s` to `s` maintains the collinearity of `s`.


theorem PartENat.ne_top_of_lt : ∀ {x y : PartENat}, x < y → x ≠ ⊤ := by sorry

This theorem states that for any two elements `x` and `y` of the type `PartENat`, which represents the natural numbers extended with a symbol for infinity (`⊤`), if `x` is less than `y` (`x < y`), then `x` cannot be infinity (`x ≠ ⊤`). In other words, no natural number or infinity (represented by `x`) that is less than another number or infinity (represented by `y`) can be infinity itself.

If `x` is a natural number or infinity (PartENat) and `x` is less than `y` (PartENat), then `x` is not equal to infinity (`x ≠ ⊤`).


IsLocallyConstant.continuous

theorem IsLocallyConstant.continuous :
    ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {f : X → Y},
      IsLocallyConstant f → Continuous f :=
  by sorry

The theorem `IsLocallyConstant.continuous` states that for any types `X` and `Y`, and given the topological space structure on `X` and `Y`, if function `f` from `X` to `Y` is locally constant (i.e., the preimage of any set under `f` is open), then `f` is continuous. In other words, any function `f` that satisfies the condition that the inverse image of any subset of `Y` is an open set in `X` is guaranteed to be a continuous function.

If a function between topological spaces is locally constant, then it is continuous.


theorem eq_mul_inv_iff_mul_eq : ∀ {G : Type u_3} [inst : Group G] {a b c : G}, a = b * c⁻¹ ↔ a * c = b := by sorry

This theorem states that for any group `G` and any elements `a`, `b`, `c` of `G`, `a` is equal to the product of `b` and the inverse of `c` if and only if `a` multiplied by `c` is equal to `b`. In other words, it states an equivalence between two ways of expressing a relationship involving multiplication and inversion in a group.

For any group `G` and elements `a`, `b`, `c` in `G`, `a = b * c^-1` if and only if `a * c = b`.


theorem Cardinal.mk_arrow :
    ∀ (α : Type u) (β : Type v),
      Cardinal.mk (α → β) = Cardinal.lift.{u, v} (Cardinal.mk β) ^ Cardinal.lift.{v, u} (Cardinal.mk α) :=
  by sorry

The theorem `Cardinal.mk_arrow` states that for any two types `α` and `β`, the cardinality of the function type from `α` to `β` (`α → β`) is equal to the cardinality of `β` lifted to the maximum of universe levels of `α` and `β`, raised to the power of the cardinality of `α` lifted to the maximum of universe levels of `α` and `β`. Here, cardinality is a measure of the "size" of a type, the lift operation adjusts the universe level of a cardinal number, and `α → β` represents the type of functions from `α` to `β`.

The cardinality of the function type `α → β` is equal to the cardinality of `β` lifted to the maximum of the universe levels of `α` and `β`, raised to the power of the cardinality of `α` lifted to the maximum of the universe levels of `α` and `β`.


theorem MeasureTheory.lintegral_add_right' :
    ∀ {α : Type u_1} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} (f : α → ENNReal) {g : α → ENNReal},
      AEMeasurable g μ → ∫⁻ (a : α), f a + g a ∂μ = ∫⁻ (a : α), f a ∂μ + ∫⁻ (a : α), g a ∂μ :=
  by sorry

This theorem, `MeasureTheory.lintegral_add_right'`, states that for any type `α`, measurable space `m` of `α`, and measure `μ` on `α`, if we have two functions `f` and `g` mapping from `α` to the extended nonnegative real numbers (which include all nonnegative real numbers and positive infinity), and function `g` is almost everywhere measurable with respect to measure `μ`, then the integral over `μ` of the function `(a : α), f a + g a` (which is the function that adds the results of `f` and `g` at any given point) is equal to the sum of the integrals of `f` and `g` separately over `μ`. This is essentially a statement of linearity of integration in the context of measure theory.

For measurable functions `f` and almost everywhere measurable `g` on a measurable space `(α, μ)` with values in the extended nonnegative real numbers, the integral of their sum `f + g` equals the sum of their integrals `∫(α, μ) (f + g) dμ = ∫(α, μ) fdμ + ∫(α, μ) gdμ`.


theorem CategoryTheory.LocalizerMorphism.RightResolution.Hom.ext :
    ∀ {C₁ : Type u_1} {C₂ : Type u_2} {inst : CategoryTheory.Category.{u_5, u_1} C₁}
      {inst_1 : CategoryTheory.Category.{u_6, u_2} C₂} {W₁ : CategoryTheory.MorphismProperty C₁}
      {W₂ : CategoryTheory.MorphismProperty C₂} {Φ : CategoryTheory.LocalizerMorphism W₁ W₂} {X₂ : C₂}
      {R R' : CategoryTheory.LocalizerMorphism.RightResolution Φ X₂}
      (x y : CategoryTheory.LocalizerMorphism.RightResolution.Hom R R'), x.f = y.f → x = y :=
  by sorry

The theorem `CategoryTheory.LocalizerMorphism.RightResolution.Hom.ext` states that for any two categories `C₁` and `C₂` with corresponding morphism properties `W₁` and `W₂`, a localizer morphism `Φ` between `W₁` and `W₂`, and an object `X₂` in `C₂`, for any two right resolutions `R` and `R'` of `Φ` and `X₂`, if two morphisms `x` and `y` from `R` to `R'` have the same underlying function (i.e., `x.f = y.f`), then `x` and `y` are the same morphism (i.e., `x = y`). This theorem therefore guarantees the uniqueness of morphisms in the context of category theory when they have the same underlying function.

Given categories `C₁`, `C₂`, morphism properties `W₁` and `W₂`, a localizer morphism `Φ` between `W₁` and `W₂`, and objects `X₂` in `C₂`, if `R` and `R'` are right resolutions of `Φ` and `X₂`, then morphisms `x` and `y` in `R` with equal underlying functions `x.f = y.f` are equal `x = y`.


theorem eq_neg_of_add_eq_zero_right : ∀ {α : Type u_1} [inst : SubtractionMonoid α] {a b : α}, a + b = 0 → b = -a := by
  sorry

This theorem states that for any type `α` which is a subtraction monoid, for any two elements `a` and `b` of this type, if the sum of `a` and `b` equals zero, then `b` equals the negation of `a`. In mathematical terms, this can be written as: for all `a` and `b` in some type which is a subtraction monoid, if `a + b = 0`, then `b = -a`.

If `α` is a subtraction monoid type, then for all `a` and `b` in `α`, if `a + b = 0`, then `b = -a`.


theorem Finset.prod_multiset_map_count :
    ∀ {α : Type u_3} [inst : DecidableEq α] (s : Multiset α) {M : Type u_6} [inst_1 : CommMonoid M] (f : α → M),
      Multiset.prod (Multiset.map f s) = Finset.prod (Multiset.toFinset s) fun m => f m ^ Multiset.count m s :=
  by sorry

The theorem `Finset.prod_multiset_map_count` states that for any multiset `s` of elements from an arbitrary type `α` (which has a decidable equality) and a function `f` that maps from `α` to a type `M` (which is equipped with a commutative monoid structure), the product of the mapped multiset elements is equal to the product of the unique elements of the multiset (obtained by converting the multiset to a finset) each raised to the power of its multiplicity in the original multiset. In simpler terms, it justifies the ability to interchange the order of mapping a function over a multiset and taking the product, with taking the product over the unique elements of the multiset where each element is raised to the power of its count in the multiset.

For any multiset `s` of decidably equal elements from type `α` and any commutative monoid `M` with a function `f` from `α` to `M`, the multiset product of `f` applied to the elements of `s` equals the product of `f` applied to each unique element in `s` raised to the power of its multiplicity in `s`.


theorem Submodule.comap_map_eq :
    ∀ {R : Type u_1} {R₂ : Type u_2} {M : Type u_4} {M₂ : Type u_5} [inst : Semiring R] [inst_1 : Semiring R₂]
      [inst_2 : AddCommGroup M] [inst_3 : Module R M] [inst_4 : AddCommGroup M₂] [inst_5 : Module R₂ M₂]
      {τ₁₂ : R →+* R₂} [inst_6 : RingHomSurjective τ₁₂] {F : Type u_8} [inst_7 : FunLike F M M₂]
      [inst_8 : SemilinearMapClass F τ₁₂ M M₂] (f : F) (p : Submodule R M),
      Submodule.comap f (Submodule.map f p) = p ⊔ LinearMap.ker f :=
  by sorry

The theorem `Submodule.comap_map_eq` asserts that for any semirings `R` and `R₂`, any commutative additive groups `M` and `M₂`, a module `M` over `R`, a module `M₂` over `R₂`, a surjective ring homomorphism `τ₁₂` from `R` to `R₂`, a function `f` which is a semilinear map from `M` to `M₂` with respect to `τ₁₂`, and a submodule `p` of `M`, the preimage under `f` of the image under `f` of `p` is equal to the join of `p` and the kernel of `f`. Here, the preimage is computed via the `Submodule.comap` function, the image via the `Submodule.map` function, and the join via the `⊔` operation. In other words, it describes how mapping and then comapping a submodule with a semilinear map corresponds to enlarging the original submodule by the kernel of the map.

For any semirings R and R₂, commutative additive groups M and M₂, a module M over R, a module M₂ over R₂, a surjective ring homomorphism τ₁₂ from R to R₂, a semilinear map f from M to M₂ with respect to τ₁₂, and a submodule p of M, the preimage of the image of p under f, as computed by `Submodule.comap` and `Submodule.map`, equals the join of p and the kernel of f.


theorem Int.ofNat_mul_negSucc : ∀ (m n : ℕ), ↑m * Int.negSucc n = -↑(m * Nat.succ n) := by sorry

This theorem states that for any two natural numbers `m` and `n`, the product of `m` and the successor of `n` with a negative sign is equal to the negation of the product of `m` and the successor of `n` when both are cast to integers. In other words, multiplying a natural number with the negative successor of another natural number in the integers is the same as taking the negative of the product of the two natural numbers, where the second one has been succeeded.

For any natural numbers m and n, (-m * (Suc n)) = -(m * Suc n), where Suc denotes the successor function.


theorem continuousOn_pi :
    ∀ {α : Type u_1} [inst : TopologicalSpace α] {ι : Type u_5} {π : ι → Type u_6}
      [inst_1 : (i : ι) → TopologicalSpace (π i)] {f : α → (i : ι) → π i} {s : Set α},
      ContinuousOn f s ↔ ∀ (i : ι), ContinuousOn (fun y => f y i) s :=
  by sorry

This theorem, named `continuousOn_pi`, is about the continuity of functions in topological spaces. It states that for any type `α` with a topological space structure, any type `ι`, a function `π` from `ι` to another type, a function `f` from `α` to the output of `π`, and a set `s` of type `α`, `f` is continuous on the set `s` if and only if, for every element `i` from `ι`, the function that takes an element `y` and maps it to the `i`-th component of `f(y)` is also continuous on `s`. In other words, a function is continuous on a set if and only if it is continuous on that set when evaluated at each component.

A function from a topological space to another space is continuous on a set if and only if the projection of its values to each component is continuous on that set.


theorem Mathlib.Order.Filter.Prod._auxLemma.7 :
    ∀ {α : Type u_1} {β : Type u_2} {s : Set (α × β)} {f : Filter α} {g : Filter β},
      (s ∈ f ×ˢ g) = ∃ t₁ ∈ f, ∃ t₂ ∈ g, t₁ ×ˢ t₂ ⊆ s :=
  by sorry

This theorem is about the product of two filters. It says that for any two types `α` and `β`, a set `s` of pairs `(α, β)`, and filters `f` and `g` over `α` and `β` respectively, the set `s` is in the product of `f` and `g` if and only if there exist subsets `t₁` and `t₂` in `f` and `g` respectively, such that the product of `t₁` and `t₂` is a subset of `s`. In mathematical terms, given a set `s` in the Cartesian product of `α` and `β`, and filters `f` on `α` and `g` on `β`, `s` belongs to the product filter `f ×ˢ g` if and only if there exist `t₁` in `f` and `t₂` in `g` such that the Cartesian product of `t₁` and `t₂` is contained in `s`.

A set of pairs in the Cartesian product of two types belongs to the product filter of two filters if and only if there exist subsets in each filter whose Cartesian product contains the set.


theorem SeparationQuotient.mk_eq_mk :
    ∀ {X : Type u_1} [inst : TopologicalSpace X] {x y : X},
      SeparationQuotient.mk x = SeparationQuotient.mk y ↔ Inseparable x y :=
  by sorry

The theorem `SeparationQuotient.mk_eq_mk` states that for any topological space `X` and any two points `x` and `y` in `X`, the natural map from `X` to its separation quotient applied to `x` is equal to the same map applied to `y` if and only if `x` and `y` are inseparable. Here, two points `x` and `y` are said to be inseparable if their neighborhood filters, denoted `𝓝 x` and `𝓝 y` respectively, are equal.

For any topological space X and points x, y in X, the natural map from X to its separation quotient takes x to y if and only if the neighborhood filters of x and y are equal.


theorem List.replicate_sublist_replicate :
    ∀ {α : Type u_1} {m n : ℕ} (a : α), List.Sublist (List.replicate m a) (List.replicate n a) ↔ m ≤ n := by sorry

The theorem `List.replicate_sublist_replicate` states that for any type `α`, natural numbers `m` and `n`, and an element `a` of type `α`, the list which is the replication of `a` `m` times is a sublist of the list which is the replication of `a` `n` times if and only if `m` is less than or equal to `n`. This essentially means that a list made up of `m` copies of an element is contained within a list made up of `n` copies of the same element precisely when `m` is less than or equal to `n`.

For all type α, natural numbers m and n, and element a of α, the sublist a :: ... :: a (repeated m times) is contained in the sublist a :: ... :: a (repeated n times) if and only if m ≤ n.


theorem connectedComponentIn_eq_image :
    ∀ {α : Type u} [inst : TopologicalSpace α] {F : Set α} {x : α} (h : x ∈ F),
      connectedComponentIn F x = Subtype.val '' connectedComponent { val := x, property := h } :=
  by sorry

This theorem states that in any topological space `α`, for any subset `F` of `α` and a point `x` in `α` such that `x` belongs to `F`, the connected component of `x` in `F` is equivalent to the image under the subtype value function of the connected component of the subtype `{ val := x, property := h }`. Here, `h` is the assumption that `x` is in `F`. In other words, if a point belongs to a set in a topological space, its connected component within that set is the same as the connected component of the point considered as an element of the subtype defined by the set.

In any topological space, the connected component of a point in a subset is equal to the image under the subtype value function of the connected component of the subpoint.


theorem MeasureTheory.measure_eq_iInf :
    ∀ {α : Type u_1} [inst : MeasurableSpace α] {μ : MeasureTheory.Measure α} (s : Set α),
      ↑↑μ s = ⨅ t, ⨅ (_ : s ⊆ t), ⨅ (_ : MeasurableSet t), ↑↑μ t :=
  by sorry

The theorem `MeasureTheory.measure_eq_iInf` states that for any given type `α` that forms a measurable space, any measure `μ` on that space, and any set `s` of type `α`, the measure of `s` is equal to the infimum of the measures of all measurable sets `t` such that `s` is a subset of `t`. In other words, we can calculate the measure of a set by looking at all larger measurable sets and finding the smallest measure among them.

For any measurable space `(α, Σ, μ)`, the measure of a measurable set `s` is equal to the infimum of the measures of all measurable sets `t` containing `s`.


theorem MeasureTheory.measure_eq_zero_of_trim_eq_zero :
    ∀ {α : Type u_1} {m m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} {s : Set α} (hm : m ≤ m0),
      ↑↑(μ.trim hm) s = 0 → ↑↑μ s = 0 :=
  by sorry

The theorem `MeasureTheory.measure_eq_zero_of_trim_eq_zero` states that for any type `α`, any two measurable spaces `m` and `m0` on `α`, any measure `μ` on `α`, and any set `s` of `α`, if `m` is less than or equal to `m0` (`hm`), and if the trimmed measure of `μ` with respect to `m` is zero on `s`, then the original measure `μ` is also zero on `s`. Here, the trimming of a measure is a process that modifies the measure to make it compatible with a smaller sigma algebra.

If `μ` is a measure on a measurable space `α`, `m` and `m0` are two measurable structures on `α` with `hm(m ≤ m0)` and the trimmed measure `μ∣m` is zero on set `s`, then `μ(s) = 0`.


theorem Fin.succ_zero_eq_one : ∀ {n : ℕ}, Fin.succ 0 = 1 := by sorry

This theorem, named `Fin.succ_zero_eq_one`, states that for any natural number `n`, the successor of `0` in the finite sequence of size `n` (denoted as `Fin.succ 0`) is equal to `1`. In simpler terms, it implies that if you increment `0` in the series of the first `n` natural numbers (including zero), you will always get `1`.

For any natural number `n`, `Fin.succ 0` equals `1` in the finite sequence of length `n+1`.


theorem forall_open_iff_discrete :
    ∀ {X : Type u_2} [inst : TopologicalSpace X], (∀ (s : Set X), IsOpen s) ↔ DiscreteTopology X := by sorry

This theorem, `forall_open_iff_discrete`, states that for any type `X` equipped with a topology (i.e., a topological space), the condition that every subset of `X` is an open set is equivalent to the topology being a discrete topology. In other words, a topological space `X` is a discrete topological space if and only if every subset of `X` is considered open in this topology.

A topological space is discrete if and only if every subset is open.


theorem nhds_mono : ∀ {α : Type u} {t₁ t₂ : TopologicalSpace α} {a : α}, t₁ ≤ t₂ → nhds a ≤ nhds a := by sorry

The theorem `nhds_mono` asserts that for any type `α` and any two topological spaces `t₁` and `t₂` over `α`, and any element `a` of `α`, if `t₁` is a subtopology of `t₂` (i.e., `t₁ ≤ t₂`), then the neighborhood filter of `a` in `t₁` is a subfilter of the neighborhood filter of `a` in `t₂`. In other words, every neighborhood of `a` in the smaller topology is also a neighborhood of `a` in the larger topology.

For any type `α`, if `t₁` is a subtopology of `t₂` over `α` and `a` is an element of `α`, then the neighborhood filter of `a` in `t₁` is contained in the neighborhood filter of `a` in `t₂`.


/-- This is used as the ext lemma instead of `LinearMap.pi_ext` for reasons explained in
note [partially-applied ext lemmas].  -/
theorem LinearMap.pi_ext' :
    ∀ {R : Type u} {M : Type v} {ι : Type x} [inst : Semiring R] {φ : ι → Type i}
      [inst_1 : (i : ι) → AddCommMonoid (φ i)] [inst_2 : (i : ι) → Module R (φ i)] [inst_3 : Finite ι]
      [inst_4 : DecidableEq ι] [inst_5 : AddCommMonoid M] [inst_6 : Module R M] {f g : ((i : ι) → φ i) →ₗ[R] M},
      (∀ (i : ι), f ∘ₗ LinearMap.single i = g ∘ₗ LinearMap.single i) → f = g :=
  by sorry

This theorem, `LinearMap.pi_ext'`, states that for any semiring `R`, Type `M`, Type index `ι`, a function `φ : ι → Type i`, and given the conditions that for each `i` in `ι`, `φ i` forms an additive commutative monoid and a module over `R`, that `ι` is finite and has decidable equality, and `M` forms an additive commutative monoid and a module over `R`, for any two linear maps `f` and `g` from the function space `(i : ι) → φ i` to `M`, if for all `i` in `ι`, the composition of `f` with the single linear map at `i` is equal to the composition of `g` with the single linear map at `i`, then `f` is equal to `g`. In simpler terms, it tells that if two linear maps agree on all single-element inputs, then they are equal.

Given a semiring `R`, a finite index type `ι`, an additive commutative monoid `M` that is an `R`-module, and functions `f` and `g` from `ι` to `M` such that `φ i` forms an additive commutative monoid and an `R`-module for each `i`, if `f i = g i` for all `i` in `ι`, then `f = g`.


theorem Algebra.norm_eq_zero_iff :
    ∀ {R : Type u_1} {S : Type u_2} [inst : CommRing R] [inst_1 : Ring S] [inst_2 : Algebra R S] [inst_3 : IsDomain R]
      [inst_4 : IsDomain S] [inst_5 : Module.Free R S] [inst_6 : Module.Finite R S] {x : S},
      (Algebra.norm R) x = 0 ↔ x = 0 :=
  by sorry

This theorem states that for any types `R` and `S`, where `R` is a commutative ring, `S` is a ring, and `S` is an `R`-algebra, `R` is a domain and `S` is also a domain, `S` is a free `R`-module, and `S` is a finite `R`-module, if an element `x` of type `S` satisfies the condition that the algebraic norm of `x` (calculated as the determinant of `(*) x`) is zero, then it is equivalent to stating that the element `x` itself is zero. This theorem provides a necessary and sufficient condition for an element of an `R`-algebra to be zero in terms of the algebraic norm.

In a commutative ring `R`, for any domain `S` that is a finite `R`-algebra, an `R`-module, and a domain, the algebraic norm of an element `x` in `S` being zero is equivalent to `x` being the additive identity in `S`.


theorem Irreducible.associated_of_dvd :
    ∀ {α : Type u_1} [inst : Monoid α] {p q : α}, Irreducible p → Irreducible q → p ∣ q → Associated p q := by sorry

This theorem states that for any type `α` that forms a `Monoid`, given two elements `p` and `q` of this type, if both `p` and `q` are irreducible and `p` divides `q`, then `p` and `q` are associated. In terms of number theory, two elements are associated if they differ by a multiplication of a unit, which in the case of integers, means they are multiples of each other. Thus, the theorem is asserting that in a monoid, two irreducible elements that divide each other must be associates.

In a monoid, if two irreducible elements are divisors of each other, then they are associates.


theorem Mathlib.MeasureTheory.Function.L1Space._auxLemma.20 :
    ∀ (α : Type u_1) (β : Type u_2) {m : MeasurableSpace α} (μ : MeasureTheory.Measure α) [inst : NormedAddCommGroup β],
      MeasureTheory.Integrable (fun x => 0) μ = True :=
  by sorry

This theorem asserts that for any types `α` and `β`, a given measurable space `m` associated with `α`, a measure `μ` also associated with `α`, and an instance of the type class `NormedAddCommGroup` on `β`, the function which maps every element of `α` to the zero element of `β` is integrable with respect to the measure `μ`. In other words, the zero function is always integrable.

For any measurable space `(α, m)`, measure `μ` on `α`, and `NormedAddCommGroup` type `β`, the constant function from `α` to the zero element of `β` is integrable with respect to `μ`.


/-- A point `x` in a discrete subset `s` of a topological space admits a neighbourhood
that only meets `s` at `x`.   -/
theorem nhds_inter_eq_singleton_of_mem_discrete :
    ∀ {X : Type u_1} [inst : TopologicalSpace X] {s : Set X} [inst_1 : DiscreteTopology ↑s] {x : X},
      x ∈ s → ∃ U ∈ nhds x, U ∩ s = {x} :=
  by sorry

The theorem `nhds_inter_eq_singleton_of_mem_discrete` states that for any point `x` in a discrete subset `s` of a topological space, there exists a neighborhood of `x` that intersects with `s` only at `x`. In other words, given a topological space `X`, a discrete subset `s` of `X`, and a point `x` in `s`, we can always find a neighborhood `U` of `x` such that the intersection of `U` and `s` is precisely the singleton set `{x}`. This reflects a property of discrete sets in topological spaces: every point in a discrete set is "isolated" from other points in the set by neighborhoods that do not contain any other points from the set.

For any discrete subset `s` of a topological space `X` and any point `x` in `s`, there exists a neighborhood of `x` that intersects `s` only at `x`.


theorem AlgebraicGeometry.AffineTargetMorphismProperty.IsLocal.affine_openCover_iff :
    ∀ {P : AlgebraicGeometry.AffineTargetMorphismProperty},
      AlgebraicGeometry.AffineTargetMorphismProperty.IsLocal P →
        ∀ {X Y : AlgebraicGeometry.Scheme} (f : X ⟶ Y) (𝒰 : AlgebraicGeometry.Scheme.OpenCover Y)
          [h𝒰 : ∀ (i : 𝒰.J), AlgebraicGeometry.IsAffine (𝒰.obj i)],
          AlgebraicGeometry.targetAffineLocally P f ↔ ∀ (i : 𝒰.J), P CategoryTheory.Limits.pullback.snd :=
  by sorry

This theorem provides a characterization of a property of morphisms between algebraic geometry schemes, when the target is locally affine. Specifically, for any property `P` of morphisms into an affine scheme that is local in the sense of the `AffineTargetMorphismProperty.IsLocal` definition, a morphism `f` from a scheme `X` to a scheme `Y` satisfies the `targetAffineLocally` relation with `P` if and only if `P` holds for the second projection of the pullback of `f` and the inclusion of each open subset of an open cover `𝒰` of `Y`, whenever each object of `𝒰` is an affine scheme.
In simpler terms, this theorem allows us to check a local property on all affine parts of the target of a morphism, rather than on the whole scheme.

Given a property `P` of morphisms into affine schemes that is local, a morphism `f` from a scheme `X` to a locally affine scheme `Y` satisfies `P` if and only if `P` holds for the second projection of the pullback and the inclusion of each open subset of any open cover of `Y` that consists of affine schemes.


/-- A homomorphism `f` of seminormed groups is Lipschitz, if there exists a constant
`C` such that for all `x`, one has `‖f x‖ ≤ C * ‖x‖`. The analogous condition for a linear map of
(semi)normed spaces is in `Mathlib/Analysis/NormedSpace/OperatorNorm.lean`. -/
theorem AddMonoidHomClass.lipschitz_of_bound :
    ∀ {𝓕 : Type u_1} {E : Type u_6} {F : Type u_7} [inst : SeminormedAddGroup E] [inst_1 : SeminormedAddGroup F]
      [inst_2 : FunLike 𝓕 E F] [inst_3 : AddMonoidHomClass 𝓕 E F] (f : 𝓕) (C : ℝ),
      (∀ (x : E), ‖f x‖ ≤ C * ‖x‖) → LipschitzWith (Real.toNNReal C) ⇑f :=
  by sorry

This theorem states that a homomorphism `f` of seminormed groups is Lipschitz continuous if there exists a constant `C` such that for all elements `x`, the norm of `f x` is less than or equal to `C` times the norm of `x`. Here, Lipschitz continuity is defined as a function `f` being Lipschitz continuous with constant `K ≥ 0` if for all `x, y` we have `dist (f x) (f y) ≤ K * dist x y`. The constant `C` is interpreted as a non-negative real number using the `Real.toNNReal` function, which returns `0` if `C < 0`. This concept is analogous to a condition for linear maps of (semi)normed spaces, which can be found in `Mathlib/Analysis/NormedSpace/OperatorNorm.lean`.

A homomorphism between seminormed groups is Lipschitz continuous if there exists a constant `C` such that the norm of the image under the homomorphism is bounded by `C` times the norm of the argument.


theorem gc_floorDiv_smul :
    ∀ {α : Type u_2} {β : Type u_3} [inst : OrderedAddCommMonoid α] [inst_1 : OrderedAddCommMonoid β]
      [inst_2 : SMulZeroClass α β] [inst_3 : FloorDiv α β] {a : α},
      0 < a → GaloisConnection (fun x => a • x) fun x => x ⌊/⌋ a :=
  by sorry

The theorem `gc_floorDiv_smul` states that, for any types `α` and `β` which are ordered additive commutative monoids, and for any `a` in `α` which is greater than zero, the functions `a • x` and `x ⌊/⌋ a` form a Galois connection. This means that for all `x` in `α` and `y` in `β`, `a` times `x` is less than or equal to `y` if and only if `x` is less than or equal to the floor division of `y` by `a`. Here, `a • x` denotes the scaled version of `x` by a factor of `a`, and `x ⌊/⌋ a` denotes the floor division of `x` by `a`.

For types `α` and `β` being ordered additive commutative monoids, and for any positive `a` in `α`, the functions `a • x` and `x ⌊/⌋ a` form a Galois connection, that is, `a • x ≤ y` if and only if `x ≤ y ∖ a` for all `x` in `α` and `y` in `β`.


theorem Nat.le_floor_iff' :
    ∀ {α : Type u_2} [inst : LinearOrderedSemiring α] [inst_1 : FloorSemiring α] {a : α} {n : ℕ},
      n ≠ 0 → (n ≤ ⌊a⌋₊ ↔ ↑n ≤ a) :=
  by sorry

This theorem states that for any type `α` that forms a linear ordered semiring and a floor semiring, and for any non-zero natural number `n` and any element `a` of type `α`, the statement "n is less than or equal to the floor of a" is equivalent to "n as an element of the semiring is less than or equal to a". This theorem is useful for performing comparisons involving the floor function in a semiring.

For any linear ordered semiring `α` and non-zero natural number `n` in `α`, the equality `n ≤ floor a` holds if and only if `n` is less than or equal to `a` in the semiring `α`.


IsMinFilter.add

theorem IsMinFilter.add :
    ∀ {α : Type u} {β : Type v} [inst : OrderedAddCommMonoid β] {f g : α → β} {a : α} {l : Filter α},
      IsMinFilter f l a → IsMinFilter g l a → IsMinFilter (fun x => f x + g x) l a :=
  by sorry

The theorem `IsMinFilter.add` states that for any types `α` and `β`, where `β` forms an ordered commutative monoid under addition, and any functions `f` and `g` from `α` to `β`, and any `α` value `a` and any filter `l` in `α`, if `a` is a point of minimal value under `f` and under `g` in some `l`-neighborhood, then `a` is also a point of minimal value under the function `h` that maps `x` to `f(x) + g(x)` in the same `l`-neighborhood. In other words, if `f(a)` and `g(a)` are both minimal for all `x` near `a`, then `(f+g)(a)` is also minimal for all `x` near `a`.

If `a` minimally satisfies `f(a) = \inf_{x \in l} f(x)` and `g(a) = \inf_{x \in l} g(x)` for some filter `l` and functions `f` and `g` from a type `α` to an ordered commutative monoid `β`, then `a` also minimally satisfies `(f + g)(a) = \inf_{x \in l} (f + g)(x)`.


MeasurableSet.insert

theorem MeasurableSet.insert :
    ∀ {α : Type u_1} [inst : MeasurableSpace α] [inst_1 : MeasurableSingletonClass α] {s : Set α},
      MeasurableSet s → ∀ (a : α), MeasurableSet (insert a s) :=
  by sorry

The theorem `MeasurableSet.insert` states that for any type `α` equipped with both a `MeasurableSpace` structure and a `MeasurableSingletonClass` structure, if `s` is a set of elements of type `α` that is measurable, then the set resulting from inserting any element `a` of type `α` into `s` is also measurable. This means that measurability is preserved under the operation of inserting an element into a set.

If `α` is a type with both `MeasurableSpace` and `MeasurableSingletonClass` structures, and `s` is a measurable subset of `α`, then the subset obtained by inserting an element `a` into `s` is also measurable.


/-- A point `c` belongs the perpendicular bisector of `[p₁, p₂] iff `c -ᵥ midpoint ℝ p₁ p₂` is
orthogonal to `p₂ -ᵥ p₁`.  -/
theorem AffineSubspace.mem_perpBisector_iff_inner_eq_zero :
    ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V]
      [inst_2 : MetricSpace P] [inst_3 : NormedAddTorsor V P] {c p₁ p₂ : P},
      c ∈ AffineSubspace.perpBisector p₁ p₂ ↔ ⟪c -ᵥ midpoint ℝ p₁ p₂, p₂ -ᵥ p₁⟫_ℝ = 0 :=
  by sorry

The theorem `AffineSubspace.mem_perpBisector_iff_inner_eq_zero` states that for a given point `c` and a segment defined by points `p₁` and `p₂` in a Euclidean affine space, `c` lies on the perpendicular bisector of the segment `[p₁, p₂]` if and only if the vector formed by `c` and the midpoint of `p₁` and `p₂` is orthogonal (i.e., the inner product equals zero) to the vector formed by `p₂` and `p₁`. This theorem provides a condition related to inner products for checking if a point is on the perpendicular bisector of a given segment.

A point c in a Euclidean affine space is on the perpendicular bisector of the segment [p₁, p₂] if and only if the vector from c to the midpoint of p₁ and p₂ is orthogonal to the vector from p₁ to p₂. (Equivalently, the inner product of these two vectors is zero.)


theorem UniqueFactorizationMonoid.normalizedFactors_zero :
    ∀ {α : Type u_1} [inst : CancelCommMonoidWithZero α] [inst_1 : NormalizationMonoid α]
      [inst_2 : UniqueFactorizationMonoid α], UniqueFactorizationMonoid.normalizedFactors 0 = 0 :=
  by sorry

This theorem states that for any type `α` that forms a `CancelCommMonoidWithZero`, a `NormalizationMonoid`, and a `UniqueFactorizationMonoid`, the multiset of normalized prime factors of zero, as determined by the `UniqueFactorizationMonoid.normalizedFactors` function, is zero. In other words, the zero element has no prime factors in the context of unique factorization monoids.

For any type `α` that is a CancelCommMonoidWithZero, a NormalizationMonoid, and a UniqueFactorizationMonoid in Lean 4, the normalized prime factors of zero, as given by `UniqueFactorizationMonoid.normalizedFactors`, are the empty multiset.


theorem neg_one_pow_eq_or :
    ∀ (R : Type u_1) [inst : Monoid R] [inst_1 : HasDistribNeg R] (n : ℕ), (-1) ^ n = 1 ∨ (-1) ^ n = -1 := by sorry

This theorem, `neg_one_pow_eq_or`, states that for any type `R` that is a monoid and has a distributive negation, and for any natural number `n`, the value of `(-1) ^ n` is either `1` or `-1`. In mathematical terms, it asserts that the power of `-1` for any non-negative integer will always be `1` or `-1`.

For any monoid `R` with distributive negation, the value of `(-1) ^ n` is equal to `1` or `-1` for every natural number `n`.


theorem CategoryTheory.Limits.parallelPair_functor_obj :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C]
      {F : CategoryTheory.Functor CategoryTheory.Limits.WalkingParallelPair C}
      (j : CategoryTheory.Limits.WalkingParallelPair),
      (CategoryTheory.Limits.parallelPair (F.map CategoryTheory.Limits.WalkingParallelPairHom.left)
              (F.map CategoryTheory.Limits.WalkingParallelPairHom.right)).obj
          j =
        F.obj j :=
  by sorry

This theorem states that for any category `C`, and any functor `F` from the category of a walking parallel pair to `C`, the object obtained by applying the functor `F` to a walking parallel pair is identical to the object obtained by the `parallelPair` operation to the morphisms `WalkingParallelPairHom.left` and `WalkingParallelPairHom.right` in the category `C`. The `parallelPair` operation creates a parallel pair of morphisms between two objects in a category.

For any category `C` and functor `F` from the category of walking parallel pairs, `F(WalkingParallelPair(x, y))` is isomorphic to `parallelPair(F(x) ↔[F(f)] F(y))` in `C`, where `x ↔[f] y` is a walking parallel pair in `C`.


theorem List.dlookup_cons_eq :
    ∀ {α : Type u} {β : α → Type v} [inst : DecidableEq α] (l : List (Sigma β)) (a : α) (b : β a),
      List.dlookup a ({ fst := a, snd := b } :: l) = some b :=
  by sorry

The theorem `List.dlookup_cons_eq` states that for any types `α` and `β`, assuming `α` has a decidable equality, given a list `l` of Sigma types (`Sigma β`), a value `a` of type `α`, and a value `b` of type `β a`, when we prepend a pair with first element `a` and second element `b` to the list `l` and then look for the first value in the new list that corresponds to the key `a` using `List.dlookup`, we will always get the value `b`. Essentially, this theorem asserts that `List.dlookup` correctly retrieves the most recently added value for a given key in a list of key-value pairs.

Given a list `l` of pairs `(α × β)`, an element `a` of type `α`, and its corresponding element `b` of type `β` in this list, `List.dlookup (a :: l) = b`.


/-- The zeroth cyclotomic polyomial is `1`.  -/
theorem Polynomial.cyclotomic_zero : ∀ (R : Type u_1) [inst : Ring R], Polynomial.cyclotomic 0 R = 1 := by sorry

The theorem `Polynomial.cyclotomic_zero` states that the zeroth cyclotomic polynomial, regardless of the ring `R` over which it is considered, is always equal to `1`. Here, `R` can be any type endowed with a ring structure. Essentially, this theorem asserts a constant value of `1` for the cyclotomic polynomial when the input parameter `n` is zero.

The zeroth cyclotomic polynomial equals 1 in any commutative ring.


theorem le_add_iff_nonneg_right :
    ∀ {α : Type u_1} [inst : AddZeroClass α] [inst_1 : LE α]
      [inst_2 : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1]
      [inst_3 : ContravariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] (a : α) {b : α},
      a ≤ a + b ↔ 0 ≤ b :=
  by sorry

This theorem, `le_add_iff_nonneg_right`, states that for all elements `a` and `b` in a type `α` that has an addition operation and a less than or equal to order (`LE`), it holds that `a` is less than or equal to `a + b` if and only if `0` is less than or equal to `b`. The type `α` must be equipped with an `AddZeroClass` instance, meaning it has a zero element and an addition operation. Additionally, the type `α` needs to have the properties of `CovariantClass` and `ContravariantClass` with respect to addition and the order, meaning that the order and the addition operation interact in certain specific ways.

For all elements `a` in a type `α` with addition and order, `a ≤ a + b` if and only if `0 ≤ b`.


/-- The complement of a set has the same frontier as the original set.  -/
theorem frontier_compl : ∀ {X : Type u} [inst : TopologicalSpace X] (s : Set X), frontier sᶜ = frontier s := by sorry

This theorem states that, for any set in a topological space, the frontier of the complement of the set is the same as the frontier of the set itself. Here, the 'frontier' of a set is defined as the set of points that lie between the closure and the interior of the set. The 'complement' of a set consists of all points that are not in the set. Hence, in more plain terms, the boundary of a set and the boundary of everything not in the set are the same.

The boundary of a set in a topological space is equal to the boundary of its complement.


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

The theorem `Multiset.nodup_dedup` asserts that for any multiset `s` of a type `α`, where `α` has decidable equality, the operation `Multiset.dedup s` results in a multiset with no duplicates. In other words, when duplicates are removed from a given multiset `s` using the `Multiset.dedup` function, the resulting multiset satisfies the `Multiset.Nodup` property.

For any decidably equal multiset `s` of type `α`, `Multiset.dedup s` is a multiset with no duplicate elements.


/-- The norm of the identity is at most `1`. It is in fact `1`, except when the space is trivial
where it is `0`. It means that one can not do better than an inequality in general.  -/
theorem ContinuousLinearMap.norm_id_le :
    ∀ {𝕜 : Type u_1} {E : Type u_4} [inst : SeminormedAddCommGroup E] [inst_1 : NontriviallyNormedField 𝕜]
      [inst_2 : NormedSpace 𝕜 E], ‖ContinuousLinearMap.id 𝕜 E‖ ≤ 1 :=
  by sorry

The theorem `ContinuousLinearMap.norm_id_le` states that the norm of the identity map on a non-trivial normed space over a non-trivially normed field is at most `1`. More specifically, it assures that the norm of the identity map as a continuous linear map from a space to itself does not exceed `1`. However, the norm is indeed `1`, except when the space itself is trivial, in which case it is `0`. This entails that one cannot establish a stronger result than this inequality in a general case.

The norm of the identity map as a continuous linear operator on a non-trivial normed space over a non-trivially normed field does not exceed 1.


theorem List.dlookup_cons_ne :
    ∀ {α : Type u} {β : α → Type v} [inst : DecidableEq α] (l : List (Sigma β)) {a : α} (s : Sigma β),
      a ≠ s.fst → List.dlookup a (s :: l) = List.dlookup a l :=
  by sorry

The theorem `List.dlookup_cons_ne` states that for any types `α` and `β`, where `β` is a dependent type determined by `α`, and for any list `l` of sigma types `β`, and any sigma type `s`, if the key `a` is not equal to the first component of `s`, then the result of the `dlookup` function (which finds the first value in the list corresponding to the key `a`) is the same whether we are looking in the list where `s` is the first element or in the original list `l`. In other words, if we're looking for a key that's not the key of the first element, prepending that first element won't affect the result of the `dlookup` function.

For any types `α` and `β`, list `l` of sigma types `β`, and sigma type `s` with different keys, the result of `dlookup` on list `l` is equal to the result of `dlookup` on list `[s] ++ l`.


theorem Equiv.self_trans_symm : ∀ {α : Sort u} {β : Sort v} (e : α ≃ β), e.trans e.symm = Equiv.refl α := by sorry

This theorem, `Equiv.self_trans_symm`, states that for all types `α` and `β`, if we have an equivalence `e` between `α` and `β`, then the composition of `e` and its inverse (i.e., `e.trans e.symm`) is equivalent to the identity mapping on `α` (i.e., `Equiv.refl α`). In other words, if you can transform `α` to `β` and then reverse it back to `α`, you essentially do nothing (you obtain the identity map), which is a fundamental property of all equivalences.

For all types `α` and equivalences `e` between `α` and another type `β`, `e.trans e.symm = Equiv.refl α`.


theorem abs_inv : ∀ {α : Type u_2} [inst : LinearOrderedField α] (a : α), |a⁻¹| = |a|⁻¹ := by sorry

The theorem `abs_inv` states that for every type `α` that is a linear ordered field, the absolute value of the inverse of any element `a` from `α` is equal to the inverse of the absolute value of `a`. In mathematical notation, this is saying that for any real number `a`, |1/a| = 1/|a|.

For any linear ordered field `α`, |a^(-1)| = |a|^(-1) for all `a` in `α`.


/-- The addition of two nonsingular affine points in `W` on a sloped line is nonsingular.  -/
theorem WeierstrassCurve.Affine.nonsingular_add :
    ∀ {F : Type u} [inst : Field F] {W : WeierstrassCurve.Affine F} {x₁ x₂ y₁ y₂ : F},
      W.nonsingular x₁ y₁ →
        W.nonsingular x₂ y₂ →
          (x₁ = x₂ → y₁ ≠ W.negY x₂ y₂) →
            W.nonsingular (W.addX x₁ x₂ (W.slope x₁ x₂ y₁ y₂)) (W.addY x₁ x₂ y₁ (W.slope x₁ x₂ y₁ y₂)) :=
  by sorry

The theorem `WeierstrassCurve.Affine.nonsingular_add` states that given a field `F`, a Weierstrass curve `W` in affine coordinates over `F`, and two nonsingular points (`x₁`, `y₁`) and (`x₂`, `y₂`) on `W`, if `x₁` equals `x₂` then `y₁` must not be the negative of `y₂` under the Weierstrass curve transformation. Under these conditions, the sum of these two points, calculated using the `W.addX` and `W.addY` operations with the slope of the line through the points, results in another point that is also nonsingular on the Weierstrass curve.

Given a Weierstr Ross curve in affine coordinates over a field, if two nonsingular points on the curve have the same x-coordinate, then their sum, calculated using the curve's `addX` and `addY` operations and the slope of the line through them, is another nonsingular point on the curve, excluding the case where the y-coordinates are negatives of each other.


theorem Mathlib.Data.Finset.Option._auxLemma.2 :
    ∀ {α : Type u_1} {a : α} {o : Option α}, (a ∈ Option.toFinset o) = (a ∈ o) := by sorry

This theorem states that for any type `α`, any element `a` of type `α`, and any optional value `o` of type `α`, the statement "element `a` is a member of the set obtained by converting the optional value `o` to a finite set" is equivalent to the statement "element `a` is present in the optional value `o`".

For any type `α`, element `a` of `α`, and optional value `o` of type `option α`, `a ∈ set o` if and only if `a = some a' ∈ o` for some `a'`.


theorem CategoryTheory.Limits.limMap_π_assoc :
    ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] {C : Type u} [inst_1 : CategoryTheory.Category.{v, u} C]
      {F G : CategoryTheory.Functor J C} [inst_2 : CategoryTheory.Limits.HasLimit F]
      [inst_3 : CategoryTheory.Limits.HasLimit G] (α : F ⟶ G) (j : J) {Z : C} (h : G.obj j ⟶ Z),
      CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.limMap α)
          (CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.limit.π G j) h) =
        CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.limit.π F j)
          (CategoryTheory.CategoryStruct.comp (α.app j) h) :=
  by sorry

The theorem `CategoryTheory.Limits.limMap_π_assoc` states that in the context of a category with objects of type `C` and another category with objects of type `J`, given two functors `F` and `G` from `J` to `C` (both of which are assumed to have limits), a natural transformation `α` from `F` to `G`, an object `j` of `J`, and a morphism `h` from `G.obj j` to an object `Z` in `C`, the composition of the limit mapping of `α` with the composition of the projection from the limit of `G` to `j` and `h` is equal to the composition of the projection from the limit of `F` to `j` with the composition of the `j` component of `α` and `h`. In mathematical terms, this theorem establishes the commutativity of the given diagram in the category `C`.

In a category with limits, given functors F and G from J to C, a natural transformation α from F to G, an object j of J, and a morphism h from G(j) to Z in C, the diagram commutes: limit(F)→j→G(j)→Z = limit(F)→j→F(j)→Z → G(j)→Z.


theorem derivWithin_zero_of_not_differentiableWithinAt :
    ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {F : Type v} [inst_1 : NormedAddCommGroup F]
      [inst_2 : NormedSpace 𝕜 F] {f : 𝕜 → F} {x : 𝕜} {s : Set 𝕜},
      ¬DifferentiableWithinAt 𝕜 f s x → derivWithin f s x = 0 :=
  by sorry

The theorem `derivWithin_zero_of_not_differentiableWithinAt` asserts that for any type `𝕜` which is a nontrivially normed field, any type `F` which is a normed add commutative group over this field, any function `f` from `𝕜` to `F`, any point `x` in `𝕜`, and any set `s` of points in `𝕜`, if the function `f` is not differentiable at the point `x` within the set `s`, then the derivative of `f` at the point `x` within the set `s` is zero. In mathematical terms, this would be equivalent to stating that if a function does not have a derivative at a particular point within a set, then the derivative of the function at that point, considered within the set, is zero.

If a function is not differentiable at a point within a set in a normed add commutative group over a nontrivially normed field, then its derivative at that point within the set is zero.


/-- If `f` is countably generated and `f.HasBasis p s`, then `f` admits a decreasing basis
enumerated by natural numbers such that all sets have the form `s i`. More precisely, there is a
sequence `i n` such that `p (i n)` for all `n` and `s (i n)` is a decreasing sequence of sets which
forms a basis of `f` -/
theorem Filter.HasBasis.exists_antitone_subbasis :
    ∀ {α : Type u_1} {ι' : Sort u_5} {f : Filter α} [h : Filter.IsCountablyGenerated f] {p : ι' → Prop}
      {s : ι' → Set α},
      Filter.HasBasis f p s → ∃ x, (∀ (i : ℕ), p (x i)) ∧ Filter.HasAntitoneBasis f fun i => s (x i) :=
  by sorry

This theorem asserts that if a filter `f` on a type `α` is countably generated and it has a basis characterized by a predicate `p` over the index set `ι'` where each index maps to a set `s` in `α`, then there exists a sequence `x` indexed by the natural numbers (`i : ℕ`) such that `p (x i)` holds for all `i` and the mapping `i => s (x i)` forms a decreasing (antitone) sequence of sets which constitute a basis for the filter `f`. Here, a filter being countably generated means that its elements can be generated from a countable collection of subsets, and a filter having a basis means there is a collection of sets from which every set in the filter can be generated. The decreasing (antitone) condition implies that if `i ≤ j` then the set at index `j` is a subset of the set at index `i`.

Given a countably generated filter `f` on type `α` with a countable basis characterized by predicate `p` over index set `ι`, there exists a decreasing sequence `x` indexed by natural numbers such that `p (x i)` holds and `{x i} i ∈ ℕ` forms a basis for `f`.


theorem inner_self_nonneg :
    ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
      {x : E}, 0 ≤ RCLike.re ⟪x, x⟫_𝕜 :=
  by sorry

This theorem, named `inner_self_nonneg`, states that for any type `𝕜` that has an `RCLike` structure, and for any `E`, a normed additive commutative group which also forms an inner product space over `𝕜`, the inner product of any element `x` of `E` with itself is always non-negative. Here, `RCLike.re` is a function that maps an element of type `𝕜` to the real number line ℝ. In mathematical terms, the theorem says that for any `x` in `E`, the real component of the inner product of `x` with itself (i.e., ⟨x, x⟩_𝕜) is equal to or greater than 0.

For any normed additive commutative group `E` over a type `𝕜` with an `RCLike` structure, the inner product of any element `x` in `E` with itself is non-negative (i.e., ⟨x, x⟩_𝕜 ≥ 0).