theorem uniformity_eq_comap_nhds_one :
    ∀ (α : Type u_1) [inst : UniformSpace α] [inst_1 : Group α] [inst_2 : UniformGroup α],
      uniformity α = Filter.comap (fun x => x.2 / x.1) (nhds 1) :=
  by sorry

This theorem states that for any type `α` that has a `UniformSpace` structure, a `Group` structure, and a `UniformGroup` structure, the uniformity of `α` (which is a filter on the product `α × α` defined by the uniform space structure) is equal to the filter obtained by applying the `comap` function to the function that takes a pair `x` and returns the result of `x.2 / x.1` (where `x.2` and `x.1` represent the second and first elements of the pair `x` respectively), and the neighborhood filter at `1` (which is a filter formed by the set of all neighborhoods of `1`). The `comap` function in this context is used to pull back the neighborhood filter at `1` along the function that divides the second element of a pair by the first one, to get a new filter on `α × α`.

For any UniformSpace, Group, and UniformGroup type `α`, the uniformity of `α` equals the pullback of the neighborhood filter at `1` through the function `x mapsto x.2 / x.1`.


HasSSubset.SSubset.ne

/-- **Alias** of `ne_of_ssubset`. -/
theorem HasSSubset.SSubset.ne :
    ∀ {α : Type u} [inst : HasSSubset α] [inst_1 : IsIrrefl α fun x x_1 => x ⊂ x_1] {a b : α}, a ⊂ b → a ≠ b := by sorry

This theorem, named `HasSSubset.SSubset.ne`, states that for any type `α` that has a subset structure and respects the property of irreflexivity (meaning that no element is considered a proper subset of itself), if `a` and `b` are elements of `α` such that `a` is a proper subset of `b` (symbolized as `a ⊂ b`), then `a` and `b` must be distinct, i.e., `a` is not equal to `b`.

If `α` is a type with irreflexive subset structure, then for all `a` and `b` in `α`, if `a` is a proper subset of `b` (`a ⊂ b`), then `a ≠ b`.


Multiset.Nodup.map

theorem Multiset.Nodup.map :
    ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {s : Multiset α},
      Function.Injective f → Multiset.Nodup s → Multiset.Nodup (Multiset.map f s) :=
  by sorry

This theorem states that for any types `α` and `β`, any function `f` from `α` to `β`, and any multiset `s` of type `α`, if the function `f` is injective and the multiset `s` has no duplicates (i.e., all elements in `s` are unique), then the multiset obtained by mapping `f` over `s` also has no duplicates. In other words, applying an injective function to a multiset with unique elements results in a new multiset with unique elements.

If `f: α -> β` is an injective function and `s: set α` has no duplicates, then `map f s: set β` also has no duplicates.


theorem MeasureTheory.stronglyMeasurable_zero :
    ∀ {α : Type u_5} {β : Type u_6} {x : MeasurableSpace α} [inst : TopologicalSpace β] [inst_1 : Zero β],
      MeasureTheory.StronglyMeasurable 0 :=
  by sorry

The theorem `MeasureTheory.stronglyMeasurable_zero` states that for any measurable space `α` and any topological space `β` that has a zero element, the zero function, which maps every element of `α` to the zero of `β`, is strongly measurable. Recall that a function is strongly measurable if it is the limit of a sequence of simple functions.

For any measurable space `α` and topological space `β` with a zero element, the zero function from `α` to `β` is strongly measurable, i.e., it is the limit of a sequence of simple functions.


theorem MeasureTheory.Measure.haveLebesgueDecomposition_spec :
    ∀ {α : Type u_1} {m : MeasurableSpace α} (μ ν : MeasureTheory.Measure α)
      [h : MeasureTheory.Measure.HaveLebesgueDecomposition μ ν],
      Measurable (μ.rnDeriv ν) ∧
        MeasureTheory.Measure.MutuallySingular (μ.singularPart ν) ν ∧
          μ = μ.singularPart ν + ν.withDensity (μ.rnDeriv ν) :=
  by sorry

The theorem `MeasureTheory.Measure.haveLebesgueDecomposition_spec` states that for any types `α`, given a measurable space `m` and two measures `μ` and `ν` on that space with the Lebesgue decomposition property, the Radon-Nikodym derivative of `μ` with respect to `ν` is measurable. Furthermore, the singular part of `μ` with respect to `ν` and `ν` themselves are mutually singular. Lastly, `μ` is equal to the sum of its singular part with respect to `ν` and `ν` with the density of the Radon-Nikodym derivative of `μ` with respect to `ν`. In mathematical terms, if `μ` and `ν` are measures with the Lebesgue decomposition property, then `μ = μ_singular + ν * (dμ/dν)`, where `μ_singular` and `ν` are mutually singular, and `dμ/dν` is the Radon-Nikodym derivative of `μ` with respect to `ν`, which is measurable.

Given measurable spaces `(α, Σ, m)` and measures `μ` and `ν` on `α` with the Lebesgue decomposition property, the Radon-Nikodym derivative `dμ/dν` of `μ` with respect to `ν` is measurable, and `μ` is equal to the sum of its singular part `μ_singular` with respect to `ν` and `ν` with the product of `ν` and the Radon-Nikodym derivative `dμ/dν`. That is, `μ = μ_singular + ν * (dμ/dν)`, where `μ_singular` and `ν` are mutually singular.


/-- The diagram `K.homology i ⟶ K.opcycles i ⟶ K.cycles j ⟶ K.homology j` is exact
when `c.Rel i j`.  -/
theorem HomologicalComplex.HomologySequence.composableArrows₃_exact :
    ∀ {C : Type u_1} {ι : Type u_2} [inst : CategoryTheory.Category.{u_3, u_1} C]
      [inst_1 : CategoryTheory.Preadditive C] {c : ComplexShape ι} (K : HomologicalComplex C c) (i j : ι),
      c.Rel i j →
        ∀ [inst_2 : CategoryTheory.CategoryWithHomology C],
          CategoryTheory.ComposableArrows.Exact (HomologicalComplex.HomologySequence.composableArrows₃ K i j) :=
  by sorry

This theorem states that for any given complex shape `c`, homological complex `K`, and indices `i` and `j` in the complex shape, if a relation `c.Rel` exists between `i` and `j`, then the sequence of mappings `K.homology i ⟶ K.opcycles i ⟶ K.cycles j ⟶ K.homology j` is exact in the context of a category with homology. Here, "exact" refers to the property of a sequence in category theory where the image of one morphism equals the kernel of the next.

For any complex shape `c` and homological complex `K`, if `i` and `j` are indices with a relation `c.Rel` between them, then the sequence of homomorphisms from `K.homology i` to `K.opcycles i` to `K.cycles j` to `K.homology j` forms an exact sequence in the category of homology groups.


theorem Filter.map₂_pure_right :
    ∀ {α : Type u_1} {β : Type u_3} {γ : Type u_5} {m : α → β → γ} {f : Filter α} {b : β},
      Filter.map₂ m f (pure b) = Filter.map (fun x => m x b) f :=
  by sorry

The theorem `Filter.map₂_pure_right` asserts that for any types `α`, `β`, and `γ`, a binary function `m : α → β → γ`, a filter `f` on type `α`, and a value `b` of type `β`, the image of the binary function `m` applied to the filter `f` and the pure filter containing only `b` is equivalent to the image of the function `m x b` applied to the filter `f`. In mathematical terms, this theorem demonstrates a kind of "compatability" between the binary function and the filter map with the special case of a pure filter.

For any type `α`, filter `f` on `α`, function `m : α -> beta -> gamma`, and value `b` of type `β`, the image of `m` applied to `f` and the pure filter at `b` is equal to the image of `m x b` applied to `f`.


theorem nhds_eq_order :
    ∀ {α : Type u} [inst : TopologicalSpace α] [inst_1 : Preorder α] [t : OrderTopology α] (a : α),
      nhds a = (⨅ b ∈ Set.Iio a, Filter.principal (Set.Ioi b)) ⊓ ⨅ b ∈ Set.Ioi a, Filter.principal (Set.Iio b) :=
  by sorry

The theorem `nhds_eq_order` states that for any type `α`, where `α` is given a topological space structure, a preorder structure, and an order topology, for any element `a` in `α`, the neighborhood filter at `a` is equal to the infimum of the principal filters of the right-open left-infinite interval for every element less than `a` intersected with the infimum of the principal filters of the left-open right-infinite interval for every element greater than `a`. In simpler terms, this theorem describes how the neighborhoods of a point in an ordered topological space can be constructed from intervals that are open to the right and contain all smaller elements, and intervals that are open to the left and contain all larger elements.

The neighborhood filter of an element in an ordered topological space is equal to the infimum of the principal filters of right-open, left-infinite intervals containing smaller elements, intersected with the infimum of the principal filters of left-open, right-infinite intervals containing larger elements.


theorem linearIndependent_equiv :
    ∀ {ι : Type u'} {ι' : Type u_1} {R : Type u_2} {M : Type u_4} [inst : Semiring R] [inst_1 : AddCommMonoid M]
      [inst_2 : Module R M] (e : ι ≃ ι') {f : ι' → M}, LinearIndependent R (f ∘ ⇑e) ↔ LinearIndependent R f :=
  by sorry

The theorem `linearIndependent_equiv` asserts that for any two types `ι` and `ι'`, a type `R` that is a semiring, a type `M` that is an additive commutative monoid and a module over `R`, and an equivalence `e` between `ι` and `ι'`, the family of vectors `f` is linearly independent over `R` if and only if the family of vectors obtained by applying `f` after the map induced by `e` is also linearly independent over `R`. This means that the linear independence of a family of vectors is preserved under the re-indexing of the basis vectors.

Given types `ι` and `ι'`, a semiring `R`, an additive commutative monoid and `R`-module `M`, and an equivalence `e` between `ι` and `ι'`, the family `{x_i : M | i ∈ ι}` is linearly independent over `R` if and only if the family `{x_i' : M | i' = e(i) for i ∈ ι}` is linearly independent over `R`.


theorem iInf_and :
    ∀ {α : Type u_1} [inst : CompleteLattice α] {p q : Prop} {s : p ∧ q → α}, iInf s = ⨅ (h₁ : p), ⨅ (h₂ : q), s ⋯ := by
  sorry

This theorem states that for any type `α` that forms a complete lattice, and for any propositions `p` and `q`, the indexed infimum (i.e., the greatest lower bound) of a function `s` that maps from the conjunction `p ∧ q` to `α` is equal to the infimum over `h₁` in `p` and `h₂` in `q` of `s`. In other words, it describes taking the infimum first over all truth assignments that make `p` true, and then over all truth assignments that make `q` true, and this gives the same result as taking the infimum directly over all truth assignments that make both `p` and `q` true.

For any complete lattice `α` and propositions `p` and `q`, the infimum of a function `s` from `p ∧ q` to `α` equals the infimum over `h₁ in p` and `h₂ in q` of `s(h₁, h₂)`.


theorem Filter.ext_iff : ∀ {α : Type u} {f g : Filter α}, f = g ↔ ∀ (s : Set α), s ∈ f ↔ s ∈ g := by sorry

The theorem `Filter.ext_iff` states the following: for any type `α` and any two filters `f` and `g` over `α`, `f` is equal to `g` if and only if for every set `s` of type `α`, `s` is in `f` if and only if `s` is in `g`. In other words, two filters are considered equal if they contain exactly the same sets.

Two filters over a type `α` are equal if and only if they contain the same sets.


theorem Filter.tendsto_neg_atTop_atBot :
    ∀ {β : Type u_4} [inst : OrderedAddCommGroup β], Filter.Tendsto Neg.neg Filter.atTop Filter.atBot := by sorry

The theorem `Filter.tendsto_neg_atTop_atBot` states that for any type `β` that forms an ordered additive commutative group, the function that maps each element to its negation (denoted by `Neg.neg`) tends to negative infinity (`Filter.atBot`) as the input tends to positive infinity (`Filter.atTop`). In other words, as we take larger and larger values in this group, their negatives become smaller and smaller, approaching negative infinity.

For any ordered additive commutative group type `β`, the function `Neg.neg` tends to `Filter.atBot` as elements approach `Filter.atTop`.


/-- **Alias** of the reverse direction of `nhdsSet_eq_principal_iff`. -/
theorem IsOpen.nhdsSet_eq :
    ∀ {X : Type u_1} [inst : TopologicalSpace X] {s : Set X}, IsOpen s → nhdsSet s = Filter.principal s := by sorry

This theorem, known as an alias of the reverse direction of `nhdsSet_eq_principal_iff`, states that for any set `s` in a topological space `X`, if `s` is an open set (as defined by `IsOpen`), then the filter of neighborhoods of `s` (as defined by `nhdsSet`) is equal to the principal filter of `s` (as defined by `Filter.principal`). Here, the principal filter of a set is the collection of all its supersets, and the filter of neighborhoods of a set is the supremum over all neighborhoods of the elements of the set in the given topological space.

If a set `s` in a topological space is open, then its filter of neighborhoods equals its principal filter.


theorem inf_inf_sdiff : ∀ {α : Type u} [inst : GeneralizedBooleanAlgebra α] (x y : α), x ⊓ y ⊓ x \ y = ⊥ := by sorry

The theorem `inf_inf_sdiff` states that for any type `α` that forms a Generalized Boolean Algebra, for any two elements of this type, say `x` and `y`, the greatest lower bound (infimum denoted by `⊓`) of `x` and `y` and the set difference of `x` and `y` (`x \ y`) is the bottom element (`⊥`). In simpler terms, it says that if you take the intersection of `x` and `y` and then remove all elements of `y` from `x`, you will end up with an empty set.

For any type `α` that forms a Generalized Boolean Algebra, `x` and `y` being elements of `α`, `x ⊓ (x \ y) = ⊥`.


theorem Set.union_eq_self_of_subset_right : ∀ {α : Type u} {s t : Set α}, t ⊆ s → s ∪ t = s := by sorry

The theorem `Set.union_eq_self_of_subset_right` states that for all types `α` and for any two sets `s` and `t` of type `α`, if `t` is a subset of `s`, then the union of `s` and `t` is equal to `s`. This means that adding all elements from `t` to `s` does not change the set `s`, which is a direct consequence of the fact that all elements of `t` are already in `s` because `t` is a subset of `s`.

For all types `α` and sets `s` and `t` of type `α`, if `t` is a subset of `s`, then `s = s ∪ t`.


theorem List.length_rotate : ∀ {α : Type u} (l : List α) (n : ℕ), List.length (List.rotate l n) = List.length l := by
  sorry

This theorem states that for any list `l` of elements of some type `α` and any natural number `n`, the length of the list obtained by rotating `l` to the left by `n` positions is equal to the length of the original list `l`. In other words, performing a left rotation operation on a list doesn't change its length. This holds for any type `α` and any list `l` of that type.

For any list `l` of length `n` and any natural number `n`, the length of the left rotated list `l.rotated n` is equal to `n`.


theorem Nat.le_of_succ_le : ∀ {n m : ℕ}, Nat.succ n ≤ m → n ≤ m := by sorry

This theorem states that for any two natural numbers `n` and `m`, if the successor of `n` (which is `n + 1`) is less than or equal to `m`, then `n` is also less than or equal to `m`. In other words, if `n + 1 ≤ m`, then it must be the case that `n ≤ m`. This is a basic property of natural numbers and order relations.


theorem Fin.castSucc_lt_iff_succ_le : ∀ {n : ℕ} {i : Fin n} {j : Fin (n + 1)}, Fin.castSucc i < j ↔ Fin.succ i ≤ j := by
  sorry

This theorem, `Fin.castSucc_lt_iff_succ_le`, states that for any natural number `n` and for any elements `i` from the Finset `Fin n` and `j` from the Finset `Fin (n + 1)`, the function `Fin.castSucc i` is less than `j` if and only if `Fin.succ i` is less than or equal to `j`. In other words, it's comparing the ordering relations after applying the `castSucc` and `succ` functions to `i`, in the context of the specific finite sets that `i` and `j` belong to.

For any natural numbers `n`, `i ∈ Fin n`, and `j ∈ Fin (n + 1)`, `Fin.castSucc i < j` if and only if `Fin.succ i ≤ j`.


theorem Complex.conj_eq_iff_re : ∀ {z : ℂ}, (starRingEnd ℂ) z = z ↔ ↑z.re = z := by sorry

This theorem, named `Complex.conj_eq_iff_re`, states that for any given complex number `z`, the conjugate of `z` is equal to `z` if and only if `z` is equal to its real part. Here, `starRingEnd ℂ` represents the conjugate of a complex number, and `↑z.re` represents the real part of `z`. Consequently, this theorem essentially says that a complex number is equal to its conjugate (meaning that its imaginary part is zero) if and only if it is a real number.

A complex number is equal to its conjugate if and only if it is a real number. (equivalently, a complex number z has zero imaginary part if and only if z = ↑z.re)


Matroid.Basis.subset

theorem Matroid.Basis.subset : ∀ {α : Type u_1} {M : Matroid α} {I X : Set α}, M.Basis I X → I ⊆ X := by sorry

This theorem states that for any type `α`, any matroid `M` over `α`, and any sets `I` and `X` of elements of type `α`, if `I` is a basis of `X` in `M`, then `I` is a subset of `X`. In other words, every element in the basis `I` is also an element in the set `X`.

For any matroid M over type α and any sets I (a basis of X in M) and X of elements of α, I is a subset of X.


theorem MvPolynomial.constantCoeff_X :
    ∀ (R : Type u) {σ : Type u_1} [inst : CommSemiring R] (i : σ), MvPolynomial.constantCoeff (MvPolynomial.X i) = 0 :=
  by sorry

This theorem states that for any commutative semiring `R` and any type `σ`, the constant coefficient of the degree `1` monomial $X_i$ is `0`. In other words, if you retrieve the constant term (the coefficient of the 0th degree term) from the polynomial representing the `i`th variable in a multivariate polynomial over a commutative semiring, it will always be `0`.

For any commutative semiring `R` and type `σ`, the constant term of the polynomial representing the `i`th variable in a multivariate polynomial over `R` is `0`.


theorem Complex.sin_periodic : Function.Periodic Complex.sin (2 * ↑Real.pi) := by sorry

This theorem states that the complex sine function is periodic with a period of `2 * π`. In other words, for any complex number `z`, the value of `sin(z + 2π)` is equal to `sin(z)`. Here, `π` is defined as `3.14159265...`, which is twice a zero of the cosine function in the interval `[1,2]`. The periodic nature of the complex sine function is a fundamental property in complex analysis and trigonometry.

The complex sine function is periodic with a period of 2π, i.e., sin(z + 2π) = sin(z) for all complex numbers z.


theorem Complex.sin_ofReal_im : ∀ (x : ℝ), (Complex.sin ↑x).im = 0 := by sorry

This theorem states that the imaginary part of the complex sine of a real number is always zero. In other words, if `x` is any real number, and we compute the sine of `x` in the complex plane, the result is a complex number whose imaginary part is zero. In mathematical notation, this is essentially saying that $\Im(\sin(x)) = 0$ for all real numbers $x$.

The imaginary part of the complex sine function is zero for all real numbers. In mathematical notation, $\Im(\sin(x)) = 0$ for all $x \in \mathbb{R}$.


/-- **Alias** of `Left.neg_le_self`. -/
theorem neg_le_self :
    ∀ {α : Type u} [inst : AddGroup α] [inst_1 : Preorder α]
      [inst_2 : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] {a : α}, 0 ≤ a → -a ≤ a :=
  by sorry

This theorem, referred to as `neg_le_self`, states that for any type `α` which is an additive group and has a preorder relation that is covariant with addition, if `0` is less than or equal to a particular `a` of type `α`, then the negation of `a` is less than or equal to `a`. In other words, for any element `a` in such a structure, if `a` is non-negative, its negative or opposite is always less than or equal to `a`.

For any additive group `α` with a covariant preorder relation and any `a` in `α` such that `0 ≤ a`, we have `-a ≤ a`.


theorem Set.forall_insert_of_forall :
    ∀ {α : Type u} {P : α → Prop} {a : α} {s : Set α}, (∀ x ∈ s, P x) → P a → ∀ x ∈ insert a s, P x := by sorry

This theorem states that for any type `α`, any property `P` of type `α → Prop`, any element `a` of type `α`, and any set `s` of type `Set α`, if every element `x` in `s` satisfies the property `P`, and the element `a` also satisfies `P`, then every element `x` in the set that results from inserting `a` into `s` also satisfies `P`. In other words, if all elements of a set and an additional element adhere to a certain property, then all elements of the updated set containing the additional element also adhere to the same property.

If `α` is a type, `P` is a property of type `α → Prop`, `a : α`, and `s : Set α` are such that `∀ x ∈ s, P x` and `P a`, then `P (mem s a)`. (This states that if every element of a set `s` has property `P` and `a` also has property `P`, then the inserted element `mem s a` also has property `P`.)


theorem MeasureTheory.upperCrossingTime_le :
    ∀ {Ω : Type u_1} {ι : Type u_2} [inst : ConditionallyCompleteLinearOrderBot ι] {a b : ℝ} {f : ι → Ω → ℝ} {N : ι}
      {n : ℕ} {ω : Ω}, MeasureTheory.upperCrossingTime a b f N n ω ≤ N :=
  by sorry

This theorem states that for any types Ω and ι, where ι is a conditionally complete linear order with a minimum element, given any two real numbers `a` and `b`, a function `f` mapping from ι × Ω to ℝ, a specific value `N` of type ι, a natural number `n`, and a specific value `ω` of type Ω, the upper crossing time of `f` at heights `a` and `b` with respect to `N`, `n`, and `ω` is always less than or equal to `N`. The upper crossing time is a concept from measure theory, indicating how much time a stochastic process spends above a certain level.

For any type Ω with a minimum element, any conditionally complete linear order ι, any real-valued function f on ι × Ω, any value N ∈ ι, natural number n, and value ω ∈ Ω, the upper crossing time of f at heights a and b with respect to N, n, and ω is always less than or equal to N.


/-- For a function `f` and a measurable set `s`, the integral of `indicator s f`
over the whole space is equal to `∫ x in s, f x ∂μ` defined as `∫ x, f x ∂(μ.restrict s)`.  -/
theorem MeasureTheory.integral_indicator :
    ∀ {X : Type u_1} {E : Type u_3} [inst : MeasurableSpace X] [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace ℝ E] {f : X → E} {s : Set X} {μ : MeasureTheory.Measure X},
      MeasurableSet s → ∫ (x : X), Set.indicator s f x ∂μ = ∫ (x : X) in s, f x ∂μ :=
  by sorry

This theorem, `MeasureTheory.integral_indicator`, states that for any given function `f` from a set `X` to a normed additive commutative group `E`, and any measurable set `s` of `X` with respect to a measure `μ`, if `s` is a measurable set, then the integral of the indicator function of `s` with respect to `f` over the entire set `X` is equal to the integral of `f` over the set `s` restricted by `μ`. In mathematical terms, this is saying that $\int_X 1_s(x) f(x) dμ = \int_s f(x) dμ$, where $1_s$ is the indicator function of `s`.

For any measurable set `s` in the measurable space `(X, μ)` and any integrable function `f` from `X` to a normed additive commutative group `E`, $\int\_X 1\_s(x) f(x) d\mu = \int\_s f(x) d\mu$, where $1\_s$ is the indicator function of `s`.


theorem tsub_lt_iff_left :
    ∀ {α : Type u_1} [inst : AddCommSemigroup α] [inst_1 : PartialOrder α] [inst_2 : ExistsAddOfLE α]
      [inst_3 : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] [inst_4 : Sub α] [inst_5 : OrderedSub α]
      {a b c : α} [inst_6 : ContravariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1],
      b ≤ a → (a - b < c ↔ a < b + c) :=
  by sorry

This theorem states that for any type `α` that has the structure of an additive commutative semigroup, a partial order, an addition operation for elements that satisfy the less than or equals relation, a subtract operation, and an ordered subtract operation, and also satisfies the covariant and contravariant properties, if `b` is less than or equal to `a`, then `a - b` is less than `c` if and only if `a` is less than `b + c`.

For any additive commutative semigroup `α` with a partial order and ordered subtraction satisfying covariant and contravariant properties, if `a ≤ b` and `b + c`, then `a ≤ c + b`.


theorem Int.emod_def : ∀ (a b : ℤ), a % b = a - b * (a / b) := by sorry

This theorem states that for all integer values `a` and `b`, the modulus operation `a % b` is equivalent to the operation `a - b * (a / b)`. In other words, the remainder of the division of `a` by `b` is the same as `a` minus the product of `b` and the integer quotient of `a` divided by `b`.

For all integers `a` and `b`, `a % b` equals `a - b * (a \ dividedBy b)`. (In mathematical notation: `a % b = a - b * (a \ div b)`)


theorem TensorProduct.tmul_add :
    ∀ {R : Type u_1} [inst : CommSemiring R] {M : Type u_4} {N : Type u_5} [inst_1 : AddCommMonoid M]
      [inst_2 : AddCommMonoid N] [inst_3 : Module R M] [inst_4 : Module R N] (m : M) (n₁ n₂ : N),
      m ⊗ₜ[R] (n₁ + n₂) = m ⊗ₜ[R] n₁ + m ⊗ₜ[R] n₂ :=
  by sorry

This theorem states that for any commutative semiring `R`, any module `M` over `R`, any module `N` over `R`, and any elements `m` in `M` and `n₁`, `n₂` in `N`, the tensor product of `m` with the sum of `n₁` and `n₂` is equal to the sum of the tensor product of `m` with `n₁` and the tensor product of `m` with `n₂`. This is a statement of the distributive property in the context of tensor products.

For any commutative semiring R, modules M and N, and elements m in M and n₁, n₂ in N, the tensor product m ⊗ (n₁ + n₂) is equal to the sum of the tensor products m ⊗ n₁ and m ⊗ n₂.


theorem Matrix.smul_mul :
    ∀ {l : Type u_1} {m : Type u_2} {n : Type u_3} {R : Type u_7} {α : Type v} [inst : AddCommMonoid α] [inst_1 : Mul α]
      [inst_2 : Fintype n] [inst_3 : Monoid R] [inst_4 : DistribMulAction R α] [inst_5 : IsScalarTower R α α] (a : R)
      (M : Matrix m n α) (N : Matrix n l α), a • M * N = a • (M * N) :=
  by sorry

The theorem `Matrix.smul_mul` states that for any types `l`, `m`, `n`, `R`, `α` and given a commutative additive monoid `α` with multiplication, where `n` is a finite type, `R` is a monoid, and `α` is a `R`-module with multiplication distributing over scalar multiplication, then scalar multiplication is compatible with matrix multiplication. In other words, for any scalar `a` from `R`, and any two matrices `M` and `N` with elements from `α`, where `M`'s columns index type is same as `N`'s rows index type, the operation of scaling `M` by `a` and then multiplying by `N` is the same as the operation of multiplying `M` by `N` first and then scaling the result by `a`. This can be mathematically expressed as `a • (M * N) = a • M * N`.

For any commutative monoid `R`, `α` being an `R`-module with multiplication distributing over scalar multiplication, and `M` and `N` being matrices with compatible dimensions over `α`, we have `a * (M * N) = a * M * N` for any scalar `a` in `R`.


theorem Polynomial.leadingCoeff_add_of_degree_lt :
    ∀ {R : Type u} [inst : Semiring R] {p q : Polynomial R},
      Polynomial.degree p < Polynomial.degree q → Polynomial.leadingCoeff (p + q) = Polynomial.leadingCoeff q :=
  by sorry

The theorem `Polynomial.leadingCoeff_add_of_degree_lt` states that for any semiring `R` and any two polynomials `p` and `q` over `R`, if the degree of `p` is less than the degree of `q`, then the leading coefficient of the sum of `p` and `q` is the same as the leading coefficient of `q`. In other words, when adding two polynomials, if one polynomial has a lower degree than the other, the leading coefficient of the result is not affected by the lower degree polynomial.

If `p` and `q` are polynomials over a semiring `R` with `deg p < deg q`, then the leading coefficient of `p + q` equals the leading coefficient of `q`.


theorem zero_ne_one' : ∀ (α : Type u_2) [inst : Zero α] [inst_1 : One α] [inst_2 : NeZero 1], 0 ≠ 1 := by sorry

This theorem states that for any type `α` that has both zero and one elements and satisfies the property that one is not zero (signified by the `NeZero 1` instance), zero is not equal to one. This is generally applied to numeric types where the concepts of zero and one are well-defined, such as integers, real numbers, complex numbers, etc.

For any type `α` with zero and one elements where one is not zero, zero is not equal to one. (In other words, `0 ≠ 1` for types `α` with `0` and `1` and `NeZero 1 α`.)


Ideal.IsPrime.isMaximal

theorem Ideal.IsPrime.isMaximal :
    ∀ {R : Type u_4} [inst : CommRing R] [inst_1 : Ring.DimensionLEOne R] {p : Ideal R},
      Ideal.IsPrime p → p ≠ ⊥ → Ideal.IsMaximal p :=
  by sorry

This theorem states that for a given type `R` which forms a commutative ring and has dimension less than or equal to one, if `p` is a prime ideal and it is not the bottom element (the smallest ideal, usually `{0}`), then `p` is a maximal ideal. In the language of ring theory, a prime ideal of a commutative, one-dimensional ring that is not the zero ideal is necessarily a maximal ideal.

In a one-dimensional commutative ring `R` with unit, a prime ideal `p` different from the bottom ideal is a maximal ideal.


theorem Mathlib.Data.Nat.PrimeFin._auxLemma.4 : ∀ {n p : ℕ}, (p ∈ n.primeFactors) = (Nat.Prime p ∧ p ∣ n ∧ n ≠ 0) := by
  sorry

The theorem `Mathlib.Data.Nat.PrimeFin._auxLemma.4` states that for any two natural numbers `n` and `p`, `p` is a part of the prime factors of `n` if and only if three conditions are met: `p` is a prime number, `p` divides `n` without leaving a remainder, and `n` is not equal to zero.

A natural number `p` is a prime factor of another natural number `n` if and only if `p` is a prime number, `p` divides `n`, and `n` is non-zero.


ContinuousAt.congr

theorem ContinuousAt.congr :
    ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {f : X → Y} {x : X}
      {g : X → Y}, ContinuousAt f x → f =ᶠ[nhds x] g → ContinuousAt g x :=
  by sorry

The theorem `ContinuousAt.congr` states that for any two functions `f` and `g` from a topological space `X` to a topological space `Y`, and any point `x` in `X`, if `f` is continuous at `x` and `g` is equal to `f` in a neighborhood of `x` (represented by the filter `nhds x`), then `g` is also continuous at `x`. Essentially, it says that if two functions coincide in a neighborhood of a point, and one of them is continuous at that point, then the other is too.

If a function `f` is continuous at a point `x` in a topological space `X` and `f` equals `g` in a neighborhood of `x`, then `g` is also continuous at `x` in `X` to `Y`.


theorem hasSum_le :
    ∀ {ι : Type u_1} {α : Type u_3} [inst : OrderedAddCommMonoid α] [inst_1 : TopologicalSpace α]
      [inst_2 : OrderClosedTopology α] {f g : ι → α} {a₁ a₂ : α},
      (∀ (i : ι), f i ≤ g i) → HasSum f a₁ → HasSum g a₂ → a₁ ≤ a₂ :=
  by sorry

This theorem states that for any types `ι` and `α`, where `α` is an ordered additive commutative monoid with a topological space structure and its order topology is closed, given two functions `f` and `g` from `ι` to `α` and two elements `a₁` and `a₂` in `α`, if for every `i` in `ι` the value of `f` at `i` is less than or equal to the value of `g` at `i`, and `f` has a sum `a₁` and `g` has a sum `a₂`, then `a₁` is less than or equal to `a₂`. In simpler terms, if each term in the sequence generated by `f` is less than or equal to the corresponding term in the sequence generated by `g`, and the sums of these sequences are `a₁` and `a₂` respectively, then the sum `a₁` is less than or equal to the sum `a₂`.

Given functions `f` and `g` from a type `ι` to an ordered additive commutative monoid `α` with a closed order topology, if for all `i` in `ι`, `f i ≤ gi` and `Σ i, fi = a₁` and `Σ i, gi = a₂`, then `a₁ ≤ a₂`.


theorem MeasurableSet.of_compl :
    ∀ {α : Type u_1} {s : Set α} {m : MeasurableSpace α}, MeasurableSet sᶜ → MeasurableSet s := by sorry

This theorem states that for any type `α`, any set `s` of type `α`, and any measure space `m` on `α`, if the complement of the set `s` (denoted as `sᶜ`) is a measurable set, then the set `s` itself is also a measurable set. In mathematical terms, if a set's complement is measurable in a given measure space, then the set itself is measurable in that measure space.

If a set's complement is measurable in a given measure space, then the set is measurable.


theorem Filter.HasCountableBasis.isCountablyGenerated :
    ∀ {α : Type u_1} {ι : Type u_4} {f : Filter α} {p : ι → Prop} {s : ι → Set α},
      Filter.HasCountableBasis f p s → Filter.IsCountablyGenerated f :=
  by sorry

This theorem states that for any type `α` and `ι`, and for any filter `f` of the type `α` and predicate `p` and function `s` from `ι` to the set of `α`, if the filter `f` has a countable basis defined by predicate `p` and function `s`, then the filter `f` is countably generated. Here, a countable basis of a filter means a countable collection of sets that the filter is built from, and a countably generated filter means a filter that is generated from a countable collection of sets.

If a filter on type `α` has a countable basis defined by a predicate and a function from a countable type, then the filter is countably generated.


PEquiv.ext

theorem PEquiv.ext : ∀ {α : Type u} {β : Type v} {f g : α ≃. β}, (∀ (x : α), f x = g x) → f = g := by sorry

This theorem, `PEquiv.ext`, states that for any two partial equivalences `f` and `g` between two types `α` and `β`, if for every element `x` of type `α`, `f` applied to `x` is equal to `g` applied to `x`, then `f` and `g` are indeed the same partial equivalence. In other words, two partial equivalences are identical if they yield the same result for every input from their domain.

If two partial equivalences between types `α` and `β` agree on every element from their domain, then they are equal as partial equivalences.


theorem Order.min_of_le_pred :
    ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : PredOrder α] {a : α}, a ≤ Order.pred a → IsMin a := by sorry

This theorem states that for any type `α` that has a preordering and predorder structure, if an element `a` of type `α` is less than or equal to its predecessor, then `a` is a minimal element of `α`. Here, an element is said to be minimal if there is no element strictly less than it. The predecessor of an element `a` is the greatest element less than `a` if `a` is not minimal; if `a` is minimal, then its predecessor is `a` itself.

If `α` is a type with a preordering and `a` is an element of `α` such that `a` is less than or equal to its predecessor, then `a` is a minimal element of `α`.


theorem mul_lt_mul :
    ∀ {α : Type u} [inst : StrictOrderedSemiring α] {a b c d : α}, a < c → b ≤ d → 0 < b → 0 ≤ c → a * b < c * d := by
  sorry

This theorem states that for any type `α` that is a strictly ordered semiring (a mathematical structure with two operations, namely addition and multiplication, where the set is strictly ordered and the operations obey certain properties), given four elements `a`, `b`, `c`, `d` of this type, if `a` is less than `c`, `b` is less than or equal to `d`, `b` is greater than zero, and `c` is greater than or equal to zero, then the product of `a` and `b` is less than the product of `c` and `d`. This is a statement about the interplay of order and multiplication in strictly ordered semirings.

In a strictly ordered semiring, if a ≤ c and b > 0 with d ≥ 0, then a * b < c * d.


Set.OrdConnected.strictConvex

theorem Set.OrdConnected.strictConvex :
    ∀ {𝕜 : Type u_1} {β : Type u_5} [inst : OrderedSemiring 𝕜] [inst_1 : TopologicalSpace β]
      [inst_2 : LinearOrderedCancelAddCommMonoid β] [inst_3 : OrderTopology β] [inst_4 : Module 𝕜 β]
      [inst_5 : OrderedSMul 𝕜 β] {s : Set β}, Set.OrdConnected s → StrictConvex 𝕜 s :=
  by sorry

This theorem states that for any ordered semiring `𝕜` and any type `β` that is a topological space, a linearly ordered cancellative additive commutative monoid, has an order topology, is a module over `𝕜`, and has a scalar multiplication that respects the order, if a set `s` of `β` is order-connected, then `s` is strictly convex in `𝕜`. In other words, if `s` has the property that for any two points in `s`, all points between those two are also in `s`, then `s` is strictly convex meaning that the open line segment between any two distinct points in `s` is contained in the interior of `s`.

Given an ordered semiring `𝕜`, a topological space `β` that is a linearly ordered cancellative additive commutative monoid with an order topology, a `𝕜`-module structure, and respects the order, if `s` is an order-connected subset of `β`, then `s` is strictly convex.


theorem inf_le_inf_right : ∀ {α : Type u} [inst : SemilatticeInf α] (a : α) {b c : α}, b ≤ c → b ⊓ a ≤ c ⊓ a := by sorry

This theorem states that for any type `α` that is a semilattice under the infimum operation (semilattice inf), given any three elements `a`, `b`, `c` of type `α`, if `b` is less than or equal to `c`, then the infimum of `b` and `a` is less than or equal to the infimum of `c` and `a`. This asserts a property of the infimum operation: where the position of a smaller element does not change the outcome when taking the infimum with a fixed other element.

For any semilattice `α` and elements `a, b, c` in `α` with `b ≤ c`, the infimum of `b` and `a` is less than or equal to the infimum of `c` and `a`.


theorem SetLike.coe_mono : ∀ {A : Type u_1} {B : Type u_2} [i : SetLike A B], Monotone SetLike.coe := by sorry

The theorem `SetLike.coe_mono` states that for all types `A` and `B`, where `A` is a `SetLike` of `B`, the function `SetLike.coe` (which is a coercion from a term of `A` to its corresponding `Set`) is monotone. In other words, given a partial order on `A` and `B`, if `a` and `b` are two elements in `A` such that `a ≤ b`, then the corresponding sets obtained by the coercion function from `a` and `b` also satisfy `SetLike.coe a ≤ SetLike.coe b`.

For any type `A` being a `SetLike` of `B` and given a partial order on `A`, if `a ≤ b` in `A`, then `SetLike.coe (a : Set B) ≤ SetLike.coe (b : Set B)` in the lattice of sets.


theorem CategoryTheory.Limits.ι_colimMap_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.HasColimit F]
      [inst_3 : CategoryTheory.Limits.HasColimit G] (α : F ⟶ G) (j : J) {Z : C}
      (h : CategoryTheory.Limits.colimit G ⟶ Z),
      CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.colimit.ι F j)
          (CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.colimMap α) h) =
        CategoryTheory.CategoryStruct.comp (α.app j)
          (CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.colimit.ι G j) h) :=
  by sorry

This theorem states that for any two functors `F` and `G` from a category `J` to a category `C`, if both functors have colimit, and if `α` is a natural transformation from `F` to `G`, then for any object `j` in `J` and any morphism `h` from the colimit of `G` to an object `Z` in `C`, the composition of the coprojection from `j` under `F` to the colimit of `F` with the composition of the mapping of the colimit under `α` and `h` is equal to the composition of the application of `α` at `j` with the composition of the coprojection from `j` under `G` to the colimit of `G` and `h`.

In simpler terms, it ensures that mapping the colimit respects the structure of the category, specifically related to the composition of morphisms, in the scenario when we are dealing with two functors and a natural transformation between them.

 For any functors F and G from a category J to a category C with colimits, and any natural transformation α from F to G, the diagram commutes:

colim(F)(j) ⟶ colim(F) ⟶ Z ⟶ colim(G)(j) ⟶ Z

where j is an object in J, h is a morphism from colim(G) to Z, and the arrows represent the coprojections, α, and h.


theorem Nat.add_one : ∀ (n : ℕ), n + 1 = Nat.succ n := by sorry

This theorem states that for any natural number `n`, adding 1 to `n` is equivalent to obtaining the successor of `n` in the natural numbers. In other words, for any given natural number, the operation of addition by 1 yields the same result as the operation of obtaining the subsequent number.

For any natural number `n`, `n + 1` is equal to the successor of `n`.


theorem Quot.EqvGen_sound : ∀ {α : Type u} {r : α → α → Prop} {a b : α}, EqvGen r a b → Quot.mk r a = Quot.mk r b := by
  sorry

The theorem `Quot.EqvGen_sound` states that for any type `α` and any relation `r` on `α`, and for any elements `a` and `b` of type `α`, if `a` and `b` generate an equivalence relation under `r` (denoted as `EqvGen r a b`), then the quotient of `a` and `b` with respect to the relation `r` are equal. This theorem can be interpreted as saying that the process of forming quotients respects the generation of equivalence relations.

If `a` and `b` generate an equivalence relation `r` on type `α` such that `a R b`, then the quotients `a / r` and `b / r` are equal.


theorem Complex.abs_exp : ∀ (z : ℂ), Complex.abs (Complex.exp z) = Real.exp z.re := by sorry

This theorem states that for every complex number `z`, the absolute value of the exponential of `z` is equal to the real exponential of the real part of `z`. In other words, if we calculate the exponential function of a complex number and then take its absolute value, the result is the same as if we had taken the real part of the complex number and computed the real exponential of that. This is formulated mathematically as `|e^z| = e^Re(z)` for all complex numbers `z`.

The absolute value of the complex exponential function equals the real exponential of the real part for all complex numbers: |e^z| = e^(Re(z)).


/-- Closed balls are bounded  -/
theorem Metric.isBounded_closedBall :
    ∀ {α : Type u} [inst : PseudoMetricSpace α] {x : α} {r : ℝ}, Bornology.IsBounded (Metric.closedBall x r) := by sorry

This theorem states that for any pseudometric space, given any point `x` in the space and any real number `r`, the closed ball centered at `x` with radius `r` is a bounded set. Here, a closed ball is defined as the set of all points `y` such that the distance from `y` to `x` is less than or equal to `r`. A set is considered bounded relative to the ambient bornology if its complement is cobounded.

For any pseudometric space and point `x` in it, the closed ball centered at `x` with radius `r` is a bounded set. (A set is bounded if its complement is cobounded in the ambient topology.)


ContinuousMap.Homotopic.refl

theorem ContinuousMap.Homotopic.refl :
    ∀ {X : Type u} {Y : Type v} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] (f : C(X, Y)),
      ContinuousMap.Homotopic f f :=
  by sorry

This theorem states that for any continuous map `f` from a topological space `X` to another topological space `Y`, the map `f` is homotopic to itself. In other words, there exists a continuous transformation (or homotopy) from the function `f` to itself within the same topological spaces. This is an application of the reflexive property of homotopy in continuous mapping.

Every continuous function from a topological space to itself is homotopic to itself.


theorem Finset.sdiff_union_of_subset :
    ∀ {α : Type u_1} [inst : DecidableEq α] {s₁ s₂ : Finset α}, s₁ ⊆ s₂ → s₂ \ s₁ ∪ s₁ = s₂ := by sorry

The theorem `Finset.sdiff_union_of_subset` states that for any type `α` with decidable equality, and for any two finite sets `s₁` and `s₂` of type `α`, if `s₁` is a subset of `s₂`, then the union of the set difference `s₂ \ s₁` and `s₁` is equal to `s₂`. In mathematical terms, if $s₁$ is a subset of $s₂$, then $s₂ \ s₁ \cup s₁ = s₂$.

For any type `α` with decidable equality and finite sets `s₁` and `s₂` of type `α` with `s₁` a subset of `s₂`, we have `s₂ \ s₁ ∪ s₁ = s₂`. In mathematical notation, $s₂ \setminus s₁ \cup s₁ = s₂$.


theorem Quot.out_eq : ∀ {α : Sort u_1} {r : α → α → Prop} (q : Quot r), Quot.mk r (Quot.out q) = q := by sorry

The theorem `Quot.out_eq` states that for any equivalence class `q` over a sort `α` with an equivalence relation `r`, if we choose an element from `q` using the function `Quot.out` and then form a new equivalence class with that chosen element, we get back the original equivalence class `q`. This demonstrates the consistency of the `Quot.out` function with the equivalence class structure.

For any equivalence class `q` and its representative `x` in type `α` with respect to an equivalence relation `r`, `Quot.out (Quot.mk _ x) = q`.


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

The theorem `Set.image2_iUnion_right` states that for all types `α`, `β`, `γ`, and any indexing type `ι`, for any binary function `f` from `α` and `β` to `γ`, any set `s` of type `α`, and any family of sets `t` indexed by `ι` of type `β`, the image under `f` of the set `s` and the union over `ι` of sets `t i` is equal to the union over `i` of the image under `f` of `s` and `t i`. In mathematical terms, this can be expressed as $f(s, \bigcup_i t_i) = \bigcup_i f(s, t_i)$.

For any functions $f: \alpha \times \beta \to \gamma$, sets $s:\alpha$, and a family $t: \ι \to \beta$ of sets, $f(s, \bigcup\_{i \in \ι} t\_i) = \bigcup\_{i \in \ι} f(s, t\_i)$.


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

This theorem, `InnerProductSpace.Core.inner_conj_symm`, states that for any type `𝕜` that behaves like a ring with conjugation, and for any type `F` that behaves like an additive commutative group and is a `𝕜`-module, the inner product of `x` and `y` in an inner product space is equal to the complex conjugate of the inner product of `y` and `x`. Here, `starRingEnd 𝕜` denotes the complex conjugate in the ring `𝕜`. This is a property of inner product spaces in general over the complex numbers.

For any complex ring `𝕜` with conjugation and additive commutative `𝕜`-module `F`, the inner product of `x` and `y` in an inner product space equals the complex conjugate of the inner product of `y` and `x`.


IsOpen.uniqueDiffOn

theorem IsOpen.uniqueDiffOn :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {s : Set E}, IsOpen s → UniqueDiffOn 𝕜 s :=
  by sorry

This theorem states that for any nontrivially normed field `𝕜` and any normed add commutative group `E` that is also a normed space over `𝕜`, if `s` is an open set in `E`, then `s` is uniquely differentiable with respect to `𝕜`. In simpler terms, it says that any open set in a normed space is uniquely differentiable.

For any nontrivially normed field `𝕜` and normed additive group `E` that is also a normed space over `𝕜`, every open set in `E` is uniquely differentiable as a function from `𝕜` to `E`.


theorem OmegaCompletePartialOrder.ContinuousHom.monotone :
    ∀ {α : Type u} {β : Type v} [inst : OmegaCompletePartialOrder α] [inst_1 : OmegaCompletePartialOrder β]
      (f : α →𝒄 β), Monotone ⇑f :=
  by sorry

This theorem states that for any types `α` and `β` that have an instance of `OmegaCompletePartialOrder`, any function `f` from `α` to `β` that is a continuous homomorphism (denoted as `α →𝒄 β`), is a monotone function. In other words, if `a` and `b` are elements of type `α` such that `a` is less than or equal to `b`, then the application of `f` to `a` (denoted as `f a` or `⇑f a`) is less than or equal to the application of `f` to `b` (denoted as `f b` or `⇑f b`).

For any continuous homomorphism between two types with an OmegaCompletePartialOrder structure, the image of a smaller element is less than or equal to the image of a larger element.


theorem isCompact_range :
    ∀ {X : Type u} {Y : Type v} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] [inst_2 : CompactSpace X]
      {f : X → Y}, Continuous f → IsCompact (Set.range f) :=
  by sorry

This theorem asserts that for every two types `X` and `Y` where `X` is a compact space and `Y` is a topological space, if a function `f` maps from `X` to `Y` and is continuous, then the range of `f` (i.e., the set of all the images of elements in `X` under `f`) is compact. In other words, for any nontrivial filter `f` that contains the range of `f`, there exists a point in the range such that every set of `f` intersects every neighborhood of that point. This theorem links the concepts of continuity and compactness, showing that the continuous image of a compact space is also compact.

A continuous function from a compact space to a topological space maps compact sets to compact sets. (The range of a continuous function from a compact space is a compact subset of the target space.)


theorem ENNReal.top_mul : ∀ {a : ENNReal}, a ≠ 0 → ⊤ * a = ⊤ := by sorry

This theorem states that for all values `a` of the type `ENNReal` (which represents the extended nonnegative real numbers, usually denoted as [0, ∞]), if `a` is not equal to 0, then the multiplication of the special value `⊤` (which represents infinity in this context) and `a` equals `⊤`. This essentially mirrors the mathematical concept that multiplying any non-zero real number with infinity yields infinity.

For all `a` in `ENNReal`, `a *= ⊤` equals `⊤` if `a` is non-zero.


theorem Filter.prod_mem_prod :
    ∀ {α : Type u_1} {β : Type u_2} {s : Set α} {t : Set β} {f : Filter α} {g : Filter β},
      s ∈ f → t ∈ g → s ×ˢ t ∈ f ×ˢ g :=
  by sorry

This theorem states that for any types `α` and `β`, and any sets `s` of type `α` and `t` of type `β`, along with filters `f` on `α` and `g` on `β`, if `s` is in `f` and `t` is in `g`, then the Cartesian product of `s` and `t` is in the Cartesian product of `f` and `g`. In other words, it says that the product of two sets is a member of the product of their respective filters if the individual sets are members of their respective filters.

For filters \(f\) on type \(\alpha\) and \(g\) on type \(\beta\), if \(s \in f\) (where \(s\) is a set of type \(\alpha\)) and \(t \in g\) (where \(t\) is a set of type \(\beta\)), then \(s \times t \in f \times g\) (where \(s \times t\) is the Cartesian product of \(s\) and \(t\)).


theorem Function.Periodic.sub_eq' :
    ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {c x : α} [inst : AddCommGroup α],
      Function.Periodic f c → f (c - x) = f (-x) :=
  by sorry

The theorem named `Function.Periodic.sub_eq'` states that, for any types `α` and `β`, and for any function `f` from `α` to `β` and elements `c` and `x` of `α`, if `α` forms an additive commutative group and the function `f` is periodic with period `c`, then the function evaluated at `c - x` equals the function evaluated at `-x`.

For any additive commutative group type `α`, periodic function `f` from `α` to `β`, and elements `c`, `x` of `α`, if `f` has period `c`, then `f(c - x) = f(-x)`.


theorem LinearMap.ext_iff :
    ∀ {R : Type u_1} {S : Type u_6} {M : Type u_9} {M₃ : Type u_12} [inst : Semiring R] [inst_1 : Semiring S]
      [inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid M₃] [inst_4 : Module R M] [inst_5 : Module S M₃] {σ : R →+* S}
      {f g : M →ₛₗ[σ] M₃}, f = g ↔ ∀ (x : M), f x = g x :=
  by sorry

This theorem states that for all semirings `R` and `S`, additive commutative monoids `M` and `M₃`, with `M` and `M₃` being modules over `R` and `S` respectively, and a ring homomorphism `σ` from `R` to `S`, two linear maps `f` and `g` from `M` to `M₃` are equal if and only if they produce the same output for all inputs `x` in `M`. In other words, two linear maps are identical if they behave the same way on all elements of the module `M`.

For all semirings R and S, additive commutative monoids M and M₃, and ring homomorphisms σ from R to S, two linear maps f and g from M to M₃ are equal if and only if they agree on all elements of M.


theorem MeasureTheory.Measure.quasiMeasurePreserving_fst :
    ∀ {α : Type u_1} {β : Type u_3} [inst : MeasurableSpace α] [inst_1 : MeasurableSpace β]
      {μ : MeasureTheory.Measure α} {ν : MeasureTheory.Measure β} [inst_2 : MeasureTheory.SFinite ν],
      MeasureTheory.Measure.QuasiMeasurePreserving Prod.fst (MeasureTheory.Measure.prod μ ν) μ :=
  by sorry

The theorem `MeasureTheory.Measure.quasiMeasurePreserving_fst` states that for any two types `α` and `β` with associated measurable spaces, and for any given measures `μ` and `ν` on `α` and `β` respectively, where `ν` is s-finite (i.e., it can be approximated by a finite measure), the function `Prod.fst` which gives the first projection of a pair, is quasi-measure-preserving. In other words, when we consider the product measure of `μ` and `ν` on the product space `α × β`, projecting this measure onto the `α` part via `Prod.fst` preserves the original measure `μ` on `α`.

Given measurable spaces `(α, Σα, μ)` and `(β, Σβ, ν)` where `ν` is s-finite, the function `Prod.fst : α × β → α` is quasi-measure-preserving with respect to the product measure `μ ⊗ ν` on `(α × β, Σα × Σβ)`.


theorem not_forall_not : ∀ {α : Sort u_2} {p : α → Prop}, (¬∀ (x : α), ¬p x) ↔ ∃ x, p x := by sorry

This theorem, `not_forall_not`, states that for any type `α` and for any property `p` of `α`, the negation of the statement "For all `x` of type `α`, `p` does not hold" is logically equivalent to the existence statement "There exists an `x` of type `α` such that `p` holds". In other words, if it is not the case that `p` fails for all `x`, then there exists some `x` for which `p` is true.

The negation of "for all x in α, not p(x)" is logically equivalent to "there exists x in α such that p(x) holds".


/-- An induction principle for closure membership. If `p` holds for `1` and all elements of `k`, and
is preserved under multiplication and inverse, then `p` holds for all elements of the closure
of `k`.  -/
theorem Subgroup.closure_induction :
    ∀ {G : Type u_1} [inst : Group G] {k : Set G} {p : G → Prop} {x : G},
      x ∈ Subgroup.closure k →
        (∀ x ∈ k, p x) → p 1 → (∀ (x y : G), p x → p y → p (x * y)) → (∀ (x : G), p x → p x⁻¹) → p x :=
  by sorry

This theorem is an induction principle for membership in the closure of a set in a group. If a certain property `p` is satisfied by the identity element `1` and all elements of a set `k`, and `p` is also preserved under group multiplication and taking the inverse, then the property `p` holds for all elements in the closure of the set `k` in the group. In other words, if you start with a subset of elements that satisfy a rule, and that rule is preserved under the operations of the group, then the rule is satisfied by the smallest subgroup containing the subset.

If a property is satisfied by the identity element and all elements of a set in a group, and is preserved under group multiplication and taking inverses, then the property holds for all elements in the closure of the set in the group.


theorem List.take_all_of_le : ∀ {α : Type u_1} {n : ℕ} {l : List α}, List.length l ≤ n → List.take n l = l := by sorry

This theorem states that for any type `α`, any natural number `n`, and any list `l` of type `α`, if the length of the list `l` is less than or equal to `n`, then taking the first `n` elements of `l` results in `l` itself. In other words, if you attempt to take more elements than a list has, you just get the list itself.

For any type `α`, any natural number `n`, and any list `l` of length `|l|` of type `α`, `take n l = l` when `|l| ≤ n`.


theorem NumberField.InfinitePlace.not_isReal_iff_isComplex :
    ∀ {K : Type u_2} [inst : Field K] {w : NumberField.InfinitePlace K},
      ¬NumberField.InfinitePlace.IsReal w ↔ NumberField.InfinitePlace.IsComplex w :=
  by sorry

This theorem states that for any number field `K` and any infinite place `w` of `K`, `w` is not a real place if and only if `w` is a complex place. In other words, an infinite place of a number field cannot be both real and complex at the same time. If it's not real, it's definitely complex and vice versa.

For any number field K and its infinite place w, w is neither real nor complex if and only if it is complex.


theorem tsub_mul :
    ∀ {α : Type u} [inst : CanonicallyOrderedCommSemiring α] [inst_1 : Sub α] [inst_2 : OrderedSub α]
      [inst_3 : IsTotal α fun x x_1 => x ≤ x_1]
      [inst_4 : ContravariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] (a b c : α),
      (a - b) * c = a * c - b * c :=
  by sorry

This theorem states that, for any type `α` that is a canonically ordered commutative semiring and also supports subtraction operation that is ordered, and for any three elements `a`, `b`, and `c` of this type, the operation of subtracting `b` from `a` and then multiplying the result by `c` is equivalent to first multiplying `a` and `b` by `c` and then subtracting the two results. In mathematical notation, this can be written as `(a - b) * c = a * c - b * c`. This can be thought of as a distributive property of multiplication over subtraction in this algebraic structure.

For any commutative semiring `α` with a canonically ordered additive and multiplicative structure and supported subtraction operation, the distribution law holds: `(a - b) * c = a * c - b * c` for all `a, b, c ∈ α`.


theorem Finset.coe_eq_empty : ∀ {α : Type u_1} {s : Finset α}, ↑s = ∅ ↔ s = ∅ := by sorry

This theorem states that for any type `α` and any finite set `s` of type `α`, the coercion of `s` to a set results in the empty set if and only if `s` itself is the empty set. In other words, a finite set in Lean is empty if and only if its set-theoretic counterpart is also empty.

For any type `α`, the coercion of a finite set `s` of type `α` to a set is the empty set if and only if `s` is the empty set.


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

This theorem, named `Left.neg_neg_iff`, states that for any type `α` which is an additive group (`AddGroup α`) and has a less than operation (`LT α`), and wherein addition (`fun x x_1 => x + x_1`) is left-covariant with respect to the less than operation (`fun x x_1 => x < x_1`), a negative value `-a` is less than zero if and only if zero is less than `a`. This theorem uses the left-covariant property and essentially asserts the equivalence of negative values being less than zero and their positive counterparts being greater than zero in the context of an ordered additive group.

For any additive group with a total order where addition is left-covariant with respect to the order, the negation of an element is less than zero if and only if zero is less than the element.


theorem Finsupp.single_eq_zero :
    ∀ {α : Type u_1} {M : Type u_5} [inst : Zero M] {a : α} {b : M}, (fun₀ | a => b) = 0 ↔ b = 0 := by sorry

The theorem `Finsupp.single_eq_zero` states that for any types `α` and `M` with `M` being a type with a zero, and for any elements `a` of type `α` and `b` of type `M`, the function `fun₀` that maps `a` to `b` is equal to zero if and only if `b` is equal to zero. In other words, the function is null only when it maps `a` to the zero element of `M`.

For any types `α` and `M` with `M` having a zero element, and for all `a : α` and `b : M`, the function mapping `a` to `b` is equal to the zero element of `M` if and only if `b` is equal to the zero element of `M`.


/-- An additive isomorphism of additive monoids sends `0` to `0`
(and is hence an additive monoid isomorphism). -/
theorem AddEquiv.map_zero :
    ∀ {M : Type u_6} {N : Type u_7} [inst : AddZeroClass M] [inst_1 : AddZeroClass N] (h : M ≃+ N), h 0 = 0 := by sorry

This theorem states that an additive isomorphism of additive monoids maps the identity element (zero) in the source monoid to the identity element (zero) in the target monoid. In other words, if we have two additive monoids (types `M` and `N` with respective zero property classes), then for any additive isomorphism `h` from `M` to `N`, applying `h` to zero in `M` will always yield zero in `N`.

Given additive monoids M and N and an additive isomorphism h from M to N, h(0\_M) = 0\_N.


theorem Set.mem_compl : ∀ {α : Type u} {s : Set α} {x : α}, x ∉ s → x ∈ sᶜ := by sorry

This theorem states that for any type 'α', any set 's' of type 'α', and any element 'x' of type 'α', if 'x' is not an element of 's', then 'x' is an element of the complement of 's'. Here, the complement of a set 's' (denoted as 'sᶜ' in Lean 4) refers to all elements of type 'α' that are not in 's'.

If x is not an element of set s, then x belongs to the complement of s.


theorem neg_add_eq_sub : ∀ {α : Type u_1} [inst : SubtractionCommMonoid α] (a b : α), -a + b = b - a := by sorry

This theorem states that for any type `α` that has a `SubtractionCommMonoid` instance (that is, a structure where subtraction is a commutative operation), for any two members `a` and `b` of type `α`, the negation of `a` added to `b` is equal to `b` subtracted by `a`. In mathematical terms, for all `a` and `b` in such a structure, `-a + b = b - a`.

For any type `α` with a `SubtractionCommMonoid` structure, subtraction is commutative, that is, `-a + b = b - a` for all `a, b` in `α`.


theorem Set.not_disjoint_iff_nonempty_inter : ∀ {α : Type u} {s t : Set α}, ¬Disjoint s t ↔ Set.Nonempty (s ∩ t) := by
  sorry

The theorem `Set.not_disjoint_iff_nonempty_inter` asserts that for all types `α` and for all sets `s` and `t` of this type, `s` and `t` are not disjoint if and only if the intersection of `s` and `t` is nonempty. Here, two sets are considered disjoint if their intersection is empty. Therefore, this theorem is stating that the negation of the disjointness of two sets is equivalent to the non-emptiness of their intersection.

A sets `s` and `t` are not disjoint if and only if their intersection is non-empty. (In other words, sets `s` and `t` have non-empty intersection if and only if they are not disjoint.)


theorem le_sup_inf : ∀ {α : Type u} [inst : DistribLattice α] {x y z : α}, (x ⊔ y) ⊓ (x ⊔ z) ≤ x ⊔ y ⊓ z := by sorry

This theorem, `le_sup_inf`, states that for any type `α` which is a distributive lattice and any three elements `x`, `y`, `z` of this type, the supremum (join) of `x` and `y` intersected with the supremum of `x` and `z` is less than or equal to the supremum of `x` and the intersection of `y` and `z`. In terms of lattice theory, it relates the operations of join (supremum) and meet (infimum) in a specific way. This can be expressed in LaTeX as: $(x \vee y) \wedge (x \vee z) \leq x \vee (y \wedge z)$, where $\vee$ represents the supremum and $\wedge$ represents the infimum.

For any distributive lattice `α`, the join of two elements `x` and `y` intersected with the join of `x` and `z` is less than or equal to the join of `x` and the meet of `y` and `z`. In mathematical notation: $(x \vee y) \wedge (x \vee z) \leq x \vee (y \wedge z)$.


theorem Complex.neg_re : ∀ (z : ℂ), (-z).re = -z.re := by sorry

This theorem states that the real part of the negation of a complex number is equal to the negation of the real part of the original complex number. In other words, if you have a complex number `z`, and you negate this number to get `-z`, then the real part of `-z` (`(-z).re`) is identical to the negative of the real part of `z` (`-z.re`).

The real part of the negation of a complex number equals the negative of the real part of the original complex number. In mathematical notation, this can be expressed as `(-\ complex.re z).equiv (- z.re)`.


theorem Mathlib.GroupTheory.GroupAction.Basic._auxLemma.18 :
    ∀ {G : Type u_1} {α : Type u_2} [inst : AddGroup G] [inst_1 : AddAction G α] {a : α} {g : G},
      (g ∈ AddAction.stabilizer G a) = (g +ᵥ a = a) :=
  by sorry

This theorem states that for any additive group `G`, an action `AddAction` of `G` on a type `α`, an element `a` of type `α`, and an element `g` of `G`, `g` belongs to the stabilizer of `a` under the additive action if and only if the action of `g` on `a` leaves `a` unchanged. In mathematical terms, the stabilizer of `a` is the set of all elements of `G` that, when acting on `a`, produce `a`.

For any additive group `G`, an element `a` of a type `α`, and an action `AddAction` of `G` on `α`, an element `g` stabilizes `a` if and only if `AddAction g a = a`.


theorem Multiset.noncommSum_coe :
    ∀ {α : Type u_3} [inst : AddMonoid α] (l : List α) (comm : Set.Pairwise {x | x ∈ ↑l} AddCommute),
      Multiset.noncommSum (↑l) comm = List.sum l :=
  by sorry

This theorem states that for any list `l` of elements of a certain type `α` under an additive monoid structure, if the pairwise addition of all distinct elements in this list is commutative (i.e., the order of addition does not affect the result), then the non-commutative sum of the elements in this list (seen as a multiset and computed by `Multiset.noncommSum`) is equal to the regular sum of the elements in the list (computed by `List.sum`). In this sense, this theorem establishes a connection between the sum of elements in a list and the non-commutative sum of elements in a multiset when the addition operation is commutative.

If `l` is a list of commutative additive monoid elements, then `Multiset.noncommSum l` equals `List.sum l`.


theorem isBounded_ge_nhds :
    ∀ {α : Type u_2} [inst : Preorder α] [inst_1 : TopologicalSpace α] [inst_2 : BoundedGENhdsClass α] (a : α),
      Filter.IsBounded (fun x x_1 => x ≥ x_1) (nhds a) :=
  by sorry

This theorem states that for any type `α` that is a preorder and a topological space, and for any element `a` of type `α`, if `α` is a such that it has a property of being a `BoundedGENhdsClass` (a class of pre-ordered sets that are bounded below in the neighborhood filter), then the filter of neighborhoods around `a` (denoted by `nhds a`) is eventually bounded with respect to the relation `x ≥ x_1`. In other words, for any point `a`, there exists a uniform bound `b` such that in the vicinity of `a` (as defined by the neighborhood filter), all values `x` are greater than or equal to `b`.

For any preorder and topological space `α` that is a `BoundedGENhdsClass`, there exists a uniform bound `b` such that for all `a` in `α`, all elements `x` in the neighborhood filter of `a` satisfy `x ≥ b`.


theorem Set.image2_eq_empty_iff :
    ∀ {α : Type u_1} {β : Type u_3} {γ : Type u_5} {f : α → β → γ} {s : Set α} {t : Set β},
      Set.image2 f s t = ∅ ↔ s = ∅ ∨ t = ∅ :=
  by sorry

The theorem `Set.image2_eq_empty_iff` states that for any types `α`, `β`, and `γ`, and for any binary function `f : α → β → γ` and sets `s : Set α` and `t : Set β`, the image of the function `f` over sets `s` and `t` (represented as `Set.image2 f s t`) is empty if and only if set `s` is empty or set `t` is empty. In other words, a function applied to two sets will produce an empty set if and only if at least one of the original sets is empty.

For any functions \(f : \alpha \to \beta \to \gamma\) and sets \(s : \text{Set } \alpha\) and \(t : \text{Set } \beta\), \( \text{Set.image2 } f \ s \ t = \emptyset \iff s = \emptyset \lor t = \emptyset \).


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

This theorem states that for any semiring `R`, any natural number `n`, and any polynomial `p` over `R`, if the coefficient of `X^n` in `p` (denoted `Polynomial.coeff p n`) is not zero, then `n` is less than or equal to the degree of the polynomial `p` (denoted `Polynomial.degree p`). In other words, if a term with `X^n` is present (and has non-zero coefficient) in the polynomial, the degree of the polynomial is at least `n`.

For any semiring `R`, if `p` is a polynomial over `R` with non-zero coefficient for `X^n` where `n` is less than or equal to the degree of `p`, then `n` is equal to the degree of `p`. (Note: The statement in the description seems to have a mistake as it only guarantees that the degree of `p` is at least `n`, not equal to `n`.)


theorem DFinsupp.single_eq_of_ne :
    ∀ {ι : Type u} {β : ι → Type v} [inst : DecidableEq ι] [inst_1 : (i : ι) → Zero (β i)] {i i' : ι} {b : β i},
      i ≠ i' → (DFinsupp.single i b) i' = 0 :=
  by sorry

The theorem `DFinsupp.single_eq_of_ne` asserts that for any types `ι` and `β` where `β` is a function of `ι`, given a decidable equality on `ι` and a zero element for every `β i`, if we have two elements `i` and `i'` from `ι`, and an element `b` from `β i`, if `i` is not equal to `i'` (`i ≠ i'`), then the application of the function `DFinsupp.single i b` to `i'` yields `0`.

In simpler terms, it states that the function `DFinsupp.single i b` maps any element `i'` not equal to `i` to zero.

For any types `ι` and `β` where `β` is a function of `ι`, if `DFinsupp.single i b` is defined for `i ≠ i'` in `ι`, then `DFinsupp.single i b i' = 0`.


theorem MeasureTheory.AEEqFun.mk_coeFn :
    ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] {μ : MeasureTheory.Measure α}
      [inst_1 : TopologicalSpace β] (f : α →ₘ[μ] β), MeasureTheory.AEEqFun.mk ↑f ⋯ = f :=
  by sorry

This theorem in Lean 4 is stating that for any type `α` with a measurable space structure, any measure `μ` on `α`, and any type `β` with a topological space structure, if you have an almost everywhere equal function `f` from `α` to `β`, the operation of constructing an equivalence class of `f` using the function `MeasureTheory.AEEqFun.mk` with `f` as an argument (where the `f` is passed as a representative of its own equivalence class), will yield `f` itself. In other words, it asserts the consistency of the equivalence class construction process in the context of almost everywhere equal functions.

For any measurable space `(α, Σ, μ)`, topological space `(β, τ)`, and almost everywhere equal functions `f : α → β`, `MeasureTheory.AEEqFun.mk μ τ f = f`.


theorem Mathlib.Data.ENNReal.Basic._auxLemma.1 : ∀ {p q : NNReal}, (↑p = ↑q) = (p = q) := by sorry

This theorem states that for all nonnegative real numbers `p` and `q` (denoted by `NNReal`), the equality of their embeddings into another type (denoted by `↑p` and `↑q`) is equivalent to their direct equality. In other words, if the embedded forms of two nonnegative real numbers are equal, then the original nonnegative real numbers themselves are equal, and vice versa.

For all nonnegative real numbers `p` and `q`, `↑p = ↑q` if and only if `p = q`.


theorem ULift.down_injective : ∀ {α : Type u_1}, Function.Injective ULift.down := by sorry

This theorem states that for all types `α`, the function `ULift.down` is injective. In other words, if `ULift.down` applied to two values gives the same result, then the two original values must have been the same. This means that `ULift.down` preserves distinctness: no two different values will map to the same value. In mathematical terms, if `ULift.down(x) = ULift.down(y)`, then `x = y`. This property is crucial for many mathematical constructions and proofs.

For all types `α`, the function `ULift.down` is a bijective function from the universe of `α` to its image under `ULift.down`.


theorem CliffordAlgebra.lift_ι_apply :
    ∀ {R : Type u_1} [inst : CommRing R] {M : Type u_2} [inst_1 : AddCommGroup M] [inst_2 : Module R M]
      {Q : QuadraticForm R M} {A : Type u_3} [inst_3 : Semiring A] [inst_4 : Algebra R A] (f : M →ₗ[R] A)
      (cond : ∀ (m : M), f m * f m = (algebraMap R A) (Q m)) (x : M),
      ((CliffordAlgebra.lift Q) { val := f, property := cond }) ((CliffordAlgebra.ι Q) x) = f x :=
  by sorry

This theorem states that for any commutative ring `R`, any additive commutative group `M` that is also a module over `R`, any quadratic form `Q` on `M` with values in `R`, any semiring `A` that is also an algebra over `R`, any linear map `f` from `M` to `A` satisfying the condition that for each `m` in `M`, the square of `f(m)` equals the image of `Q(m)` under the algebra map from `R` to `A`, and any `x` in `M`, applying the lift of `Q` to the pair consisting of `f` and this condition to the result of applying the canonical linear map from `M` to the Clifford algebra of `Q` to `x` gives the same result as applying `f` to `x`. In other words, the lift of the quadratic form respects the application of the canonical map and the linear map `f`.

For any commutative ring `R`, additive commutative group `M` as an `R`-module, quadratic form `Q` on `M` with values in `R`, semiring `A` as an `R`-algebra, linear map `f : M → A` satisfying `f(m)² = Q(m)(map R A)`, and `x` in `M`, the lift of `Q` to the Clifford algebra of `Q` applied to the pair `(f, (m ↦ f(m)² = Q(m)(map R A)))` and the canonical map from `M` to the Clifford algebra of `Q` applied to `x` yields the same result as applying `f` to `x`.


DifferentiableWithinAt.differentiableAt

theorem DifferentiableWithinAt.differentiableAt :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {f : E → F}
      {x : E} {s : Set E}, DifferentiableWithinAt 𝕜 f s x → s ∈ nhds x → DifferentiableAt 𝕜 f x :=
  by sorry

The theorem `DifferentiableWithinAt.differentiableAt` states that for any nontrivially normed field `𝕜`, normed additive commutative groups `E` and `F` also being normed spaces over `𝕜`, a function `f` from `E` to `F`, a point `x` in `E`, and a set `s` of elements from `E`, if `f` is differentiable at the point `x` within the set `s` (`DifferentiableWithinAt 𝕜 f s x`), and if the set `s` is a neighborhood of the point `x` (`s ∈ nhds x`), then the function `f` is differentiable at the point `x` (`DifferentiableAt 𝕜 f x`). In other words, if a function is differentiable at a point within a local neighborhood, and the neighborhood is "close" to the point, then the function is also differentiable at the point itself.

If a function is differentiable within a neighborhood of a point in a normed space, then the function is differentiable at that point.


theorem Disjoint.sdiff_eq_left :
    ∀ {α : Type u_2} [inst : GeneralizedCoheytingAlgebra α] {a b : α}, Disjoint a b → a \ b = a := by sorry

This theorem states that for any generalized coheyting algebra `α` and any two elements `a` and `b` of `α`, if `a` and `b` are disjoint (in other words, their greatest lower bound (infimum) is the bottom element `⊥` of `α`), then the difference of `a` and `b` (denoted `a \ b`), is equal to `a`. In mathematical terms, if `a` and `b` are disjoint in the lattice sense, then removing `b` from `a` leaves `a` unchanged.

If `α` is a generalized coheta algebra and `a` and `b` in `α` are disjoint, then `a \ b = a`.


theorem Nat.gcd_mul_lcm : ∀ (m n : ℕ), Nat.gcd m n * Nat.lcm m n = m * n := by sorry

The theorem `Nat.gcd_mul_lcm` states that for any two natural numbers `m` and `n`, the product of the greatest common divisor (gcd) of `m` and `n` and the least common multiple (lcm) of `m` and `n` is equal to the product of `m` and `n`. In mathematical terms, for all natural numbers `m` and `n`, we have $\text{gcd}(m, n) \times \text{lcm}(m, n) = m \times n$.

The greatest common divisor of natural numbers `m` and `n` multiplied by their least common multiple equals the product of `m` and `n`: $\text{gcd}(m, n) \times \text{lcm}(m, n) = m \times n$.


theorem or_self_iff : ∀ {a : Prop}, a ∨ a ↔ a := by sorry

This theorem, `or_self_iff`, states that for any proposition `a`, the logical OR of `a` with itself is logically equivalent to `a` itself. In other words, it is saying that "either `a` is true or `a` is true" if and only if "`a` is true". This is a fundamental property of logic, and it holds universally for any proposition `a`.

For all propositions `a`, `a \vee a` is logically equivalent to `a`.


theorem RingHom.injective_iff_ker_eq_bot :
    ∀ {R : Type u} {S : Type v} {F : Type u_1} [inst : Ring R] [inst_1 : Semiring S] [inst_2 : FunLike F R S]
      [rc : RingHomClass F R S] (f : F), Function.Injective ⇑f ↔ RingHom.ker f = ⊥ :=
  by sorry

This theorem states that for any types `R`, `S`, and `F`, where `R` is a ring, `S` is a semiring, `F` is a function type from `R` to `S` that satisfies the `FunLike` and `RingHomClass` properties, a function `f` of type `F` is injective if and only if the kernel of `f` (as a ring homomorphism) is the bottom ideal (denoted by `⊥`). In other words, a ring homomorphism between these structures is injective if and only if its kernel, as an ideal of the domain, is the zero ideal. This theorem builds a bridge between the injectivity of a function and a property of its kernel in the context of ring homomorphisms.

A ring homomorphism between rings and semirings is injective if and only if its kernel is the bottom ideal.


theorem ModelWithCorners.target_eq :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {H : Type u_3} [inst_3 : TopologicalSpace H] (I : ModelWithCorners 𝕜 E H),
      I.target = Set.range ↑I :=
  by sorry

This theorem states that for any nontrivial normed field `𝕜`, any normed additive commutative group `E` that is also a normed space over `𝕜`, any topological space `H`, and any `ModelWithCorners` I with respect to these structures, the target of `I` is equivalent to the set range of `I`. In simpler terms, the theorem says that the set of all possible outputs of the ModelWithCorners `I` is precisely the set of all values it can map to.

For any nontrivial normed field `𝕜`, normed additive commutative group `E` over `𝕜`, topological space `H`, and `ModelWithCorners` `I` with respect to these structures, the range of `I` is equal to its target.


theorem Ordinal.IsNormal.self_le :
    ∀ {f : Ordinal.{u_4} → Ordinal.{u_4}}, Ordinal.IsNormal f → ∀ (a : Ordinal.{u_4}), a ≤ f a := by sorry

The theorem `Ordinal.IsNormal.self_le` states that for any normal function `f` mapping ordinals to ordinals, any ordinal `a` is less than or equal to `f(a)`. In other words, a normal ordinal function always produces an output that is greater than or equal to its input. This is a property of normal functions in the context of ordinal numbers.

For any normal function `f` mapping ordinals to ordinals, `a ≤ f(a)` for all ordinals `a`.


/-- If the angle between three points is `π / 2`, the first two points are not equal.  -/
theorem EuclideanGeometry.left_ne_of_oangle_eq_pi_div_two :
    ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V]
      [inst_2 : MetricSpace P] [inst_3 : NormedAddTorsor V P] [hd2 : Fact (FiniteDimensional.finrank ℝ V = 2)]
      [inst_4 : Module.Oriented ℝ V (Fin 2)] {p₁ p₂ p₃ : P},
      EuclideanGeometry.oangle p₁ p₂ p₃ = ↑(Real.pi / 2) → p₁ ≠ p₂ :=
  by sorry

This theorem, stated in the context of Euclidean Geometry, asserts that given a normed additive commutative group `V` equipped with an inner product space structure over the real numbers, a metric space `P`, and a normed additive torsor `V` over `P`, if the space `V` has a two-dimensional real vector space structure and is oriented, then for any three points `p₁`, `p₂`, and `p₃` in `P`, if the angle between these three points is equal to `π / 2`, then the first two points `p₁` and `p₂` must be distinct, that is, they are not the same point.

In Euclidean Geometry, if a two-dimensional oriented inner product space over the real numbers with distinct points `p₁` and `p₂` is a normed additive torsor over a metric space, then `p₁` and `p₂` are distinct when the angle between them is a right angle (π/2 radians).


theorem ENNReal.toNNReal_mul : ∀ {a b : ENNReal}, (a * b).toNNReal = a.toNNReal * b.toNNReal := by sorry

This theorem states that for every two elements `a` and `b` from the extended nonnegative real numbers `ENNReal`, the operation of converting the product of `a` and `b` to the nonnegative real numbers `toNNReal` is the same as first converting `a` and `b` separately to nonnegative real numbers and then multiplying them. In other words, the multiplication operation is compatible with the `toNNReal` function.

For all `a` and `b` in the extended nonnegative real numbers `ENNReal`, `toNNReal (a * b) = toNNReal a * toNNReal b`.


/-- **Alias** of the reverse direction of `Finset.le_inf_iff`. -/
theorem Finset.le_inf :
    ∀ {α : Type u_2} {β : Type u_3} [inst : SemilatticeInf α] [inst_1 : OrderTop α] {s : Finset β} {f : β → α} {a : α},
      (∀ b ∈ s, a ≤ f b) → a ≤ Finset.inf s f :=
  by sorry

This theorem, `Finset.le_inf`, states that for any types `α` and `β`, with `α` being a semilattice with an associated "top" element, a given set `s` of type `Finset β`, a function `f` mapping from `β` to `α`, and an element `a` of type `α`: if `a` is less than or equal to the function `f` evaluated at each element `b` in the set `s`, then `a` is also less than or equal to the infimum of the set `s` under the function `f`. The infimum here is defined as the greatest lower bound of the function applied to the elements of the set.

For any semilattice `α` with top element, function `f` from type `β` to `α`, set `s` of type `Finset β`, and element `a` of type `α`, if `a ≤ f(b)` for all `b` in `s`, then `a ≤ ∧ x in s. f(x)`, where `∧` denotes the infimum under the function `f`.


IsMinFilter.isExtr

theorem IsMinFilter.isExtr :
    ∀ {α : Type u} {β : Type v} [inst : Preorder β] {f : α → β} {l : Filter α} {a : α},
      IsMinFilter f l a → IsExtrFilter f l a :=
  by sorry

The theorem `IsMinFilter.isExtr` states that for any types `α` and `β` with a preorder on `β`, and given a function `f` from `α` to `β`, a filter `l` on `α`, and an element `a` of `α`, if `a` is a minimum of the function `f` in some neighborhood defined by the filter `l` (meaning `f(a)` is less than or equal to `f(x)` for all `x` in that neighborhood), then `a` is also an extremum in that neighborhood (meaning `a` is either a minimum or a maximum of `f` in that neighborhood).

If `a` is a minimum of the function `f` in the neighborhood defined by filter `l` on type `α`, then `a` is an extremum (minimum or maximum) of `f` in that neighborhood.


theorem Real.rpow_add : ∀ {x : ℝ}, 0 < x → ∀ (y z : ℝ), x ^ (y + z) = x ^ y * x ^ z := by sorry

This theorem states that for any real number `x` that is greater than zero and any two real numbers `y` and `z`, the exponentiation of `x` to the power of the sum of `y` and `z` is equal to the product of `x` raised to the power of `y` and `x` raised to the power of `z`. In mathematics notation, this can be written as: if $0 < x$ and $y, z \in \mathbb{R}$, then $x^{y+z} = x^y \cdot x^z$. This property is an important characteristic of exponentiation.

For any real number `x` > 0, `x^(y + z)` equals `x^y * x^z` for all `y, z` in the real numbers.


theorem Function.ne_iff : ∀ {α : Sort u_1} {β : α → Sort u_4} {f₁ f₂ : (a : α) → β a}, f₁ ≠ f₂ ↔ ∃ a, f₁ a ≠ f₂ a := by
  sorry

This theorem, `Function.ne_iff`, states that for all sorts `α` and `β` that is a function of `α`, and for all functions `f₁` and `f₂` from `α` to `β`, `f₁` is not equal to `f₂` if and only if there exists an element `a` in `α` such that `f₁ a` is not equal to `f₂ a`. In other words, two functions are different if and only if there is at least one argument for which they yield different results.

For functions between types `α` and `β`, `f₁` is not equal to `f₂` if and only if there exists an `x ∈ α` such that `f₁ x ≠ f₂ x`.


theorem Nat.not_succ_le_self : ∀ (n : ℕ), ¬Nat.succ n ≤ n := by sorry

This theorem states that for any natural number `n`, the successor of `n` (which can be thought of as `n + 1`) is not less than or equal to `n`. In other words, the assertion is that no natural number is greater than or equal to its immediate successor, which aligns with our standard understanding of natural numbers in mathematics.


theorem Homeomorph.apply_symm_apply :
    ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] (h : X ≃ₜ Y) (y : Y),
      h ((Homeomorph.symm h) y) = y :=
  by sorry

The theorem `Homeomorph.apply_symm_apply` states that for any homeomorphism `h` from a topological space `X` to another topological space `Y` and for any element `y` of `Y`, applying `h` to the inverse image of `y` under homeomorphism `h` will yield `y` itself. In other words, this theorem ensures that the inverse function of a homeomorphism truly behaves as an inverse, mapping each point in `Y` back to its original point in `X` after applying the homeomorphism `h`.

For any homeomorphism $h$ and any $y$ in the codomain, $h(h^{-1}(y)) = y$.


theorem MvPolynomial.map_X :
    ∀ {R : Type u} {S₁ : Type v} {σ : Type u_1} [inst : CommSemiring R] [inst_1 : CommSemiring S₁] (f : R →+* S₁)
      (n : σ), (MvPolynomial.map f) (MvPolynomial.X n) = MvPolynomial.X n :=
  by sorry

The theorem `MvPolynomial.map_X` states that for any commutative semirings `R` and `S₁`, and any ring homomorphism `f` from `R` to `S₁`, and any `n` in the index set `σ`, mapping the polynomial `X_n` (which is a degree `1` monomial) under `f` using the function `MvPolynomial.map` results in the same `X_n`. In other words, the mapping preserves the degree `1` monomial `X_n`.

For any commutative semirings R and S₁, and ring homomorphism f from R to S₁, the degree 1 monomial X\_n in R is mapped to X\_n under the function MvPolynomial.map from R-polynomials to S₁-polynomials by f.


theorem List.eq_nil_of_length_eq_zero : ∀ {α : Type u_1} {l : List α}, List.length l = 0 → l = [] := by sorry

This theorem states that for any type `α` and any list `l` of elements of type `α`, if the length of the list `l` is zero, then `l` must be the empty list. In other words, the only list of type `α` with a length of zero is the empty list. This theorem is a formalization of the intuitive notion that a list without any elements is the empty list.

For any type `α`, the empty list is the only list of length zero.


theorem interior_Icc :
    ∀ {α : Type u} [inst : TopologicalSpace α] [inst_1 : LinearOrder α] [inst_2 : OrderTopology α]
      [inst_3 : DenselyOrdered α] [inst_4 : NoMinOrder α] [inst_5 : NoMaxOrder α] {a b : α},
      interior (Set.Icc a b) = Set.Ioo a b :=
  by sorry

The theorem `interior_Icc` states that for any type `α` that is a topological space, linearly ordered, has an order topology, is densely ordered, and has no minimum or maximum order, the interior of a left-closed right-closed interval (denoted as `Set.Icc a b`) is equal to a left-open right-open interval (denoted as `Set.Ioo a b`). In simpler terms, if we consider the set of all elements that lie in the interval including end points `a` and `b`, then the largest open subset of this set is the set of all elements that lie strictly between `a` and `b`, not including `a` and `b`.

For a linearly ordered, topological space `α` without minimum or maximum, having the order topology and density property, the interior of an interval `[a, b]` equals the open interval `(a, b)`.


theorem Int.gcd_dvd_left : ∀ {a b : ℤ}, ↑(Int.gcd a b) ∣ a := by sorry

The theorem `Int.gcd_dvd_left` states that for any two integers `a` and `b`, the greatest common divisor (gcd) of `a` and `b` divides `a`. This is written in the Lean theorem prover as `↑(Int.gcd a b) ∣ a`, where `Int.gcd a b` computes the gcd of `a` and `b`, the `↑` operator converts that gcd from a natural number to an integer, and `∣` represents the "divides" relation. In mathematical terms, if $gcd(a, b) = d$, then $d | a$.

The greatest common divisor of integers `a` and `b` divides `a`. In mathematical notation, if $gcd(a, b) = d$, then $d | a$.


theorem Complex.cpow_one : ∀ (x : ℂ), x ^ 1 = x := by sorry

This theorem states that for any complex number `x`, `x` raised to the power of 1 is equal to `x` itself. It is a basic property of exponentiation that holds true for complex numbers in the field of complex arithmetic.


theorem ContinuousAt.comp_continuousWithinAt :
    ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β]
      [inst_2 : TopologicalSpace γ] {g : β → γ} {f : α → β} {s : Set α} {x : α},
      ContinuousAt g (f x) → ContinuousWithinAt f s x → ContinuousWithinAt (g ∘ f) s x :=
  by sorry

The theorem `ContinuousAt.comp_continuousWithinAt` states that for any three topological spaces `α`, `β`, and `γ`, and any two functions `g: β → γ` and `f: α → β`, as well as a set `s` of the type `α` and an element `x` of type `α`, if the function `g` is continuous at the point `(f x)` and the function `f` is continuous within the set `s` at the point `x`, then the composition of `g` and `f`, denoted by `(g ∘ f)`, is also continuous within the set `s` at the point `x`. In other words, the continuity of `g` at `(f x)` and the continuity of `f` at `x` within `s` implies the continuity of the composition `(g ∘ f)` at `x` within `s`.

If functions `f: α → β` is continuous at `x ∈ α` within a set `s ⊆ α` and `g: β → γ` is continuous at `f x ∈ β`, then their composition `g ∘ f` is continuous at `x` within `s`.


MeasureTheory.AEStronglyMeasurable.mul

theorem MeasureTheory.AEStronglyMeasurable.mul :
    ∀ {α : Type u_1} {β : Type u_2} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} [inst : TopologicalSpace β]
      {f g : α → β} [inst_1 : Mul β] [inst_2 : ContinuousMul β],
      MeasureTheory.AEStronglyMeasurable f μ →
        MeasureTheory.AEStronglyMeasurable g μ → MeasureTheory.AEStronglyMeasurable (f * g) μ :=
  by sorry

This theorem states that for any given types `α` and `β`, where `α` is equipped with a measurable space structure and `β` is equipped with topological space as well as multiplication structures, and `μ` is a measure on `α`, if two functions `f` and `g` from `α` to `β` are almost everywhere strongly measurable with respect to the measure `μ`, then their pointwise product function `(f * g)` is also almost everywhere strongly measurable with respect to the same measure `μ`. Here, almost everywhere strongly measurable means that the function is almost everywhere equal to the limit of a sequence of simple functions. The multiplication on `β` is assumed to be continuous.

Given measurable spaces `(α, Σα)` and `(β, Σβ)`, measurable functions `f, g : α → β`, a measure `μ : Σα → ℝ`, and assuming `μ` is a measure on `α`, `β` is a topological space with a continuous multiplication, and `f` and `g` are almost everywhere strongly measurable with respect to `μ`, then their pointwise product `f * g : α → β` is almost everywhere strongly measurable with respect to `μ`.


Function.Injective.uncountable

theorem Function.Injective.uncountable :
    ∀ {α : Sort u} {β : Sort v} [inst : Uncountable α] {f : α → β}, Function.Injective f → Uncountable β := by sorry

The theorem `Function.Injective.uncountable` states that for any sorts `α` and `β`, given an instance where `α` is uncountable and a function `f` from `α` to `β` that is injective, it follows that `β` is uncountable. In other words, if we have an uncountable set and an injective function from this set to another set, then the other set is also uncountable.

If `α` is an uncountable set and `f : α → β` is an injective function, then `β` is uncountable.


theorem iInf_subtype :
    ∀ {α : Type u_1} {ι : Sort u_5} [inst : CompleteLattice α] {p : ι → Prop} {f : Subtype p → α},
      iInf f = ⨅ i, ⨅ (h : p i), f { val := i, property := h } :=
  by sorry

This theorem states that for all types `α` and `ι`, where `α` is a complete lattice, and for all properties `p` over `ι` and a function `f` from the subtype of `ι` satisfying `p` to `α`, the indexed infimum of `f` is equal to the infimum over all `i` in `ι` and for all proofs `h` that `i` satisfies `p`, of `f` applied to the subtype element `{ val := i, property := h }`. In simpler terms, it says that we can compute the infimum of a function applied to elements of a subtype either directly or by considering the elements of the original type that satisfy the defining property of the subtype.

For any complete lattice `α` and property `p` over type `ι`, if `f` is a function from the subtype of `ι` satisfying `p` to `α`, then the infimum of `f` over the subtype equals the infimum of `f(i)` over all `i` in `ι` and all proofs `h` that `i` satisfies `p`.


theorem Set.left_mem_uIcc : ∀ {α : Type u_1} [inst : Lattice α] {a b : α}, a ∈ Set.uIcc a b := by sorry

The theorem `Set.left_mem_uIcc` states that for any type `α` that forms a lattice, given any two elements `a` and `b` of `α`, `a` is always an element of the set `Set.uIcc a b`. Here, `Set.uIcc a b` represents the set of all elements lying between `a` and `b` (inclusive), where the notion of betweenness is based on the lattice structure of `α`.

For any lattice type `α` and elements `a` and `b` in `α`, `a` is in the interval `Set.uIcc a b`.


theorem Mathlib.Algebra.Order.Monoid.Lemmas._auxLemma.4 :
    ∀ {α : Type u_1} [inst : Add α] [inst_1 : LE α]
      [inst_2 : CovariantClass α α (Function.swap fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1]
      [inst_3 : ContravariantClass α α (Function.swap fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] (a : α) {b c : α},
      (b + a ≤ c + a) = (b ≤ c) :=
  by sorry

This theorem is a statement about partially ordered additive monoids in the world of algebra. Given a type `α` which has an addition operation and a partial order defined on it, satisfying both covariant and contravariant properties with respect to addition, the theorem states that for any elements `a`, `b`, and `c` of this type, `b + a` is less than or equal to `c + a` if and only if `b` is less than or equal to `c`. This means that in such a structure, the inequality between `b` and `c` does not change when we add the same quantity `a` to both sides.

For all types `α` with addition `+` and a partial order `≤` such that addition is covariant and contravariant with respect to the order, `b ≤ c` if and only if `b + a ≤ c + a` for all `a, b, c` in `α`.


theorem MeasureTheory.measure_iUnion₀ :
    ∀ {ι : Type u_1} {α : Type u_2} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} [inst : Countable ι]
      {f : ι → Set α},
      Pairwise (MeasureTheory.AEDisjoint μ on f) →
        (∀ (i : ι), MeasureTheory.NullMeasurableSet (f i) μ) → ↑↑μ (⋃ i, f i) = ∑' (i : ι), ↑↑μ (f i) :=
  by sorry

The theorem `MeasureTheory.measure_iUnion₀` is a property about measure theory. Given an index type `ι` that is countable and a measurable space `α` with a measure `μ`, we consider a function `f` that maps each index `i` in `ι` to a set in `α`. If the sets `f i` are almost everywhere disjoint (that is, their intersection has measure zero), and each `f i` is a null measurable set (that is, each `f i` can be approximated by a measurable set up to a set of null measure), then the measure of the union of all `f i` is equal to the sum of the measures of each `f i`. In mathematical notation, this theorem states that if the sets `f(i)` for `i` in `ι` are pairwise `μ`-almost everywhere disjoint and null measurable, then `μ(∪ i, f(i)) = ∑' (i : ι), μ(f(i))`.

Given a countable index type `ι`, measurable space `α` with measure `μ`, and a family `f(i)` of pairwise almost everywhere disjoint, null measurable sets, the measure of their union is equal to the sum of their individual measures.


DifferentiableOn.differentiableAt

theorem DifferentiableOn.differentiableAt :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {f : E → F}
      {x : E} {s : Set E}, DifferentiableOn 𝕜 f s → s ∈ nhds x → DifferentiableAt 𝕜 f x :=
  by sorry

This theorem states that for any non-trivially normed field '𝕜', normed additive commutative group 'E', 'F', a function 'f' from 'E' to 'F', a point 'x' in 'E', and a set 's' of 'E', if the function 'f' is differentiable on the set 's' and the set 's' is a neighborhood of the point 'x', then the function 'f' is differentiable at the point 'x'. In simpler terms, if a function is differentiable everywhere in a neighborhood around a point, then it is differentiable at that point.

If a function is differentiable on a neighborhood of a point in a normed additive commutative group, then it is differentiable at that point.


theorem Polynomial.map_monomial :
    ∀ {R : Type u} {S : Type v} [inst : Semiring R] [inst_1 : Semiring S] (f : R →+* S) {n : ℕ} {a : R},
      Polynomial.map f ((Polynomial.monomial n) a) = (Polynomial.monomial n) (f a) :=
  by sorry

The theorem `Polynomial.map_monomial` states that for any semirings `R` and `S`, any ring homomorphism `f` from `R` to `S`, and any natural number `n` and element `a` of `R`, the result of mapping the polynomial `a * X^n` (`a` times `X` raised to the power `n`) across the ring homomorphism `f` is the same as the polynomial obtained by first applying the ring homomorphism `f` to `a` and then multiplying the result by `X` raised to the power `n`. In other words, this theorem asserts that the process of applying a ring homomorphism to a polynomial is commutative with the process of forming a monomial.

For any semirings R and S, ring homomorphism f from R to S, natural number n, and element a in R, we have f(a * X^n) = f(a) * X^n.


theorem Polynomial.X_sub_C_ne_zero :
    ∀ {R : Type u} [inst : Ring R] [inst_1 : Nontrivial R] (r : R), Polynomial.X - Polynomial.C r ≠ 0 := by sorry

The theorem `Polynomial.X_sub_C_ne_zero` states that for any type `R` that forms a ring and is nontrivial (i.e., it has at least two distinct elements), and for any element `r` of `R`, the polynomial `X - C r` (where `X` is the polynomial variable and `C r` is the constant polynomial `r`) is not equal to zero. This means that subtracting a constant polynomial from the polynomial variable always yields a non-zero polynomial.

For any nontrivial ring `R` and its element `r`, the polynomial `X - C r` is never equal to the zero polynomial.


theorem Set.dual_Ico :
    ∀ {α : Type u_1} [inst : Preorder α] {a b : α},
      Set.Ico (OrderDual.toDual a) (OrderDual.toDual b) = ⇑OrderDual.ofDual ⁻¹' Set.Ioc b a :=
  by sorry

The theorem `Set.dual_Ico` states that for any type `α` with a preorder and any pair of elements `a` and `b` of `α`, the left-closed right-open interval (`Set.Ico`) between the order duals of `a` and `b` is equivalent to the preimage of the left-open right-closed interval (`Set.Ioc`) between `b` and `a` under the function that converts an order dual back to an original order. In other words, it states that reversing the order of a preorder results in swapping the roles of the open and closed ends of an interval.

For any preordered type `α` and elements `a` and `b` in `α`, the left-closed right-open interval `Set.Ico a b` is equivalent to the preimage of the left-open right-closed interval `Set.Ioc b a` under the order dual function.