/-- One can reformulate smoothness on a set as continuity on this set, and smoothness in any
extended chart.  -/
theorem contMDiffOn_iff :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {H : Type u_3} [inst_3 : TopologicalSpace H] {I : ModelWithCorners 𝕜 E H}
      {M : Type u_4} [inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] [inst_6 : SmoothManifoldWithCorners I M]
      {E' : Type u_5} [inst_7 : NormedAddCommGroup E'] [inst_8 : NormedSpace 𝕜 E'] {H' : Type u_6}
      [inst_9 : TopologicalSpace H'] {I' : ModelWithCorners 𝕜 E' H'} {M' : Type u_7} [inst_10 : TopologicalSpace M']
      [inst_11 : ChartedSpace H' M'] [inst_12 : SmoothManifoldWithCorners I' M'] {f : M → M'} {s : Set M} {n : ℕ∞},
      ContMDiffOn I I' n f s ↔
        ContinuousOn f s ∧
          ∀ (x : M) (y : M'),
            ContDiffOn 𝕜 n (↑(extChartAt I' y) ∘ f ∘ ↑(PartialEquiv.symm (extChartAt I x)))
              ((extChartAt I x).target ∩
                ↑(PartialEquiv.symm (extChartAt I x)) ⁻¹' (s ∩ f ⁻¹' (extChartAt I' y).source)) :=
  by sorry

This theorem states that for any nontrivially normed field 𝕜, normed add commutative group E and E', normed spaces 𝕜 E and 𝕜 E', topological spaces H, M, H', M', model with corners I, I', and charted spaces H M, H' M', equipped with smooth manifolds with corners I M and I' M', and for any function f from M to M' defined on a set s and for any natural number or infinity n, the function f is continuously differentiable on set s with respect to the modelled corners I and I' and order n if and only if the function f is continuous on set s and for every point x in M and y in M', the composition of the extended chart at I' y, function f, and the inverse of the extended chart at I x is continuously differentiable with respect to 𝕜 and order n on the intersection of the target of the extended chart at I x and the preimage of the intersection of set s and the preimage of the source of the extended chart at I' y under the inverse operation of the extended chart at I x.

For any nontrivially normed field 𝕜, normed add commutative groups E and E', smooth manifolds with corners I M, I' M', and functions f from M to M' defined on a set s, the function f is continuously differentiable of order n on s with respect to the indicated corners if and only if the composition of the extended charts at I' y, f, and the inverse of the extended chart at I x is continuously differentiable of order n with respect to 𝕜 for all x in M and y in M'.


theorem Hyperreal.eq_of_isSt_real : ∀ {r s : ℝ}, Hyperreal.IsSt (↑r) s → r = s := by sorry

The theorem `Hyperreal.eq_of_isSt_real` states that for any two real numbers `r` and `s`, if the standard part of the hyperreal number corresponding to `r` is `s`, then `r` and `s` must be identical. The standard part of a hyperreal number `x` is a real number `r` such that for all positive real numbers `δ`, `x` lies between `r - δ` and `r + δ`.

For any real numbers `r` and `s`, if the standard part of the hyperreal number `r` is equal to `s`, then `r` and `s` are identical.


theorem Inducing.map_nhds_of_mem :
    ∀ {X : Type u_1} {Y : Type u_2} {f : X → Y} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y],
      Inducing f → ∀ (x : X), Set.range f ∈ nhds (f x) → Filter.map f (nhds x) = nhds (f x) :=
  by sorry

This theorem states that for any two types `X` and `Y`, a function `f` from `X` to `Y`, and points `x` in `X`, if the function `f` is inducing (i.e., the topology on `X` is the coarsest topology such that `f` is continuous) and the range of the function `f` is in the neighborhood of `f(x)`, then the forward map of the filter of `nhds x` under `f` is equal to the neighborhood of `f(x)`. In other words, mapping the neighborhood filter at `x` through `f` gives you the neighborhood filter at `f(x)` when `f` is inducing and the image of `f` lies within the neighborhood of `f(x)`.

If function `f` from type `X` to `Y` is inducing and the range of `f` is in the neighborhood of `f(x)` for some `x` in `X`, then the image of the neighborhood filter of `x` under `f` equals the neighborhood filter of `f(x)`.


Polynomial.differentiableAt

theorem Polynomial.differentiableAt :
    ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {x : 𝕜} (p : Polynomial 𝕜),
      DifferentiableAt 𝕜 (fun x => Polynomial.eval x p) x :=
  by sorry

The theorem `Polynomial.differentiableAt` states that for any field `𝕜` equipped with a norm (specifically a field that is nontrivially normed), any polynomial `p` with coefficients in `𝕜`, and any point `x` in `𝕜`, the function that maps `x` to the evaluation of the polynomial `p` at `x` is differentiable at `x`. In other words, for any polynomial and any point, there exists a derivative of the polynomial at that point.

For any field equipped with a norm and any polynomial with coefficients in that field, the polynomial evaluation function is differentiable.


theorem CategoryTheory.GrothendieckTopology.covers_iff :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} (J : CategoryTheory.GrothendieckTopology C)
      (S : CategoryTheory.Sieve X) (f : Y ⟶ X),
      CategoryTheory.GrothendieckTopology.Covers J S f ↔ CategoryTheory.Sieve.pullback f S ∈ J.sieves Y :=
  by sorry

The theorem `CategoryTheory.GrothendieckTopology.covers_iff` states that for any category `C`, objects `X` and `Y` in `C`, a Grothendieck topology `J` on `C`, a sieve `S` on `X`, and a morphism `f : Y ⟶ X`, the sieve `S` on `X` `J`-covers the arrow `f` to `X` if and only if the pullback of `S` along `f` is in the sieves of `J` on `Y`. In other words, a sieve `S` covers a morphism under a Grothendieck topology if and only if the pullback of `S` through this morphism is a sieve in the topology at the domain of the morphism.

A sieve on an object X in a category with a Grothendieck topology J covers the morphism f : Y ⟶ X if and only if the pullback of J-sieves on X along f is contained in the J-sieves on Y.


theorem MeasureTheory.VectorMeasure.map_apply :
    ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] [inst_1 : MeasurableSpace β] {M : Type u_3}
      [inst_2 : AddCommMonoid M] [inst_3 : TopologicalSpace M] (v : MeasureTheory.VectorMeasure α M) {f : α → β},
      Measurable f → ∀ {s : Set β}, MeasurableSet s → ↑(MeasureTheory.VectorMeasure.map v f) s = ↑v (f ⁻¹' s) :=
  by sorry

This theorem, named `MeasureTheory.VectorMeasure.map_apply`, states that for all types `α`, `β` and `M`, given a measurable space over `α` and `β`, an addition-commutative monoid over `M`, and a topological space over `M`, for any vector measure `v` of type `α` to `M`, and any function `f` from `α` to `β` that is measurable, then for any set `s` of type `β` that is measurable, the measure of the set `s` under the map of the vector measure `v` by the function `f` is equal to the measure of the preimage of the set `s` under the function `f` with respect to the vector measure `v`. In mathematical terms, for a measurable function `f: α → β` and a measurable set `s ⊆ β`, the measure of `s` under the mapped measure is the same as the measure of the preimage of `s` under the original measure.

For any measurable function between measurable spaces and any measurable set, the measure of the set under the mapped measure is equal to the measure of the preimage of the set under the original measure.


theorem Algebra.adjoin_singleton_eq_range_aeval :
    ∀ (R : Type u) {A : Type z} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A] (x : A),
      Algebra.adjoin R {x} = AlgHom.range (Polynomial.aeval x) :=
  by sorry

This theorem states that for any commutative semiring `R` and any semiring `A`, given an algebra structure on `A` over `R` and an element `x` from `A`, the subalgebra of `A` generated by `R` and the singleton set `{x}` is equal to the range of the algebra homomorphism defined by evaluating polynomials at `x`. In other words, every element in the minimal subalgebra that includes `{x}` can be obtained by taking a polynomial with coefficients in `R`, replacing the variable by `x`, and performing the resulting operations in `A`.

For any commutative semiring `R`, semiring `A`, algebra structure on `A` over `R`, and element `x` in `A`, the subalgebra of `A` generated by `R` and `{x}` equals the image of the algebra homomorphism sending polynomials over `R` to their evaluations at `x` in `A`.


/-- The intersection of a closed set and a compact set is a compact set.  -/
theorem IsCompact.inter_left :
    ∀ {X : Type u} [inst : TopologicalSpace X] {s t : Set X}, IsCompact t → IsClosed s → IsCompact (s ∩ t) := by sorry

The theorem states that in a given topological space, if we have a compact set and a closed set, the intersection of the two sets is also a compact set. Here, a compact set is defined such that for every nontrivial filter that contains the set, there exists an element in the set such that every set of the filter meets every neighborhood of that element. A set is closed if it contains all its limit points.

In a topological space, the intersection of a compact and closed set is a compact set.


theorem Nat.not_dvd_of_pos_of_lt : ∀ {m n : ℕ}, 0 < n → n < m → ¬m ∣ n := by sorry

This theorem states that for any two natural numbers `m` and `n`, if `n` is positive and less than `m`, then `m` does not divide `n`. In mathematical terms, this theorem states that if 0 < n < m for n, m ∈ ℕ, then m does not divide n.

For all natural numbers m and n, if 0 < n < m then m does not divide n.


theorem Int.zero_div : ∀ (b : ℤ), Int.div 0 b = 0 := by sorry

This theorem states that for any integer `b`, the integer division of zero by `b` equals zero. In mathematical terms, it's saying that ∀b ∈ ℤ, 0 ÷ b = 0.

For all integers `b`, the quotient of zero by `b` is equal to zero.


theorem Multiset.mem_powersetCard :
    ∀ {α : Type u_1} {n : ℕ} {s t : Multiset α}, s ∈ Multiset.powersetCard n t ↔ s ≤ t ∧ Multiset.card s = n := by sorry

The theorem `Multiset.mem_powersetCard` states that for any type `α`, natural number `n`, and multisets `s` and `t` of type `α`, a multiset `s` is a member of the powerset of `t` of cardinality `n` if and only if `s` is a sub-multiset of `t` and the cardinality of `s` equals `n`. In simpler terms, it tells us that a set `s` is in the collection of all subsets of `t` of size `n` only when `s` is indeed a subset of `t` and the size of `s` is `n`. It essentially characterizes the membership in the `n`-sized powerset of a multiset.

A multiset is an element of the powerset of another multiset with a specific cardinality if and only if it is a sub-multiset of that set and has the given cardinality.


theorem stronglyMeasurable_deriv_with_param :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {F : Type u_3} [inst_1 : NormedAddCommGroup F]
      [inst_2 : NormedSpace 𝕜 F] {α : Type u_4} [inst_3 : TopologicalSpace α] [inst_4 : MeasurableSpace α]
      [inst_5 : OpensMeasurableSpace α] [inst_6 : CompleteSpace F] [inst_7 : LocallyCompactSpace 𝕜]
      [inst_8 : MeasurableSpace 𝕜] [inst_9 : OpensMeasurableSpace 𝕜] [h : SecondCountableTopologyEither α F]
      {f : α → 𝕜 → F}, Continuous (Function.uncurry f) → MeasureTheory.StronglyMeasurable fun p => deriv (f p.1) p.2 :=
  by sorry

This theorem, named `stronglyMeasurable_deriv_with_param`, states that for all types `𝕜` and `F` such that `𝕜` is a non-trivially normed field, `F` is a normed add commutative group and a normed space over `𝕜`, and a type `α` having the structure of a topological space, measurable space, open measurable space, and having a second countable topology with `F`, for any function `f` from `α` to `𝕜` to `F` (interpreted as a function on `α × 𝕜` to `F`), if `f` is continuous, then the function that takes a pair `p` and gives the derivative of `f` at the point `p.1` in direction `p.2` is strongly measurable.

In more mathematical terms, if we have a continuous function $f : \alpha \times \kappa \rightarrow F$, then the function $g: \alpha \times \kappa \rightarrow F$ defined by $g(p) = \frac{df}{d\kappa}(p)$, where $\frac{df}{d\kappa}(p)$ denotes the derivative of $f$ at point $p.1$ in direction $p.2$, is strongly measurable. Strongly measurable functions are those that can be considered as the limit of a sequence of simple functions.

If `α` is a topological space, `F` is a normed add commutative group and a normed space over a non-trivially normed field `𝕜`, and `f : α × 𝕜 → F` is a continuous function, then the derivative function `g : α × 𝕜 → F` given by `g(p) = df/dκ(p)` is strongly measurable.


theorem Nat.max_comm : ∀ (a b : ℕ), max a b = max b a := by sorry

This theorem states that for any two natural numbers `a` and `b`, the maximum of `a` and `b` is equal to the maximum of `b` and `a`. In other words, the operation of taking the maximum of two numbers is commutative over the set of natural numbers. This is similar to saying, for instance, that $3 \oplus 2 = 2 \oplus 3$ where $\oplus$ denotes the operation of taking the maximum.

For all natural numbers `a` and `b`, `max a b` equals `max b a`.


theorem Bool.bool_iff_false : ∀ {b : Bool}, ¬b = true ↔ b = false := by sorry

This theorem, `Bool.bool_iff_false`, states that for all boolean variables `b`, the proposition "`b` is not `true`" is equivalent to the proposition "`b` is `false`". This is an inherent property of Boolean logic, where a variable can only hold `true` or `false`, and thus if it is not `true`, it must necessarily be `false`.

For all boolean variables b, b is false if and only if it is not true.


/-- Singletons are bounded.  -/
theorem Bornology.isVonNBounded_singleton :
    ∀ {𝕜 : Type u_1} {E : Type u_3} [inst : NormedField 𝕜] [inst_1 : AddCommGroup E] [inst_2 : Module 𝕜 E]
      [inst_3 : TopologicalSpace E] [inst_4 : ContinuousSMul 𝕜 E] (x : E), Bornology.IsVonNBounded 𝕜 {x} :=
  by sorry

The theorem `Bornology.isVonNBounded_singleton` states that for any singleton set, consisting of a single element `x` from a space `E`, the set is von Neumann bounded in the context of a normed field `𝕜`. In more technical terms, for any given neighborhood `V` of zero in `E`, there exists a scalar from `𝕜` such that scalar multiplication of `V` can cover the element `x`. The type `E` has a structure of a topological space, a module over the normed field `𝕜`, and the scalar multiplication from `𝕜` to `E` is continuous.

For any singleton set in a topological module over a normed field endowed with a continuous scalar multiplication, there exists a scalar such that scalar multiplication covers the set.


theorem Complex.isOpenMap_re : IsOpenMap Complex.re := by sorry

This theorem states that the real part function, denoted as `Complex.re`, which maps a complex number to its real part, is an "open map". In the context of topology, an open map is a function between two topological spaces that maps open sets to open sets. Specifically, for any open set of complex numbers, the set of their real parts is an open set of real numbers.

The real part function from the complex numbers to the real numbers is a continuous open mapping.


theorem Nat.add_lt_of_lt_sub : ∀ {a b c : ℕ}, a < c - b → a + b < c := by sorry

This theorem states that for any three natural numbers `a`, `b`, and `c`, if `a` is less than the difference of `c` and `b` (`a < c - b`), then the sum of `a` and `b` (`a + b`) is less than `c`. This is essentially a property of natural numbers concerning addition and subtraction.

If `a` is smaller than the difference between `c` and `b` (`a < c - b`), then `a + b` is strictly less than `c`.


theorem Submodule.isOrtho_orthogonal_right :
    ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
      (U : Submodule 𝕜 E), U ⟂ Uᗮ :=
  by sorry

This theorem states that for any type `𝕜` and any normed additive commutative group `E` with an inner product space over `𝕜`, every submodule `U` of `E` is orthogonal to its orthogonal complement `Uᗮ`. In other words, the inner product of any element of `U` with any element of `Uᗮ` is zero. This theorem is a fundamental property in the field of linear algebra.

For any normed additive commutative group `E` with an inner product space over a type `𝕜`, any submodule `U` of `E` is orthogonal to its orthogonal complement `Uᗮ`, i.e., for all `x ∈ U` and `y ∈ Uᗮ`, `∫ x · y = 0`.


theorem Quotient.map'_mk'' :
    ∀ {α : Sort u_1} {β : Sort u_2} {s₁ : Setoid α} {s₂ : Setoid β} (f : α → β) (h : (Setoid.r ⇒ Setoid.r) f f) (x : α),
      Quotient.map' f h (Quotient.mk'' x) = Quotient.mk'' (f x) :=
  by sorry

The theorem `Quotient.map'_mk''` states that for any types `α` and `β`, equipped with the equivalence relations `s₁` and `s₂` respectively, and for any function `f` from `α` to `β` that preserves the equivalence relationships, applying `Quotient.map'` to the quotient of an element under `f` is the same as forming the quotient of the image of the element under `f`. In other words, if `f` is a function that sends equivalent elements in `α` to equivalent elements in `β`, then mapping `f` over the quotient of an element `x` in `α` gives the same result as taking the quotient of `f(x)` in `β`.

For any functions `f` preserving equivalence relations `s₁` on `α` and `s₂` on `β`, Quotient.map' applied to `f` on the quotient of an element `x ∈ α` is equal to the quotient of `f(x)` in `β`.


Bornology.IsBounded.cthickening

theorem Bornology.IsBounded.cthickening :
    ∀ {α : Type u_2} [inst : PseudoMetricSpace α] {δ : ℝ} {E : Set α},
      Bornology.IsBounded E → Bornology.IsBounded (Metric.cthickening δ E) :=
  by sorry

The theorem `Bornology.IsBounded.cthickening` states that for any type `α` that is a pseudo metric space, any real number `δ`, and any set `E` of type `α`, if `E` is a bounded set (in the sense of the ambient bornology on `α`), then the `δ`-thickening of `E` is also a bounded set. In this context, the `δ`-thickening of a set `E` consists of those points that are at most `δ` away from `E` in terms of the infimum distance.

For any bounded set `E` in a pseudo metric space `α`, the `δ-`thickening of `E` is also a bounded set.


/-- Each pairwise difference is in the `vectorSpan`.  -/
theorem vsub_mem_vectorSpan :
    ∀ (k : Type u_1) {V : Type u_2} {P : Type u_3} [inst : Ring k] [inst_1 : AddCommGroup V] [inst_2 : Module k V]
      [inst_3 : AddTorsor V P] {s : Set P} {p1 p2 : P}, p1 ∈ s → p2 ∈ s → p1 -ᵥ p2 ∈ vectorSpan k s :=
  by sorry

This theorem states that for any pair of points `p1` and `p2` in a set `s` of points in an affine space (over a ring `k` with an associated vector space `V` and point module `P`), the vector difference of `p1` and `p2` belongs to the vector span of `s`. This vector span is a submodule in `V` generated by all pairwise differences of points in `s`. The theorem essentially says that any pairwise difference of points in a set is a combination of other pairwise differences in the same set.

For any two points `p1` and `p2` in a set `s` of points in an affine space over a ring `k`, the vector difference `p1 - p2` lies in the submodule of `k-V` generated by all pairwise differences of points in `s`.


theorem Filter.EventuallyEq.isMinFilter_iff :
    ∀ {α : Type u_1} {β : Type u_2} [inst : Preorder β] {f g : α → β} {a : α} {l : Filter α},
      f =ᶠ[l] g → f a = g a → (IsMinFilter f l a ↔ IsMinFilter g l a) :=
  by sorry

This theorem states that for any two functions `f` and `g` mapping from a type `α` to a type `β` (where `β` is preordered), a certain point `a` of type `α`, and a filter `l` on `α`, if `f` and `g` become eventually equal at the filter `l` and `f a` equals `g a`, then `f` being a minimum filter at `a` with respect to `l` is equivalent to `g` being a minimum filter at `a` with respect to `l`. In other words, the property of being a minimum filter is preserved under eventual equality at a specific point in the domain.

If functions `f` and `g` from type `α` to a preordered type `β` become equal in filter `l` at point `a` where `f a = g a`, then `f` being a minimum filter for `a` with respect to `l` is equivalent to `g` being a minimum filter for `a` with respect to `l`.


/-- A nonzero monomorphism to a simple object is an isomorphism.  -/
theorem CategoryTheory.isIso_of_mono_of_nonzero :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
      {X Y : C} [inst_2 : CategoryTheory.Simple Y] {f : X ⟶ Y} [inst_3 : CategoryTheory.Mono f],
      f ≠ 0 → CategoryTheory.IsIso f :=
  by sorry

This theorem is a statement in the field of category theory, and it asserts the following: Given a category `C` with zero morphisms and an object `Y` in `C` that is simple, if `f` is a monomorphism (an injective morphism) from another object `X` to `Y` and `f` is not the zero morphism, then `f` is an isomorphism (a bijective morphism).

In a category with zero morphisms, if `f` is a non-zero monomorphism from object `X` to simple object `Y`, then `f` is an isomorphism.


theorem Cardinal.mk_iUnion_le_sum_mk :
    ∀ {α ι : Type u} {f : ι → Set α}, Cardinal.mk ↑(⋃ i, f i) ≤ Cardinal.sum fun i => Cardinal.mk ↑(f i) := by sorry

This theorem states that for any types `α` and `ι`, and any function `f` mapping from `ι` to a set of `α`, the cardinality (size) of the union of all sets `f i` (for all `i` in `ι`) is less than or equal to the total sum of the cardinalities of each individual set `f i`. In mathematical terms, it is saying that the cardinality of the union of sets is always less than or equal to the sum of the cardinalities of the individual sets. This is analogous to the principle that the total size of a union of sets is less than or equal to the sum of the sizes of those sets, because there may be overlapping elements.

For any function from a set to a type, the cardinality of its image (the sets' union) is less than or equal to the sum of the cardinalities of the sets in the domain.


theorem AddUnits.eq_iff : ∀ {α : Type u} [inst : AddMonoid α] {a b : AddUnits α}, ↑a = ↑b ↔ a = b := by sorry

This theorem, `AddUnits.eq_iff`, establishes a condition for equality between two additive units `a` and `b` in the context of an additive monoid `α`. Specifically, it states that the coercion of `a` and `b` to `α` are equal if and only if `a` and `b` themselves are equal. This means that if the underlying elements of `a` and `b` in `α` are equal, then the `AddUnits` `a` and `b` must also be equal, and vice versa.

Given an additive monoid `α`, for all additive units `a` and `b` in `α`, `a = b` if and only if `coe a = coe b`.


theorem ProbabilityTheory.kernel.iIndepFun.indepFun_mul_left :
    ∀ {α : Type u_1} {Ω : Type u_2} {ι : Type u_3} {_mα : MeasurableSpace α} {_mΩ : MeasurableSpace Ω}
      {κ : ↥(ProbabilityTheory.kernel α Ω)} {μ : MeasureTheory.Measure α} {β : Type u_8} {m : MeasurableSpace β}
      [inst : Mul β] [inst_1 : MeasurableMul₂ β] {f : ι → Ω → β} [inst_2 : ProbabilityTheory.IsMarkovKernel κ],
      ProbabilityTheory.kernel.iIndepFun (fun x => m) f κ μ →
        (∀ (i : ι), Measurable (f i)) →
          ∀ (i j k : ι), i ≠ k → j ≠ k → ProbabilityTheory.kernel.IndepFun (f i * f j) (f k) κ μ :=
  by sorry

This theorem states that for any types `α`, `Ω`, `ι`, and `β`, given measurable spaces `α` and `Ω`, a Markov kernel `κ`, a measure `μ`, a measurable space `m` for `β`, multiplication operation on `β`, the measurability of the binary multiplication operation, and a function `f` from `ι` to a function on `Ω` with output in `β`, if the function `f` is independent under `κ` and `μ` for any input `x` from `m`, and every `ι` indexed function `f i` is measurable, then for any three distinct indices `i`, `j` and `k` from `ι`, the product of the functions `f i` and `f j` is independent of the function `f k` under the kernel `κ` and measure `μ`. This theorem is a part of the mathematical field of Probability Theory.

If `κ` is a Markov kernel, `μ` is a measure, `m` is a measurable space for `β` with a measurable binary multiplication operation, `α`, `Ω`, `ι`, and `β` are types, `f : ι → Ω → β` is a measurable function independent of itself under `κ` and `μ` for all `x ∈ m`, and each `f i` is measurable, then for all distinct `i`, `j`, and `k` in `ι`, the functions `f i` and `f j` are independent of `f k` under `κ` and `μ` for the product of their outputs.


theorem Submodule.prod_top :
    ∀ {R : Type u_1} {M : Type u_4} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {M' : Type u_9}
      [inst_3 : AddCommMonoid M'] [inst_4 : Module R M'], Submodule.prod ⊤ ⊤ = ⊤ :=
  by sorry

This theorem states that for any semiring `R`, additive commutative monoid `M`, and module `R M`, as well as any additional additive commutative monoid `M'` and module `R M'`, the product of the top submodule (i.e., the whole module) with itself is again the top submodule. In terms of algebra, this theorem is saying that the product of the entire module with itself is still the entire module, reflecting the closure property of a module over its ring of scalars.

For any semiring `R`, additive commutative monoids `M` and `M'`, and `R`-modules `M` and `M'`, the top submodule of `M` is closed under the product operation with `M`, i.e., `⊤ M ⊤ M = ⊤ M`.


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

This theorem states that for any group `G` and given group elements `a`, `b`, and `c`, if the product of `b` and `a` equals `c`, then `a` is equal to the product of the inverse of `b` and `c`. Here, `b⁻¹` denotes the inverse of `b` in the group `G`. This theorem captures a key property of groups in abstract algebra.

If `a`, `b`, and `c` are group elements such that `b * a = c`, then `a = b⁻¹ * c`.


theorem OrderDual.ofDual_le_ofDual :
    ∀ {α : Type u_1} [inst : LE α] {a b : αᵒᵈ}, OrderDual.ofDual a ≤ OrderDual.ofDual b ↔ b ≤ a := by sorry

The theorem `OrderDual.ofDual_le_ofDual` states that for any type `α`, which has an order relation, and any two elements `a` and `b` of the dual of `α`, the element `a` is less than or equal to `b` in the dual order if and only if `b` is less than or equal to `a` in the original order. In essence, this theorem states that the `OrderDual.ofDual` function reverses the order relation.

For any type `α` with an order relation and any of its dual elements `a` and `b`, `a ≤ b` in the dual order if and only if `b ≤ a` in the original order.


/-- If a normed space is non-trivial, then the norm of the identity equals `1`.  -/
theorem ContinuousLinearMap.norm_id :
    ∀ {𝕜 : Type u_1} {E : Type u_4} [inst : NormedAddCommGroup E] [inst_1 : NontriviallyNormedField 𝕜]
      [inst_2 : NormedSpace 𝕜 E] [inst_3 : Nontrivial E], ‖ContinuousLinearMap.id 𝕜 E‖ = 1 :=
  by sorry

This theorem states that if we have a non-trivial normed space (denoted by `E`), then the norm of the identity map on that space equals `1`. Here, `𝕜` is a field (like the real or complex numbers) which is both normed and non-trivial (i.e., not all elements have zero norm). `E` is a vector space over `𝕜` which is also a topological space where the topology is defined by a norm. The identity map is a continuous linear map from the normed space to itself. In this context, the norm of a continuous linear map is a measure of how much it can "stretch" vectors in the normed space. The theorem is saying that the identity map, which doesn't stretch vectors at all, has norm `1`.

In a non-trivial normed space, the norm of the identity map is equal to 1.


theorem Filter.HasBasis.property_index :
    ∀ {α : Type u_1} {ι : Sort u_4} {l : Filter α} {p : ι → Prop} {s : ι → Set α} {t : Set α}
      (h : Filter.HasBasis l p s) (ht : t ∈ l), p ↑(Filter.HasBasis.index h t ht) :=
  by sorry

This theorem states that for any filter `l` on a type `α`, index type `ι`, and two functions `p : ι → Prop` and `s : ι → Set α`, if `l` has a basis according to `p` and `s`, and a set `t` belongs to `l`, then the property `p` holds for the index associated with `t`. In other words, if we find the index of a basis set such that `s i ⊆ t` using the `Filter.HasBasis.index` function, the property `p` will hold for this index. This shows a relationship between the filter, its basis, and the properties of the basis elements.

For any filter `l` on type `α` with basis according to `p : ι → Prop` and `s : ι → Set α`, if `t ∈ l`, then `p (Filter.HasBasis.index l p s t)` holds.


theorem CauSeq.mul_limZero_right :
    ∀ {α : Type u_1} {β : Type u_2} [inst : LinearOrderedField α] [inst_1 : Ring β] {abv : β → α}
      [inst_2 : IsAbsoluteValue abv] (f : CauSeq β abv) {g : CauSeq β abv}, CauSeq.LimZero g → CauSeq.LimZero (f * g) :=
  by sorry

The theorem `CauSeq.mul_limZero_right` states that for any given types `α` and `β` where `α` is a linear ordered field and `β` is a ring, and a function `abv` from `β` to `α` that is an absolute value, if `f` is a Cauchy sequence of `β` with respect to `abv` and `g` is another such Cauchy sequence that approaches zero, then the product of `f` and `g` also approaches zero. Here, a sequence is said to approach zero if for every positive number `ε`, there exists an index `i` such that the absolute value of every term indexed by `j ≥ i` is less than `ε`.

If `f` and `g` are Cauchy sequences of a ring `β` with respect to an absolute value function `abv` from `β` to a linear ordered field `α`, then their product approaches zero if both `f` and `g` approach zero.


theorem MvPolynomial.le_totalDegree :
    ∀ {R : Type u} {σ : Type u_1} [inst : CommSemiring R] {p : MvPolynomial σ R} {s : σ →₀ ℕ},
      s ∈ MvPolynomial.support p → (Finsupp.sum s fun x e => e) ≤ MvPolynomial.totalDegree p :=
  by sorry

The `MvPolynomial.le_totalDegree` theorem states that for any multivariate polynomial `p` over a commutative semiring `R` with variables indexed by set `σ`, and any monomial `s` in the support of `p` (i.e., a monomial with a non-zero coefficient in `p`), the sum of the exponents in the monomial `s` is less than or equal to the total degree of the polynomial `p`. The total degree of a multivariate polynomial is defined as the maximum sum of the exponents over all its monomials.

For any multivariate polynomial `p` over a commutative semiring `R` with variables indexed by set `σ`, the degree of each monomial `s` in the support of `p` is less than or equal to the total degree of `p`.


theorem Nat.bitCasesOn_bit :
    ∀ {C : ℕ → Sort u} (H : (b : Bool) → (n : ℕ) → C (Nat.bit b n)) (b : Bool) (n : ℕ),
      Nat.bitCasesOn (Nat.bit b n) H = H b n :=
  by sorry

The theorem `Nat.bitCasesOn_bit` asserts that for any predicate `C` which is a function from natural numbers to some arbitrary type, and for any function `H` which maps a boolean `b` and a natural number `n` to an instance of `C(Nat.bit b n)`, and for any boolean `b` and natural number `n`, applying the `Nat.bitCasesOn` function to `Nat.bit b n` and `H` will always yield the same result as directly applying `H` to `b` and `n`. Essentially, it states that `Nat.bitCasesOn` correctly decomposes any natural number formed by appending a binary digit to another number.

For any predicate `C` and function `H`, the evaluation of `H (b, Nat.bit b n)` equals the application of `Nat.bitCasesOn` to `Nat.bit b n` and `H`.


theorem MeasureTheory.inducedOuterMeasure_eq :
    ∀ {α : Type u_1} [inst : MeasurableSpace α] {m : (s : Set α) → MeasurableSet s → ENNReal} (m0 : m ∅ ⋯ = 0),
      (∀ ⦃f : ℕ → Set α⦄ (hm : ∀ (i : ℕ), MeasurableSet (f i)),
          Pairwise (Disjoint on f) → m (⋃ i, f i) ⋯ = ∑' (i : ℕ), m (f i) ⋯) →
        ∀ {s : Set α} (hs : MeasurableSet s), ↑(MeasureTheory.inducedOuterMeasure m ⋯ m0) s = m s hs :=
  by sorry

This theorem, `MeasureTheory.inducedOuterMeasure_eq`, states that for any type `α` in a measurable space, given a function `m` from a measurable set of `α` to the extended nonnegative real numbers (abbreviated as `ENNReal`), such that `m` of the empty set is zero, if for any sequence of measurable sets `(f i)` that are pairwise disjoint, the measure `m` of the union of these sets equals the sum of the measures of each set in the sequence, then for any measurable set `s`, the measure of `s` under the outer measure induced by `m` equals the original measure `m` of `s`.

In simpler terms, this theorem asserts that if a measure on a collection of measurable sets satisfies certain properties (it is zero on the empty set and additive over countable disjoint unions), then the outer measure it induces coincides with the original measure on these sets.

If a measure on a collection of measurable sets is additive and zero on the empty set, then it is equal to the outer measure induced by that measure on any measurable set.


Monotone.sup

/-- Pointwise supremum of two monotone functions is a monotone function.  -/
theorem Monotone.sup :
    ∀ {α : Type u} {β : Type v} [inst : Preorder α] [inst_1 : SemilatticeSup β] {f g : α → β},
      Monotone f → Monotone g → Monotone (f ⊔ g) :=
  by sorry

The theorem `Monotone.sup` states that for any two monotone functions `f` and `g`, from a preordered set `α` to a semilattice (with supremum operation) `β`, the pointwise supremum of these two functions, denoted as `f ⊔ g`, is also a monotone function. This means that if `a ≤ b` in the preordered set `α`, then `(f ⊔ g) a ≤ (f ⊔ g) b` in the semilattice `β`.

If `f` and `g` are monotone functions from a preordered set `α` to a semilattice `β` with supremum operation, then `f ⊔ g` is also a monotone function.


theorem IsAbsoluteValue.abv_mul :
    ∀ {S : Type u_5} [inst : OrderedSemiring S] {R : Type u_6} [inst_1 : Semiring R] (abv : R → S)
      [inst_2 : IsAbsoluteValue abv] (x y : R), abv (x * y) = abv x * abv y :=
  by sorry

This theorem states that for any ordered semiring `S` and any semiring `R`, given a function `abv : R → S` which is an absolute value function, the absolute value of the product of `x` and `y` (both elements of `R`) is equal to the product of the absolute values of `x` and `y`. That is, if `abv` is an absolute value function, then `abv (x * y) = abv x * abv y` for any `x` and `y` in `R`.

For any semiring `R` and absolute value function `abv : R → ℝ` from `R` to the real numbers, `abv (x * y) = abv x * abv y` for all `x, y` in `R`.


theorem AddSubmonoid.LocalizationMap.sec_spec :
    ∀ {M : Type u_1} [inst : AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [inst_1 : AddCommMonoid N]
      {f : AddSubmonoid.LocalizationMap S N} (z : N),
      z + (AddSubmonoid.LocalizationMap.toMap f) ↑(AddSubmonoid.LocalizationMap.sec f z).2 =
        (AddSubmonoid.LocalizationMap.toMap f) (AddSubmonoid.LocalizationMap.sec f z).1 :=
  by sorry

This theorem states that for any type `M` with an additive commutative monoid structure, a submonoid `S` of `M`, another type `N` with an additive commutative monoid structure, and a localization map `f` from `S` to `N`, for any element `z` of `N`, the sum of `z` and the application of the `toMap` function of `f` to the second element of the pair returned by the `sec` function of `f` applied to `z`, is equal to the result of applying the `toMap` function of `f` to the first element of the pair returned by the `sec` function of `f` applied to `z`. In other words, the theorem establishes an important property connecting the `sec` function and the `toMap` function in the context of localization maps in additive commutative monoid structures.

For any additive commutative monoid homomorphism (localization map) `f` from `S` to `N`, and for any `z` in `N`, we have `f (z + f! (s, t).2) = f (s + t)`, where `s` is the first component of `f! (z, t)` and `f!` is the localization map's section function.


Set.Pairwise.subtype

/-- **Alias** of the reverse direction of `pairwise_subtype_iff_pairwise_set`. -/
theorem Set.Pairwise.subtype :
    ∀ {α : Type u_1} (s : Set α) (r : α → α → Prop), Set.Pairwise s r → Pairwise fun x y => r ↑x ↑y := by sorry

The theorem `Set.Pairwise.subtype` establishes a connection between the concepts of pairwise property for sets and subtypes in a certain direction. Specifically, it states that for any set `s` of elements of some type `α` and any relation `r` between elements of `α`, if the relation `r` holds pairwise on the set `s` (meaning that `r` is true for all distinct pairs `x, y` in `s`), then the same relation `r` holds pairwise for all distinct elements `x` and `y` when they are viewed as elements of the subtype of `α` induced by `s`. Here, `↑x` and `↑y` denote the elements `x` and `y` viewed as elements of the said subtype.

If a relation holds pairwise between all distinct elements of a set, then it also holds pairwise between the same elements viewed as elements of the subtype induced by that set.


/-- Given a family of elements `x` for the sieve `S` generated by a presieve `R`, if `x` is restricted
to `R` and then extended back up to `S`, the resulting extension equals `x`.
 -/
theorem CategoryTheory.Presieve.extend_restrict :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {P : CategoryTheory.Functor Cᵒᵖ (Type w)} {X : C}
      {R : CategoryTheory.Presieve X}
      {x : CategoryTheory.Presieve.FamilyOfElements P (CategoryTheory.Sieve.generate R).arrows},
      CategoryTheory.Presieve.FamilyOfElements.Compatible x →
        CategoryTheory.Presieve.FamilyOfElements.sieveExtend (CategoryTheory.Presieve.FamilyOfElements.restrict ⋯ x) =
          x :=
  by sorry

The theorem `CategoryTheory.Presieve.extend_restrict` states that for a given category `C`, a presheaf `P` over the opposite category of `C`, and an object `X` in `C`, if we have a presieve `R` on `X` and a family `x` of elements for the sieve `S` generated by `R` that is compatible, then if we restrict `x` to `R` and then extend it back up to `S`, the resulting extension will be equal to `x`. In other words, in the given context of category theory, the process of restricting a family of elements to a smaller presieve and then extending it back does not change the original family of elements, provided they are compatible.

For a presheaf over the opposite category of a given category, restricting and then extending a compatible family of elements through a compatible presieve results in the original family.


theorem Localization.r_iff_exists :
    ∀ {M : Type u_1} [inst : CommMonoid M] {S : Submonoid M} {x y : M × ↥S},
      (Localization.r S) x y ↔ ∃ c, ↑c * (↑y.2 * x.1) = ↑c * (↑x.2 * y.1) :=
  by sorry

This theorem states that for any commutative monoid `M`, a submonoid `S` of `M`, and any pairs `x` and `y` from `M` and `S`, `(Localization.r S) x y` is true if and only if there exists a `c` in `S` such that the product of `c`, the second element of `y` and the first element of `x` equals the product of `c`, the second element of `x` and the first element of `y`. The `Localization.r S` relation is a specific congruence relation related to the localization of the commutative monoid `M` at the submonoid `S`. This theorem forms the foundation of the notion of "equivalence" in the localization of a commutative monoid at a submonoid.

For any commutative monoid `M`, submonoid `S`, and elements `x, y` in `M`, `Localization.r S x y` holds if and only if there exists `c` in `S` such that `c * y.2 * x.1 = c * x.2 * y.1`.


/-- The range of a function from a `Unique` type contains just the
function applied to its single value.  -/
theorem Set.range_unique : ∀ {α : Type u_1} {ι : Sort u_4} {f : ι → α} [h : Unique ι], Set.range f = {f default} := by
  sorry

This theorem states that the range of a function `f` originating from a 'Unique' type, denoted by `ι`, only contains the function applied to its single unique value. In other words, if `f` is a function from a type, `ι`, with only one possible value (a unique type), then the set of all possible outputs of `f` (the range of `f`) is simply the set containing just the result of applying `f` to that one possible input value.

If `f` is a function from a type with a unique value, then the range of `f` is the set containing the image of that unique value under `f`.


theorem Finite.injective_iff_bijective :
    ∀ {α : Type u_1} [inst : Finite α] {f : α → α}, Function.Injective f ↔ Function.Bijective f := by sorry

The theorem `Finite.injective_iff_bijective` states that for any type `α`, given it is finite (as indicated by `Finite α`), for any function `f` from `α` to `α`, the function `f` is injective (meaning that if `f x = f y`, then `x = y`) if and only if `f` is bijective (meaning that `f` is both injective and surjective, where surjective means that for every element in the codomain there exists an element in the domain that is mapped to it). This theorem essentially says that in the realm of finite sets, injectivity of a function is equivalent to its bijectivity.

A function from a finite type to itself is injective if and only if it is bijective.


theorem CategoryTheory.Limits.Multicofork.fst_app_right :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {I : CategoryTheory.Limits.MultispanIndex C}
      (K : CategoryTheory.Limits.Multicofork I) (a : I.L),
      K.ι.app (CategoryTheory.Limits.WalkingMultispan.left a) =
        CategoryTheory.CategoryStruct.comp (I.fst a) (CategoryTheory.Limits.Multicofork.π K (I.fstFrom a)) :=
  by sorry

This theorem states that for any category `C`, any multispan index `I` in `C`, any multicofork `K` over `I`, and any object `a` from the left side of `I`, the application of the natural transformation `ι` of `K` to the morphism `WalkingMultispan.left a` is equal to the composition of the first morphism from `a` and the morphism from `I.fstFrom a` to the vertex of `K`. This is a condition for `K` to be a multicofork, which is a type of cocone in category theory. Here, `WalkingMultispan.left a` represents a morphism in the multispan, `I.fst a` represents the first morphism from `a`, and `CategoryTheory.Limits.Multicofork.π K (I.fstFrom a)` represents the morphism from the right side of the multispan to the vertex of the multicofork.

 For any multicofork $K$ over index $I$ in category $C$ and object $a$ in $C$, the following diagram commutes:
$$
\xymatrix{
a \ar[rr]^{\text{WalkingMultispan.left } a} \ar[rd]_{I.fst a} & & K.dom \\
& I.fstFrom a \ar[ur]_{\pi_K (I.fst a)}
}
$$
where $\pi_K$ is the natural transformation of $K$.


theorem Finset.sum_div :
    ∀ {ι : Type u_1} {α : Type u_2} [inst : DivisionSemiring α] (s : Finset ι) (f : ι → α) (a : α),
      (Finset.sum s fun i => f i) / a = Finset.sum s fun i => f i / a :=
  by sorry

The theorem `Finset.sum_div` states that for any set `s` of elements of type `ι`, any function `f` from `ι` to a type `α` that has a division semiring structure, and any value `a` of type `α`, the division of the sum of `f x` over all elements `x` in `s` by `a` is equal to the sum over `s` of the division of `f x` by `a`. In mathematical notation, it's saying that $\frac{\sum_{x\in s} f(x)}{a} = \sum_{x\in s} \frac{f(x)}{a}$.

For any set `s`, function `f` from `s` to a division semiring with identity element `a`, the sum of `f x / a` over all `x` in `s` is equal to the division of the sum of `f x` by `a`.


theorem TypeVec.split_dropFun_lastFun :
    ∀ {n : ℕ} {α : TypeVec.{u_1} (n + 1)} {α' : TypeVec.{u_2} (n + 1)} (f : TypeVec.Arrow α α'),
      TypeVec.splitFun (TypeVec.dropFun f) (TypeVec.lastFun f) = f :=
  by sorry

The theorem `TypeVec.split_dropFun_lastFun` states that for any natural number `n`, any two `n+1`-tuples of types `α` and `α'`, and any arrow `f` from `α` to `α'` in the category of `TypeVec`, splitting `f` into a prefix function operating on all but the last element (obtained via `TypeVec.dropFun`) and a function operating on only the last element (obtained via `TypeVec.lastFun`), and then recombining them via `TypeVec.splitFun`, yields the original arrow `f`. Essentially, it verifies that the operations `TypeVec.splitFun`, `TypeVec.dropFun`, and `TypeVec.lastFun` are inverses of each other when used in this manner.

For any natural number `n`, any `(α :: TypeVec n)` and `(α' :: TypeVec n)`, and any function `f : α -> α'`, the composition of `TypeVec.splitFun (TypeVec.dropFun f) (TypeVec.lastFun f)` equals `f`.


theorem Fin.addCases_left :
    ∀ {m n : ℕ} {motive : Fin (m + n) → Sort u_1} {left : (i : Fin m) → motive (Fin.castAdd n i)}
      {right : (i : Fin n) → motive (Fin.natAdd m i)} (i : Fin m), Fin.addCases left right (Fin.castAdd n i) = left i :=
  by sorry

The theorem `Fin.addCases_left` states that for any natural numbers `m` and `n`, for any `motive` which is a type dependent on a `Fin (m + n)`, and for any `left` function mapping from `Fin m` to this `motive` and a `right` function mapping from `Fin n` to this `motive`, applying `Fin.addCases` to `left`, `right` and `Fin.castAdd n i` (where `i` is a `Fin m`) results in the same output as applying `left` to `i`. In essence, this theorem asserts that `Fin.addCases` applied to a value obtained by extending the range of `i` using `Fin.castAdd` is equivalent to just applying the `left` function to the original `i`.

For any natural numbers m and n, and any type-dependent motive, the application of Fin.addCases to left functions mapping from Fin m and right functions mapping from Fin n, along with Fin.castAdd, is equivalent to simply applying the left function to elements of Fin m.


/-- In a strictly convex space, two vectors `x`, `y` are in the same ray if and only if the triangle
inequality for `x` and `y` becomes an equality.  -/
theorem sameRay_iff_norm_add :
    ∀ {E : Type u_2} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [inst_2 : StrictConvexSpace ℝ E]
      {x y : E}, SameRay ℝ x y ↔ ‖x + y‖ = ‖x‖ + ‖y‖ :=
  by sorry

In a strictly convex space, two vectors `x` and `y` are considered to be in the same ray if and only if the triangle inequality for `x` and `y` turns into an equality. That is, the length (or norm) of the sum of `x` and `y` is equal to the sum of the lengths (or norms) of `x` and `y`. This forms the basis of the theorem `sameRay_iff_norm_add`.

In a more formal mathematical language, for vectors `x` and `y` in a strictly convex space `E`, the vectors are in the same ray (as defined by the `SameRay` function) if and only if the norm of `x + y` (`‖x + y‖`) is equal to the sum of the norms of `x` and `y` (`‖x‖ + ‖y‖`).

In a strictly convex space, two vectors are in the same ray if and only if their sum has the same norm as the sum of their individual norms.


IsUnit.op

theorem IsUnit.op : ∀ {M : Type u_1} [inst : Monoid M] {m : M}, IsUnit m → IsUnit (MulOpposite.op m) := by sorry

This theorem states that for any type `M` that forms a `Monoid`, if an element `m` of `M` is a unit (i.e., it has a two-sided inverse), then the corresponding element of the Multiplicative Opposite `Mᵐᵒᵖ` (obtained using the `MulOpposite.op` function) is also a unit. In other words, the property of being a unit is preserved under the operation of taking multiplicative opposites.

If `M` is a monoid and `m` in `M` is a unit, then the multiplicative opposite of `m` is also a unit.


IsPreirreducible.isPreconnected

theorem IsPreirreducible.isPreconnected :
    ∀ {α : Type u} [inst : TopologicalSpace α] {s : Set α}, IsPreirreducible s → IsPreconnected s := by sorry

The theorem `IsPreirreducible.isPreconnected` states that for any type `α` equipped with a topological structure, and for any set `s` of type `α`, if `s` is preirreducible (which means that there are no non-trivial pairs of disjoint open sets within `s`), then `s` is also preconnected. In the context of topology, a preconnected set is one where there is no non-trivial open partition. In other words, a preirreducible set in a topological space is always preconnected within that space.

A preirreducible set in a topological space is preconnected.


theorem Equiv.image.proof_1 : ∀ {α : Type u_2} {β : Type u_1} (e : α ≃ β) (s : Set α) (x : ↑s), e ↑x ∈ ⇑e '' s := by
  sorry

This theorem states that for any two types `α` and `β`, and an equivalence `e` from `α` to `β`, given a set `s` of type `α` and any element `x` of the set `s`, the image of `x` under the equivalence `e` is in the image of the set `s` under `e`. In other words, if we map a set from one type to another using an equivalence, every element in the original set will also be in the image set after the mapping.

For any equivalence `e` between types `α` and `β` and any set `s` of type `α`, for all `x ∈ s`, `e(x) ∈ s.image under e`.


theorem Set.bounded_lt_Iio :
    ∀ {α : Type u_1} [inst : Preorder α] (a : α), Set.Bounded (fun x x_1 => x < x_1) (Set.Iio a) := by sorry

The theorem `Set.bounded_lt_Iio` states that for any type `α` that has a preorder structure, and for any element `a` of `α`, the left-infinite right-open interval `(−∞, a)` is a bounded set, where the boundedness is defined with respect to the "less than" relation. In other words, there exists an element in `α` such that all elements in the interval are less than this element.

For any type `α` with a preorder and any `a` in `α`, the left-infinite right-open interval `(−∞, a)` is a bounded set with respect to the preorder relation.


theorem Real.rpow_lt_rpow_iff : ∀ {x y z : ℝ}, 0 ≤ x → 0 ≤ y → 0 < z → (x ^ z < y ^ z ↔ x < y) := by sorry

This theorem states that for all real numbers `x`, `y`, and `z`, given that `x` and `y` are non-negative (i.e., greater than or equal to zero), and `z` is strictly positive (greater than zero), then `x` raised to the power of `z` is less than `y` raised to the power of `z` if and only if `x` is less than `y`. Essentially, it's about how powers preserve the order of non-negative real numbers when the exponent is positive.

For all non-negative real numbers x, y, and positive real number z, x^z < y^z if and only if x < y.


theorem Complex.isOpenMap_im : IsOpenMap Complex.im := by sorry

The theorem `Complex.isOpenMap_im` states that the function that maps a complex number to its imaginary part, `Complex.im`, is an open map. In other words, if we take any open set of complex numbers, the set of their imaginary parts is also an open set in the real numbers.

The function `Complex.im` maps open sets of complex numbers to open sets in the real numbers.


theorem all_mem_nhds_filter :
    ∀ {X : Type u} {α : Type u_1} [inst : TopologicalSpace X] (x : X) (f : Set X → Set α),
      (∀ (s t : Set X), s ⊆ t → f s ⊆ f t) →
        ∀ (l : Filter α), (∀ s ∈ nhds x, f s ∈ l) ↔ ∀ (s : Set X), IsOpen s → x ∈ s → f s ∈ l :=
  by sorry

This theorem states that for any topological space `X` and any type `α`, given any point `x` in `X` and a function `f` from the sets of `X` to the sets of `α`, where `f` respects set inclusion in the sense that if one set `s` is a subset of another set `t`, then `f(s)` is a subset of `f(t)`. Then for any filter `l` of `α`, the condition that for each neighborhood `s` of `x`, `f(s)` belongs to `l` is equivalent to the condition that for each open set `s` containing `x`, `f(s)` belongs to `l`.

In other words, whether you take the neighborhood around `x` or any open set containing `x`, the image of this set under `f` is always in the filter `l` whenever the function `f` respects set inclusion.

For any topological space X and type α, if function f from subsets of X to subsets of α respects set inclusion and x is a point in X, then the filter l of α contains the image of every neighborhood of x if and only if it contains the image of every open set containing x.


theorem Set.smul_mem_smul :
    ∀ {α : Type u_2} {β : Type u_3} [inst : SMul α β] {s : Set α} {t : Set β} {a : α} {b : β},
      a ∈ s → b ∈ t → a • b ∈ s • t :=
  by sorry

This theorem states that for any two types `α` and `β` where `β` is a scalar multiplication space over `α`, and given two sets `s` of type `α` and `t` of type `β`, and two elements `a` from `s` and `b` from `t`, if `a` belongs to `s` and `b` belongs to `t`, then the result of the scalar multiplication of `a` and `b` (denoted as `a • b`) belongs to the set created by the scalar multiplication of `s` and `t` (denoted as `s • t`). In mathematical terms, if `a ∈ s` and `b ∈ t`, then `a • b ∈ s • t`.

For any types `α` and `β` with `β` a scalar multiplication space over `α`, and sets `s` of type `α` and `t` of type `β`, if `a ∈ s` and `b ∈ t`, then `a • b ∈ s • t`.


theorem BoxIntegral.Box.antitone_lower : ∀ {ι : Type u_1}, Antitone fun I => I.lower := by sorry

This theorem states that for any type `ι`, the function that maps a box `I` to its lower bound is antitone. In other words, if we have two boxes `a` and `b` such that `a` is less than or equal to `b`, then the lower bound of `b` is less than or equal to the lower bound of `a`. This is a property of order-reversing functions in the context of box integrals.

For any type `ι`, the function that maps a box `I` to its lower bound is order-reversing with respect to box inclusion.


/-- The `p`-adic norm of an integer is at most `1`.  -/
theorem padicNorm.of_int : ∀ {p : ℕ} [hp : Fact (Nat.Prime p)] (z : ℤ), padicNorm p ↑z ≤ 1 := by sorry

This theorem states that for any prime number `p` and any integer `z`, the `p`-adic norm of `z` is less than or equal to `1`. The `p`-adic norm is a function that takes a prime number `p` and a rational number `q`, and returns a rational number that is defined as `p` to the power of the negative of the `p`-adic valuation of `q` if `q` is not zero; if `q` is zero, the `p`-adic norm is `0`. Therefore, this theorem asserts a specific property of the `p`-adic norm when the input is an integer.

For any prime number `p` and integer `z`, the `p`-adic norm of `z` is less than or equal to 1.


theorem QuaternionAlgebra.coe_mul_eq_smul :
    ∀ {R : Type u_3} [inst : CommRing R] {c₁ c₂ : R} (r : R) (a : QuaternionAlgebra R c₁ c₂), ↑r * a = r • a := by sorry

This theorem states that for any commutative ring `R` and any elements `c₁`, `c₂`, and `r` of `R`, along with any element `a` of the Quaternion Algebra `QuaternionAlgebra R c₁ c₂`, the product of the coe function applied to `r` and `a` is equal to `r` scalar-multiplied by `a`. In other words, it says that for a quaternion algebra, multiplication by a scalar from the underlying commutative ring can be done by either multiplying by the ring element or scalar multiplication, and these two operations are equivalent.

For any commutative ring `R`, any quaternion algebra `a` in `QuaternionAlgebra R c₁ c₂`, and any scalar `r` in `R`, the product of `r` with `a` via scalar multiplication and via the `coe` function application is equal.


theorem Fin.modNat.proof_1 : ∀ {n m : ℕ} (i : Fin (m * n)), ↑i % n < n := by sorry

This theorem states that for any two natural numbers `n` and `m`, and any finite number `i` in the interval from 0 to `m * n`, the remainder of `i` when divided by `n` is always less than `n`. This corresponds to the general property of the modulo operation (`%`), which guarantees that the result is always in the range `[0, n)` for positive `n`.

For all natural numbers n and m, and all finite i in the range 0 <= i < m * n, the remainder i % n < n holds.


/-- In a linearly ordered field with the order topology, if `f` tends to `Filter.atTop` and `g`
tends to a negative constant `C` then `f * g` tends to `Filter.atBot`.  -/
theorem Filter.Tendsto.atTop_mul_neg :
    ∀ {𝕜 : Type u_1} {α : Type u_2} [inst : LinearOrderedField 𝕜] [inst_1 : TopologicalSpace 𝕜]
      [inst_2 : OrderTopology 𝕜] {l : Filter α} {f g : α → 𝕜} {C : 𝕜},
      C < 0 →
        Filter.Tendsto f l Filter.atTop →
          Filter.Tendsto g l (nhds C) → Filter.Tendsto (fun x => f x * g x) l Filter.atBot :=
  by sorry

In a linearly ordered field, equipped with the order topology, the theorem states that if a function `f` tends towards infinity (represented by `Filter.atTop`) and another function `g` tends towards a negative constant `C`, then the multiplication of these two functions `f * g` tends towards negative infinity (represented by `Filter.atBot`). This is to say, as the function `f` grows very large and `g` approaches a negative constant, their product becomes increasingly negative.

In a linearly ordered field, if a function tends towards positive infinity and another function tends towards a negative constant, then their product tends towards negative infinity.


DifferentiableWithinAt.sub

theorem DifferentiableWithinAt.sub :
    ∀ {𝕜 : 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 g : E → F}
      {x : E} {s : Set E},
      DifferentiableWithinAt 𝕜 f s x →
        DifferentiableWithinAt 𝕜 g s x → DifferentiableWithinAt 𝕜 (fun y => f y - g y) s x :=
  by sorry

The theorem `DifferentiableWithinAt.sub` states that, for all types `𝕜`, `E`, and `F` where `𝕜` is a nontrivially normed field, `E` is a normed additive commutative group, and `F` is a normed additive commutative group with `E` and `F` being normed spaces over `𝕜`, if you have two functions `f` and `g` from `E` to `F`, a point `x` in `E`, and a set `s` of `E`, then if `f` and `g` are differentiable at the point `x` within the set `s`, then the function that subtracts the outputs of `g` from `f` (i.e., `f y - g y` for all `y` in `E`) is also differentiable at the point `x` within the set `s`.

If `f` and `g` are differentiable at `x` within the set `s` in the normed spaces `E` and `F` over a nontrivially normed field `𝕜`, then the function `f - g` is differentiable at `x` within `s`.


theorem ENNReal.ofReal_lt_nat_cast : ∀ {p : ℝ} {n : ℕ}, n ≠ 0 → (ENNReal.ofReal p < ↑n ↔ p < ↑n) := by sorry

The theorem `ENNReal.ofReal_lt_nat_cast` states that for any real number `p` and a natural number `n` which is not equal to zero, the function `ENNReal.ofReal` applied to `p` is less than the natural number `n` if and only if `p` is less than `n`. In other words, for any non-zero natural number `n` and any real number `p`, the inequality condition `p < n` holds true if and only if `ENNReal.ofReal(p) < n`.

For any non-zero natural number `n` and real number `p`, `ENNReal.ofReal(p) < n` if and only if `p < n`.


/-- If `𝔖 : Set (Set α)` is nonempty and directed and `𝓑` is a filter basis of `𝓤 β`, then the
uniformity of `α →ᵤ[𝔖] β` admits the family `{(f, g) | ∀ x ∈ S, (f x, g x) ∈ V}` for `S ∈ 𝔖` and
`V ∈ 𝓑` as a filter basis.  -/
theorem UniformOnFun.hasBasis_uniformity_of_basis :
    ∀ (α : Type u_1) (β : Type u_2) {ι : Type u_4} [inst : UniformSpace β] (𝔖 : Set (Set α)),
      Set.Nonempty 𝔖 →
        DirectedOn (fun x x_1 => x ⊆ x_1) 𝔖 →
          ∀ {p : ι → Prop} {s : ι → Set (β × β)},
            Filter.HasBasis (uniformity β) p s →
              Filter.HasBasis (uniformity (UniformOnFun α β 𝔖)) (fun Si => Si.1 ∈ 𝔖 ∧ p Si.2) fun Si =>
                UniformOnFun.gen 𝔖 Si.1 (s Si.2) :=
  by sorry

This theorem states that if we have a nonempty and directed set `𝔖` of subsets of `α` and `𝓑` is a filter basis of the uniformity of `β` (a uniform space), then the uniformity of the type of functions from `α` to `β` equipped with the structure of uniform convergence on `𝔖` admits a filter basis composed of the pairs of functions `(f, g)` such that for every `x` in `S` (where `S` is an element of `𝔖`), the pair `(f x, g x)` is in `V` (where `V` is an element of `𝓑`). In other words, the uniformity of these functions has a basis that reflects the uniform convergence on `𝔖` and the uniform structure of `β`.

Given a nonempty and directed set `𝔖` of subsets of `α` and a filter basis `𝓑` of the uniformity of a uniform space `β`, the uniformity of functions from `α` to `β` with the structure of uniform convergence on `𝔖` has a filter basis consisting of pairs `(f, g)` of functions such that `(fx, gx)` is in `V` for all `V` in `𝓑` and `x` in `S` for some `S` in `𝔖`.


theorem Filter.HasBasis.uniformContinuousOn_iff :
    ∀ {α : Type ua} {β : Type ub} {ι : Sort u_1} [inst : UniformSpace α] {ι' : Sort u_2} [inst_1 : UniformSpace β]
      {p : ι → Prop} {s : ι → Set (α × α)},
      Filter.HasBasis (uniformity α) p s →
        ∀ {q : ι' → Prop} {t : ι' → Set (β × β)},
          Filter.HasBasis (uniformity β) q t →
            ∀ {f : α → β} {S : Set α},
              UniformContinuousOn f S ↔
                ∀ (i : ι'), q i → ∃ j, p j ∧ ∀ x ∈ S, ∀ y ∈ S, (x, y) ∈ s j → (f x, f y) ∈ t i :=
  by sorry

The theorem `Filter.HasBasis.uniformContinuousOn_iff` states that for any types `α` and `β`, any sorts `ι` and `ι'`, given two uniform spaces over `α` and `β`, if the uniformity of `α` has a basis characterized by the property `p` and the set function `s`, and the uniformity of `β` has a basis characterized by the property `q` and the set function `t`, then for any function `f` from `α` to `β` and any set `S` of `α`, the function `f` is uniformly continuous on `S` if and only if for every element `i` of `ι'` such that `q i` holds, there exists an element `j` of `ι` such that `p j` holds and for all `x` and `y` in `S`, if `(x, y)` belongs to `s j` then `(f x, f y)` belongs to `t i`.

In simpler terms, it says that a function is uniformly continuous if for a given closeness in the output (β), no matter where we are in the set `S`, we can find a closeness in the input (α) such that if any two points in the set `S` are that close in the input, their images under the function are close in the output. Closeness is defined using the uniformity filters of the respective spaces.

A function between uniform spaces is uniformly continuous on a set if and only if for every basis element of the target space's uniformity, there exists a basis element of the domain space's uniformity such that their corresponding sets imply the continuity of the function between the elements in the set.


theorem Equiv.cast_eq_iff_heq : ∀ {α β : Sort u_1} (h : α = β) {a : α} {b : β}, (Equiv.cast h) a = b ↔ HEq a b := by
  sorry

This theorem, `Equiv.cast_eq_iff_heq`, states that for any two types `α` and `β` in a universe `u_1`, given a proof `h` of their equality, and for any elements `a` of type `α` and `b` of type `β`, the application of the equivalence `Equiv.cast h` to `a` is equal to `b` if and only if `a` and `b` are heterogeneously equal, denoted as `HEq a b`. In other words, it relates the equality of types (`α = β`), their equivalence (`α ≃ β`) and heterogeneous equality of their elements.

For any types `α` and `β` equal in a universe `u_1`, and for any `a : α` and `b : β`, `Equiv.cast (eq.refl a) = b` if and only if `a` and `b` are heterogeneously equal.


theorem Set.ordConnected_biInter :
    ∀ {α : Type u_1} [inst : Preorder α] {ι : Sort u_3} {p : ι → Prop} {s : (i : ι) → p i → Set α},
      (∀ (i : ι) (hi : p i), Set.OrdConnected (s i hi)) → Set.OrdConnected (⋂ i, ⋂ (hi : p i), s i hi) :=
  by sorry

This theorem states that for any type `α` with a preorder relation, given an indexed collection of sets `{s i hi}` indexed by `ι` and filtered by a property `p`, if each of these sets is ordinally connected (i.e., any two elements in the set can be connected by a non-decreasing sequence), then their intersection is also ordinally connected. In other words, if each of the sets `{s i hi}` is such that for any two elements `a` and `b` in it with `a ≤ b`, all elements `c` with `a ≤ c ≤ b` are also in the set, then the same property holds for the intersection of all these sets.

If each set in an indexed collection of ordinally connected sets filtered by a property satisfies the property that any two elements related by a preorder relation have all elements related by that preorder relation between them, then their intersection is also ordinally connected.


theorem List.length_eq_countP_add_countP :
    ∀ {α : Type u_1} (p : α → Bool) (l : List α),
      List.length l = List.countP p l + List.countP (fun a => decide ¬p a = true) l :=
  by sorry

The theorem `List.length_eq_countP_add_countP` states that for any list `l` of elements of some type `α` and any predicate `p` mapping elements of `α` to boolean values, the length of the list `l` is equal to the sum of the counts of elements of `l` that satisfy the predicate `p` and the elements of `l` that do not satisfy the predicate `p`. In other words, it shows that the total number of elements in a list is equal to the number of elements that pass a certain condition plus the number of elements that fail the same condition.

In mathematical terms, if we denote with `|l|` the length of the list `l`, with `#p(l)` the count of elements satisfying the predicate `p`, and with `#¬p(l)` the count of elements not satisfying `p`, the theorem can be expressed as `|l| = #p(l) + #¬p(l)`.

The length of a list equals the number of elements satisfying a given predicate plus the number of elements not satisfying it.


theorem Multiset.prod_map_mul :
    ∀ {ι : Type u_1} {α : Type u_2} [inst : CommMonoid α] {m : Multiset ι} {f g : ι → α},
      Multiset.prod (Multiset.map (fun i => f i * g i) m) =
        Multiset.prod (Multiset.map f m) * Multiset.prod (Multiset.map g m) :=
  by sorry

This theorem, `Multiset.prod_map_mul`, states that for any type `ι`, type `α` with a commutative monoid structure, multiset `m` of type `ι`, and functions `f` and `g` mapping from `ι` to `α`, the product of the multiset obtained by mapping each element in `m` to the product of `f i` and `g i` (where `i` is an element in `m`) equals the product of the multiset obtained by mapping each element in `m` via `f` multiplied by the product of the multiset obtained by mapping each element in `m` via `g`. In mathematical terms, we can express this as $\prod_{i \in m} (f(i)g(i)) = (\prod_{i \in m} f(i))(\prod_{i \in m} g(i))$.

The product of multisets obtained by mapping each element in a multiset to the product of two functions is equal to the product of the multisets obtained by mapping each element to each function separately, for any commutative monoid type and commutative monoid structure on its functions.


/-- A closed ball is closed in the weak-* topology. We don't have a name for `E →SL[σ] F` with
weak-* topology in `mathlib`, so we use an equivalent condition (see `isClosed_induced_iff'`).  -/
theorem ContinuousLinearMap.is_weak_closed_closedBall :
    ∀ {𝕜 : Type u_1} {𝕜₂ : Type u_2} {F : Type u_6} [inst : NormedAddCommGroup F] [inst_1 : NontriviallyNormedField 𝕜]
      [inst_2 : NontriviallyNormedField 𝕜₂] [inst_3 : NormedSpace 𝕜₂ F] {σ₁₂ : 𝕜 →+* 𝕜₂} {E' : Type u_11}
      [inst_4 : SeminormedAddCommGroup E'] [inst_5 : NormedSpace 𝕜 E'] [inst_6 : RingHomIsometric σ₁₂]
      (f₀ : E' →SL[σ₁₂] F) (r : ℝ) ⦃f : E' →SL[σ₁₂] F⦄,
      ⇑f ∈ closure (DFunLike.coe '' Metric.closedBall f₀ r) → f ∈ Metric.closedBall f₀ r :=
  by sorry

This theorem states that a closed ball is closed in the weak-* topology. Specifically, for any normed additive commutative group `F`, any nontrivially normed fields `𝕜` and `𝕜₂`, a normed space over `𝕜₂` with type `F`, a seminormed additive commutative group `E'`, a normed space over `𝕜` with type `E'`, a ring homomorphism `σ₁₂` that is isometric, a continuous linear map `f₀` from `E'` to `F` under the ring homomorphism `σ₁₂`, and a real number `r`, if a function `f` is within the closure of the image of the function `DFunLike.coe` applied to the closed ball around `f₀` with radius `r`, then `f` is in the closed ball around `f₀` with radius `r` itself. In other words, the weak-* topology preserves the "closeness" of elements in a closed ball.

In a normed additive commutative group `F` over a nontrivially normed field `𝕜₂`, a seminormed additive commutative group `E'` over a normed field `𝕜`, and for a ring homomorphism `σ₁₂` that is isometric, a continuous linear map `f₀` from `E'` to `F`, and real number `r`, the weak-* closed ball around `f₀` with radius `r` is closed under the weak-* topology, meaning that any function `f` in the closure of this ball belongs to the ball itself.


theorem MeasureTheory.Measure.count_empty :
    ∀ {α : Type u_1} [inst : MeasurableSpace α], ↑↑MeasureTheory.Measure.count ∅ = 0 := by sorry

This theorem states that for any type `α` endowed with a measurable space structure, the counting measure of the empty set is equal to zero. In simpler words, it states that there are no elements to count in an empty set, hence its measure or size is zero.

For any measurable space `(α, Σ)`, the measure of the empty set `∅` is 0, i.e., `∫ₗ(1 : Σ → Prop) d(measure ∅) = 0`.


theorem conj_trivial :
    ∀ {R : Type u} [inst : CommSemiring R] [inst_1 : StarRing R] [inst_2 : TrivialStar R] (a : R),
      (starRingEnd R) a = a :=
  by sorry

This theorem states that for any type `R` that is a commutative semiring and also a star ring with the trivial star operation, if `a` is an element of `R`, then the star of `a` is equal to `a` itself. More formally, this theorem says that for any `a` in `R`, `starRingEnd R a = a`. The `starRingEnd R` function applies the star operation to `a`, and the `TrivialStar` class asserts that the star operation is the identity. This theorem is therefore a specification of the behavior of the star operation in a commutative semiring that is also a star ring with trivial star operation.

In a commutative semiring `R` with trivial star operation, the star of any element `a` in `R` equals `a` itself.


theorem TietzeExtension.of_tvs :
    ∀ (𝕜 : Type v) [inst : NontriviallyNormedField 𝕜] {E : Type w} [inst_1 : AddCommGroup E] [inst_2 : Module 𝕜 E]
      [inst_3 : TopologicalSpace E] [inst_4 : TopologicalAddGroup E] [inst_5 : ContinuousSMul 𝕜 E] [inst_6 : T2Space E]
      [inst_7 : FiniteDimensional 𝕜 E] [inst_8 : CompleteSpace 𝕜] [inst : TietzeExtension 𝕜], TietzeExtension E :=
  by sorry

This theorem, called TietzeExtension.of_tvs, states that for any type '𝕜' where '𝕜' is a nontrivially normed field, given a type 'E' with the properties of being an additive commutative group, a '𝕜'-module, a topological space, a topological additive group, has continuous scalar multiplication with '𝕜', is T2 (has the Hausdorff property), is finite dimensional over '𝕜', and '𝕜' is a complete space, then 'E' has the property of the Tietze Extension. The Tietze Extension property is a concept from topology and functional analysis that concerns the extension of bounded real-valued functions defined on a subset of a topological space to the whole space.

Given a nontrivially normed field '𝕜' and a topological space 'E' that is a finite-dimensional '𝕜'-module, additive commutative group, topological additive group, has continuous scalar multiplication, is T2, and '𝕜' is complete, then every bounded real-valued function on a dense subset of 'E' can be extended to a continuous real-valued function on all of 'E'.


theorem countable_iInter_mem :
    ∀ {ι : Sort u_1} {α : Type u_2} {l : Filter α} [inst : CountableInterFilter l] [inst : Countable ι] {s : ι → Set α},
      ⋂ i, s i ∈ l ↔ ∀ (i : ι), s i ∈ l :=
  by sorry

This theorem, `countable_iInter_mem`, states that for any index set ι of any kind (`Sort u_1`), any type `α`, any filter `l` on `α` that satisfies the `CountableInterFilter` condition, and any function `s` mapping from ι to sets of `α`, the intersection of all sets `s i` (for every `i` in ι) is an element of the filter `l` if and only if every set `s i` is an element of `l`. In other words, in a context where countable intersections are preserved, the membership of the intersection of a countable family of sets in a filter is equivalent to the membership of every set in the family.

For any index set ι, type α, CountableInterFilter filter l on α, and function s from ι to sets of α, if for all i in ι, s i is in l, then the intersection of all s i is in l.


theorem Set.pi_univ_Ioi_subset :
    ∀ {ι : Type u_1} {α : ι → Type u_2} [inst : (i : ι) → Preorder (α i)] (x : (i : ι) → α i) [inst_1 : Nonempty ι],
      (Set.pi Set.univ fun i => Set.Ioi (x i)) ⊆ Set.Ioi x :=
  by sorry

The theorem `Set.pi_univ_Ioi_subset` states that for any index type `ι`, any family of types `α` indexed by `ι` where each type `α i` is a preorder, and any dependent function `x : Π i, α i`, the set of all dependent functions `f` such that `f a` is greater than `x a` for all `a` in the universe of `ι` is a subset of the set of all dependent functions `g` such that `g` is greater than `x`. It requires the condition that `ι` is a nonempty type.

In other words, the left-open right-infinite intervals of each `α i` defined by `x i` combine to form a subset of the left-open right-infinite interval of the dependent functions defined by `x`.

For any nonempty index type `ι` and family `α i` of preorders indexed by `ι` with dependent function `x : Π i, α i`, the set of functions `f` such that `f a > x a` for all `a : ι` is a subset of the set of functions `g` such that `g > x`.


/-- If `χ` is a multiplicative function such that `J(a | p) = χ p` for all odd primes `p`,
then `J(a | b)` equals `χ b` for all odd natural numbers `b`.  -/
theorem jacobiSym.value_at :
    ∀ (a : ℤ) {R : Type u_1} [inst : CommSemiring R] (χ : R →* ℤ),
      (∀ (p : ℕ) (pp : Nat.Prime p), p ≠ 2 → legendreSym p a = χ ↑p) → ∀ {b : ℕ}, Odd b → jacobiSym a b = χ ↑b :=
  by sorry

The theorem `jacobiSym.value_at` states that for any integer `a` and any commutative semiring `R`, if `χ` is a multiplicative function such that the Jacobi symbol `J(a | p)` equals `χ p` for all odd prime numbers `p`, then the Jacobi symbol `J(a | b)` equals `χ b` for all odd natural numbers `b`. In other words, if a multiplicative function `χ` maps odd primes to their corresponding Jacobi symbols with respect to `a`, then this function will also map any odd natural number to its corresponding Jacobi symbol with respect to `a`.

If `χ` is a multiplicative function satisfying `J(a | p) = χ p` for all odd prime numbers `p`, then `J(a | b) = χ b` for all odd natural numbers `b`.


theorem MeasureTheory.Measure.restrict_add :
    ∀ {α : Type u_2} {_m0 : MeasurableSpace α} (μ ν : MeasureTheory.Measure α) (s : Set α),
      (μ + ν).restrict s = μ.restrict s + ν.restrict s :=
  by sorry

This theorem states that for any given types `α`, for any `MeasurableSpace α` and for any two measures `μ` and `ν` on this measurable space, and for any set `s` of type `α`, the restriction of the sum of the two measures `μ` and `ν` to the set `s` is equal to the sum of the restrictions of `μ` and `ν` to `s`. In other words, this theorem is a property of measures stating that restricting the sum of two measures to a set equals the sum of the individual measures restricted to that set.

For any measurable spaces `(α, Σ)`, measures `μ, ν` on `Σ`, and set `s ∈ Σ`, the restriction of `μ + ν` to `s` equals the sum of the restrictions of `μ` and `ν` to `s`.


IsLeftRegular.subsingleton

/-- The element `0` is left-regular if and only if `R` is trivial.  -/
theorem IsLeftRegular.subsingleton : ∀ {R : Type u_1} [inst : MulZeroClass R], IsLeftRegular 0 → Subsingleton R := by
  sorry

The theorem `IsLeftRegular.subsingleton` states that for any type `R` equipped with a multiplication operation that also has a zero element (`MulZeroClass R`), the element `0` is left-regular if and only if `R` is a singleton set (i.e., `R` is trivial). In other words, the property of `0` being left-regular, which means that multiplication on the left by `0` is a function that never maps different elements to the same element, is equivalent to the condition that `R` contains at most one element.

The element 0 of a type equipped with multiplication and a zero element is left-regular if and only if the type is a singleton.


theorem Set.inter_iInter :
    ∀ {β : Type u_2} {ι : Sort u_4} [inst : Nonempty ι] (s : Set β) (t : ι → Set β), s ∩ ⋂ i, t i = ⋂ i, s ∩ t i := by
  sorry

This theorem states that for any type `β` and any indexed type `ι` (where `ι` is nonempty), given a set `s` of `β` and a function `t` that maps from `ι` to a set of `β`, the intersection of set `s` with the intersection of all sets `t i` (where `i` ranges over `ι`) is equal to the intersection, over all `i`, of set `s` and the individual sets `t i`. In terms of set theory, this is expressing a distributive property of intersections, namely that the intersection of a set with the intersection of a family of sets can be computed by taking the intersection, for each set in the family, of the set with that set. In mathematical notation, this is saying that `s ∩ (∩i, t i) = ∩i, s ∩ t i`.

The theorem asserts that for any set `s` and a family of sets `{ti : ι | i ∈ ι}`, the intersection of `s` with the intersection of all `ti` is equal to the intersection of `s` with each `ti` over all `i` in `ι`. In symbols: `s ∩ (∧i, ti) = ∧i, s ∩ ti`.


theorem NNReal.div_le_iff : ∀ {a b r : NNReal}, r ≠ 0 → (a / r ≤ b ↔ a ≤ b * r) := by sorry

The theorem `NNReal.div_le_iff` is stating that for any nonnegative real numbers `a`, `b`, and `r`, given that `r` is not equal to zero, then the quotient of `a` divided by `r` is less than or equal to `b` if and only if `a` is less than or equal to the product of `b` and `r`. This theorem provides a way to compare fractions and products in the context of nonnegative real numbers.

For nonnegative real numbers `a`, `b`, and `r` with `r != 0`, `a / r <= b` if and only if `a <= b * r`.


theorem FreeAbelianGroup.map_comp_apply :
    ∀ {α : Type u} {β : Type v} {γ : Type w} {f : α → β} {g : β → γ} (x : FreeAbelianGroup α),
      (FreeAbelianGroup.map (g ∘ f)) x = (FreeAbelianGroup.map g) ((FreeAbelianGroup.map f) x) :=
  by sorry

The theorem `FreeAbelianGroup.map_comp_apply` states that for any types `α`, `β`, and `γ`, and any functions `f` from `α` to `β` and `g` from `β` to `γ`, the map induced by the composition of `f` and `g` on the free abelian group generated by `α` is equivalent to first applying the map induced by `f` and then applying the map induced by `g`. This is essentially a statement of functoriality of the free abelian group construction in the category of types and functions. It is a formalized version of the mathematical principle that composition of functions is associative in the context of free abelian groups.

The map induced by the composition of two functions between types is equal to the composition of the induced maps on the free abelian groups generated by those types.


theorem continuous_id_of_le : ∀ {α : Type u} {t t' : TopologicalSpace α}, t ≤ t' → Continuous id := by sorry

This theorem states that if you have any type `α` and two topological spaces `t` and `t'` over `α`, with `t` being a subset of `t'` (that is, `t` is finer than or equal to `t'`), then the identity function is continuous. In mathematical terms, if a topology `t` is less than or equal to a topology `t'` on a given set `α`, the identity function from `α` to `α` is a continuous function with respect to these topologies.

If `α` is a type and `t` is a topology on `α` that is finer than or equal to topology `t'` on `α`, then the identity function `id : α → α` is continuous from `(α, t)` to `(α, t')`.


theorem sup_sup_distrib_left : ∀ {α : Type u} [inst : SemilatticeSup α] (a b c : α), a ⊔ (b ⊔ c) = a ⊔ b ⊔ (a ⊔ c) := by
  sorry

This theorem, `sup_sup_distrib_left`, is a distributive property of the supremum or "join" operation (denoted by `⊔`) in a semilattice. It states that for any type 'α', which has a semilattice structure with a supremum operation, and for any three elements 'a', 'b', and 'c' of this type, the supremum of 'a' and the supremum of 'b' and 'c' is equal to the supremum of 'a' and 'b' and the supremum of 'a' and 'c'. In other words, in such a semilattice, the supremum operation distributes over itself.

In a semilattice with supremum operation, the supremum of any two elements is commutative and associative with respect to the supremum of a third element. (Or, more succinctly: `⊔` is idempotent and associative over itself in a semilattice.)


FreeGroup.map.comp

theorem FreeGroup.map.comp :
    ∀ {α : Type u} {β : Type v} {γ : Type w} (f : α → β) (g : β → γ) (x : FreeGroup α),
      (FreeGroup.map g) ((FreeGroup.map f) x) = (FreeGroup.map (g ∘ f)) x :=
  by sorry

This theorem states that for any three types `α`, `β`, and `γ` and any two functions `f : α → β` and `g : β → γ`, the composition of the group homomorphisms induced by the two functions is the same as the group homomorphism induced by the composition of the two functions, when applied to any element of the free group over `α`. In essence, this theorem ensures that the `FreeGroup.map` function respects the composition of functions, a property known in mathematics as functoriality.

For any groups `α`, `β`, `γ`, and functions `f : α → β` and `g : β → γ`, the group homomorphism induced by their composition `g ∘ f` on the free group over `α` is equal to the composition of the homomorphisms induced by `f` and `g`.


/-- Exactness of `L₀.X₂ ⟶ L₀.X₃ ⟶ L₃.X₁`.  -/
theorem CategoryTheory.ShortComplex.SnakeInput.L₁'_exact :
    ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.Abelian C]
      (S : CategoryTheory.ShortComplex.SnakeInput C),
      CategoryTheory.ShortComplex.Exact (CategoryTheory.ShortComplex.SnakeInput.L₁' S) :=
  by sorry

The theorem `CategoryTheory.ShortComplex.SnakeInput.L₁'_exact` states that for any type `C`, given it forms a category and is abelian, for any snake input `S` in the context of the short complex in category theory, the short complex `L₀.X₂ ⟶ L₀.X₃ ⟶ L₃.X₁` derived from `S` is exact. This means that the image of each morphism in the complex is equal to the kernel of the next morphism, a property important in the study of homological algebra.

In an abelian category `C`, the short exact sequence `0 ⟶ L₀.X₂ ⟶ L₀.X₃ ⟶ L₃.X₁ ⟶ 0` derived from a snake input `S` in the short complex is exact.


theorem IndexedPartition.some_index :
    ∀ {ι : Type u_1} {α : Type u_2} {s : ι → Set α} (hs : IndexedPartition s) (x : α),
      Setoid.Rel (IndexedPartition.setoid hs) (hs.some (hs.index x)) x :=
  by sorry

The theorem `IndexedPartition.some_index` states that for any indexed partition `s` of a type `α` indexed by a type `ι`, and for any element `x` of type `α`, the equivalence relation induced by the indexed partition `s` relates the element `x` with the element obtained by applying the `some` operation (which selects some element from each subset of the partition) to the index of `x`. In other words, each element `x` of `α` is in the same partition subset as the one selected by the `some` operation on its index in the partition.

For any indexed partition `s` of type `α` and element `x` of type `α`, `x` is in the same subset of `s` as the `some` element of the subset indexed by `x`.


/-- If `‖pₙ‖ rⁿ` is bounded in `n`, then the radius of `p` is at least `r`.  -/
theorem FormalMultilinearSeries.le_radius_of_bound :
    ∀ {𝕜 : Type u_1} {E : Type u_2} {F : Type u_3} [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F]
      (p : FormalMultilinearSeries 𝕜 E F) (C : ℝ) {r : NNReal},
      (∀ (n : ℕ), ‖p n‖ * ↑r ^ n ≤ C) → ↑r ≤ FormalMultilinearSeries.radius p :=
  by sorry

This theorem states that given a formal multilinear series `p` over a nontrivially normed field `𝕜`, a normed additive commutative group `E`, and a normed space `F` with `𝕜` as scalar field (annotated by `[inst : NontriviallyNormedField 𝕜]`, `[inst_1 : NormedAddCommGroup E]`, `[inst_2 : NormedSpace 𝕜 E]`, `[inst_3 : NormedAddCommGroup F]`, and `[inst_4 : NormedSpace 𝕜 F]`), if the series `‖pₙ‖ rⁿ` is bounded by a real number `C` for all natural numbers `n` (written as `∀ (n : ℕ), ‖p n‖ * ↑r ^ n ≤ C`), then the radius of the formal multilinear series `p` is greater than or equal to `r` (written as `↑r ≤ FormalMultilinearSeries.radius p`). Here `r` is a nonnegative real number defined as `NNReal` and the `‖pₙ‖` denotes the norm of `pₙ`.

If the norm of the coefficients of a formal multilinear series over a nontrivially normed field is bounded by a constant times the radius raised to the power of the degree for all degrees, then the radius of the series is greater than or equal to the constant.


theorem eventually_norm_pow_le :
    ∀ {α : Type u_1} [inst : SeminormedRing α] (a : α), ∀ᶠ (n : ℕ) in Filter.atTop, ‖a ^ n‖ ≤ ‖a‖ ^ n := by sorry

This theorem, `eventually_norm_pow_le`, states that for every type `α` which forms a seminormed ring, for any element `a` of `α`, after a certain natural number `n`, the norm of `a` to the power of `n` is less than or equal to the norm of `a` itself to the power of `n`. In other words, `∀ᶠ (n : ℕ) in Filter.atTop` means that this inequality holds eventually as `n` goes to infinity.

For every seminormed ring `α` and element `a` in `α`, there exists a natural number `n` such that for all `m ≥ n`, the norm of `a` raised to the power of `m` is less than or equal to the norm of `a` raised to the power of `n`.


theorem MeasureTheory.measure_iUnion_null_iff :
    ∀ {α : Type u_1} {ι : Sort u_5} [inst : MeasurableSpace α] {μ : MeasureTheory.Measure α} [inst_1 : Countable ι]
      {s : ι → Set α}, ↑↑μ (⋃ i, s i) = 0 ↔ ∀ (i : ι), ↑↑μ (s i) = 0 :=
  by sorry

The theorem `MeasureTheory.measure_iUnion_null_iff` states that for any type `α`, an index type `ι`, a measurable space over `α`, a measure `μ` on that measurable space, and a countable set `s : ι → Set α`, the measure of the union of all sets in `s` is zero if and only if the measure of each individual set in `s` is zero. In mathematical terms, it asserts that for any collection of subsets `{s_i}` in a measure space `(X, μ)`, we have `μ(⋃ s_i) = 0` if and only if `μ(s_i) = 0` for all `i`.

For any measurable space `(X, μ)` and countable collection `{s_i}` of measurable subsets with `μ(s_i) = 0` for all `i`, we have `μ(⋃ s_i) = 0`.


theorem mul_right_cancel_iff :
    ∀ {G : Type u_1} [inst : Mul G] [inst_1 : IsRightCancelMul G] {a b c : G}, b * a = c * a ↔ b = c := by sorry

This theorem states that for any type `G` that has a multiplication operation and satisfies the right cancellation property (meaning for all `a`, `b`, `c` in `G`, `a * b = a * c` implies `b = c`), the equality `b * a = c * a` is equivalent to `b = c`. This is analogous to being able to "cancel out" the `a` on both sides of the equation in ordinary arithmetic.

If `G` is a type with multiplication and right cancellation property, then `b * a = c * a` implies `b = c`.


theorem Polynomial.support_ofFinsupp :
    ∀ {R : Type u} [inst : Semiring R] (p : AddMonoidAlgebra R ℕ), Polynomial.support { toFinsupp := p } = p.support :=
  by sorry

This theorem states that for any semiring `R` and any polynomial `p` represented as an additive monoid algebra over `R`, the set of powers of `X` (i.e., `n`) with non-zero coefficients in the polynomial is exactly the same as the support of the monoid algebra `p`. In other words, the positions where the polynomial has non-zero coefficients correspond exactly to the elements of the additive monoid that are present in the monoid algebra.

For any semiring `R` and polynomial `p` over `R`, the set of exponents of non-zero coefficients in `p` is equal to the support of the additive monoid algebra generated by `p` over `R`.


/-- The `ratio` is equal to the distance ratio for any two points with nonzero finite distance.
`dist` and `nndist` versions below  -/
theorem Dilation.ratio_unique :
    ∀ {α : Type u_1} {β : Type u_2} {F : Type u_4} [inst : PseudoEMetricSpace α] [inst_1 : PseudoEMetricSpace β]
      [inst_2 : FunLike F α β] [inst_3 : DilationClass F α β] {f : F} {x y : α} {r : NNReal},
      edist x y ≠ 0 → edist x y ≠ ⊤ → edist (f x) (f y) = ↑r * edist x y → r = Dilation.ratio f :=
  by sorry

This theorem, `Dilation.ratio_unique`, states that for any two points with a nonzero and finite distance in a pseudo emetric space, the `ratio` of a dilation `f` is equal to the ratio of the distance between the images of the points under `f` and the original distance between the points. This applies for any function `f` that preserves distances (a dilation), as defined in the context of a `FunLike` function from the source to the target space, both of which are pseudo emetric spaces. The dilation's `ratio`, therefore, uniquely identifies the scaling of distances under the dilation.

In a pseudo metric space, for any two points with nonzero and finite distance, the ratio of their distances under a dilation function (preserving distances) is equal to the dilation function's scaling factor.


theorem IrreducibleSpace.isIrreducible_univ :
    ∀ (X : Type u_3) [inst : TopologicalSpace X] [inst_1 : IrreducibleSpace X], IsIrreducible Set.univ := by sorry

The theorem `IrreducibleSpace.isIrreducible_univ` asserts that for any type `X` equipped with a topological space structure and such that the topological space is irreducible (as specified by `IrreducibleSpace X`), the universal set (which contains all elements of `X`) is irreducible. In other words, the universal set is nonempty and there is no pair of disjoint open sets in it that cover it completely apart from the trivial pair where one of the sets is the empty set.

If `X` is an irreducible topological space, then its universal set is also an irreducible subset.


/-- Auxiliary lemma for `IsAdjoinRoot.lift`  -/
theorem IsAdjoinRoot.eval₂_repr_eq_eval₂_of_map_eq :
    ∀ {R : Type u} {S : Type v} [inst : CommRing R] [inst_1 : Ring S] {f : Polynomial R} [inst_2 : Algebra R S]
      {T : Type u_1} [inst_3 : CommRing T] {i : R →+* T} {x : T},
      Polynomial.eval₂ i x f = 0 →
        ∀ (h : IsAdjoinRoot S f) (z : S) (w : Polynomial R),
          h.map w = z → Polynomial.eval₂ i x (IsAdjoinRoot.repr h z) = Polynomial.eval₂ i x w :=
  by sorry

This theorem states that for any commutative rings `R`, `S`, and `T`, a given polynomial `f` with coefficients in `R`, an algebra structure on `S` over `R`, a ring homomorphism `i` from `R` to `T`, and a value `x` in `T` such that the evaluation of the polynomial `f` at `x` under the homomorphism `i` is zero. If `h` is a root of the polynomial `f` adjoined to `S`, for any `z` in `S` and any polynomial `w` in `R` such that the map from `h` to `w` equals `z`, then the evaluation of the representative of `z` under `h` at `x` under the homomorphism `i` is equal to the evaluation of the polynomial `w` at `x` under the homomorphism `i`. In simpler terms, it shows a relationship between the evaluation of a polynomial and its representative in the context of adjoined roots.

Given commutative rings R, S, T, a polynomial f over R, an algebra structure on S over R, a ring homomorphism i from R to T, a root h of f adjoined to S, and an element z in S with map h -> w = z, the evaluation of h under i at x (where f(h) = 0 and x in T) equals the evaluation of w under i at x for any polynomial w with map h -> z.


theorem Fin.rev_castSucc : ∀ {n : ℕ} (k : Fin n), Fin.rev (Fin.castSucc k) = Fin.succ (Fin.rev k) := by sorry

The theorem `Fin.rev_castSucc` states that for all natural numbers `n` and for all elements `k` of type `Fin n`, the operation of reversing the order of elements (`Fin.rev`) after embedding `k` into a larger finite set (`Fin.castSucc k`) is equivalent to the operation of first reversing the order of elements and then incrementing the resulting element (`Fin.succ (Fin.rev k)`). Essentially, this theorem is about the equivalence of two composite operations on elements of finite sets in Lean 4.

For all natural numbers `n` and elements `k` of `Fin n`, `Fin.rev (Fin.castSucc k)` is equivalent to `Fin.succ (Fin.rev k)`.


/-- Möbius inversion for functions to an `AddCommGroup`.  -/
theorem ArithmeticFunction.sum_eq_iff_sum_smul_moebius_eq :
    ∀ {R : Type u_1} [inst : AddCommGroup R] {f g : ℕ → R},
      (∀ n > 0, (Finset.sum (Nat.divisors n) fun i => f i) = g n) ↔
        ∀ n > 0, (Finset.sum (Nat.divisorsAntidiagonal n) fun x => ArithmeticFunction.moebius x.1 • g x.2) = f n :=
  by sorry

This theorem is known as the Möbius inversion for functions to an additive commutative group. It states that for all natural numbers `n` greater than 0, the sum of the function `f` over the divisors of `n` equals to the function `g` evaluated at `n` if and only if for all `n` greater than 0, the sum over the antidiagonal divisors of `n` of the Möbius function evaluated at the first element of the pair times the function `g` evaluated at the second element equals to the function `f` evaluated at `n`. In mathematical notation, we have $\sum_{i \mid n} f(i) = g(n)$ if and only if $\sum_{i,j :ij=n} \mu(i) . g(j) = f(n)$ for all $n > 0$. Here $\mu(i)$ refers to the Möbius function.

The Möbius function evaluations on the divisors of a natural number `n` are inverted by the function values on the pair of divisors `i` and `j` with product equal to `n`, i.e., $\sum_{i \mid n} \mu(i)g(i) = f(n)$ if and only if $\sum_{i,j : ij=n} g(i) = f(n)$.


theorem cauchySeq_finset_iff_tsum_vanishing :
    ∀ {α : Type u_1} {β : Type u_2} [inst : AddCommGroup α] [inst_1 : UniformSpace α] [inst_2 : UniformAddGroup α]
      {f : β → α},
      (CauchySeq fun s => Finset.sum s fun b => f b) ↔
        ∀ e ∈ nhds 0, ∃ s, ∀ (t : Set β), Disjoint t ↑s → ∑' (b : ↑t), f ↑b ∈ e :=
  by sorry

This theorem states that for any types `α` and `β`, with `α` being an additive commutative group equipped with a uniform space and being a uniform additive group, and `f` being a function from `β` to `α`, a sequence is a Cauchy sequence if and only if for every set `e` in the neighborhood of 0, there exists a finite set `s` such that for any set `t` of `β` that is disjoint from `s`, the infinite sum of the function `f` over `t` is an element of `e`. This essentially describes the conditions under which the sum of the elements of a sequence converges to a limit as the sequence becomes infinitely large.

A sequence in an additive commutative group equipped with a uniform structure converges to a limit if and only if for every neighborhood of zero, there exists a finite set such that the sum of the function values of any disjoint finite subset is in the neighborhood.


theorem Vector.get_tail_succ :
    ∀ {n : ℕ} {α : Type u_1} (v : Vector α (Nat.succ n)) (i : Fin n),
      Vector.get (Vector.tail v) i = Vector.get v (Fin.succ i) :=
  by sorry

This theorem, `Vector.get_tail_succ`, states that for any natural number `n` and any type `α`, if you have a vector `v` of length `n+1` with elements of type `α`, and an index `i` less than `n`, then getting the `i`th element of the tail of `v` is the same as getting the `i+1`th element of `v`. In simple terms, the theorem is saying that the tail of a vector effectively shifts the indices of the elements by one, which is a common property of list-like structures when you remove the head.

For any natural number `n` and type `α`, the `(i+1)`th element of a `n+1`-length vector `v` is equal to the `i`th element of its tail.


theorem isSelfAdjoint_zero : ∀ (R : Type u_1) [inst : AddMonoid R] [inst_1 : StarAddMonoid R], IsSelfAdjoint 0 := by
  sorry

The theorem `isSelfAdjoint_zero` states that for any type `R` which is an additive monoid and a star additive monoid (i.e., it has a star operation that interacts well with addition), the zero element of `R` is self-adjoint. In other words, applying the star operation to zero gives us zero itself. In mathematical terms, if `R` is a star add monoid, then `0* = 0`.

In a star additive monoid `R`, the zero element is self-adjoint, i.e., `0* = 0`.


theorem Filter.frequently_iff_neBot :
    ∀ {α : Type u} {l : Filter α} {p : α → Prop},
      (∃ᶠ (x : α) in l, p x) ↔ Filter.NeBot (l ⊓ Filter.principal {x | p x}) :=
  by sorry

This theorem states that for any type `α`, any filter `l` on `α`, and any property `p` of elements of `α`, the statement "there exist frequently (in the sense of the filter `l`) elements `x` of `α` such that `p(x)` holds" is equivalent to the statement "the infimum (or intersection) of the filter `l` and the principal filter of the set of elements `x` for which `p(x)` holds is not the bottom filter". The principal filter of a set `s` is defined as the collection of all supersets of `s`, and the bottom (or trivial) filter is the filter that contains all subsets of the set.

For any type `α`, filter `l` on `α`, and property `p` of elements of `α`, the filter `l` intersects the principal filter of elements `x` with `p(x)` holding is non-empty if and only if the infimum of `l` is not the bottom filter.


/-- An induction principle for closure membership. If `p` holds for `0`, `1`, and all elements
of `s`, and is preserved under addition and multiplication, then `p` holds for all elements
of the closure of `s`.  -/
theorem Subsemiring.closure_induction :
    ∀ {R : Type u} [inst : NonAssocSemiring R] {s : Set R} {p : R → Prop} {x : R},
      x ∈ Subsemiring.closure s →
        (∀ x ∈ s, p x) →
          p 0 → p 1 → (∀ (x y : R), p x → p y → p (x + y)) → (∀ (x y : R), p x → p y → p (x * y)) → p x :=
  by sorry

This theorem, named `Subsemiring.closure_induction`, states an induction principle for membership in the closure of a set in a non-associative semiring. Given any type `R` that forms a non-associative semiring, a set `s` of elements of that type, a property `p` that may hold for elements of `R`, and an element `x` of `R`, if `x` is in the subsemiring generated by the closure of `s`, then the following conditions imply that `p` holds for `x`:

* `p` holds for every element in `s`
* `p` holds for `0`
* `p` holds for `1`
* `p` is preserved under addition, meaning that for any two elements `x` and `y` in `R`, if `p` holds for `x` and `y`, then `p` holds for their sum `x + y`
* `p` is preserved under multiplication, meaning that for any two elements `x` and `y` in `R`, if `p` holds for `x` and `y`, then `p` holds for their product `x * y`.

In simpler terms, if a property holds for all elements in a set, and also holds for the zero and one elements, and is maintained when adding or multiplying any two elements for which the property holds, then this property holds for all elements in the subsemiring generated by the closure of the initial set.

If `s` is a set in a non-associative semiring `R`, `p` is a property that holds for all elements in `s`, `0`, and `1`, and is preserved under addition and multiplication, then `p` holds for every element in the subsemiring generated by the closure of `s`.


theorem Polynomial.Monic.mul_left_eq_zero_iff :
    ∀ {R : Type u} [inst : Semiring R] {p : Polynomial R},
      Polynomial.Monic p → ∀ {q : Polynomial R}, q * p = 0 ↔ q = 0 :=
  by sorry

This theorem states that for any semiring `R` and any polynomial `p` over `R` that is monic (i.e., its leading coefficient is 1), the product of `p` and any other polynomial `q` over `R` is zero if and only if `q` is zero. In other words, if `p` is a monic polynomial, then it has the property that multiplying it by another polynomial `q` results in a zero polynomial precisely when `q` is a zero polynomial.

For any semiring `R` and monic polynomial `p` over `R`, `p * q = 0` if and only if `q = 0`.