/-- **Alias** of the reverse direction of `Asymptotics.isBigO_norm_right`. -/
theorem Asymptotics.IsBigO.norm_right :
    ∀ {α : Type u_1} {E : Type u_3} {F' : Type u_7} [inst : Norm E] [inst_1 : SeminormedAddCommGroup F'] {f : α → E}
      {g' : α → F'} {l : Filter α}, f =O[l] g' → f =O[l] fun x => ‖g' x‖ :=
  by sorry

This theorem, "Asymptotics.IsBigO.norm_right", is an alias of the reverse direction of `Asymptotics.isBigO_norm_right`. It applies to functions `f` and `g'` mapping from a type `α` to types `E` and `F'` respectively, where `E` has a norm structure, `F'` is a semi-normed additive commutative group, and `l` is a filter on `α`. The theorem states that if `f` is Big O of `g'` at filter `l`, i.e., `f` grows no faster than `g'` in the limit as defined by `l`, then `f` is also Big O of the norm of `g'` at the same filter.

If `f` is Big O of `g'` at filter `l`, then `f` is Big O of the norm of `g'` at filter `l`, for functions `f` from type `α` to a normed type `E` and `g'` to a semi-normed additive commutative group `F'`, where `l` is a filter on `α`.


theorem himp_himp : ∀ {α : Type u_2} [inst : GeneralizedHeytingAlgebra α] (a b c : α), a ⇨ b ⇨ c = a ⊓ b ⇨ c := by sorry

This theorem states that for any type `α` that forms a Generalized Heyting Algebra, and for any three elements `a`, `b`, and `c` of this type, the Heyting implication of `a` to the Heyting implication of `b` to `c` equals the Heyting implication of `a` infimum `b` to `c`. Here, `⇨` is the Heyting implication, and `⊓` is the infimum (also known as the 'greatest lower bound' or 'meet').

For any type `α` forming a Generalized Heyting Algebra and any elements `a`, `b`, and `c` of `α`, `a ⇨ (b ⇨ c)` equals `(a ⊓ b) ⇨ c`.


theorem AlgEquiv.symm_comp :
    ∀ {R : Type uR} {A₁ : Type uA₁} {A₂ : Type uA₂} [inst : CommSemiring R] [inst_1 : Semiring A₁]
      [inst_2 : Semiring A₂] [inst_3 : Algebra R A₁] [inst_4 : Algebra R A₂] (e : A₁ ≃ₐ[R] A₂),
      AlgHom.comp ↑(AlgEquiv.symm e) ↑e = AlgHom.id R A₁ :=
  by sorry

This theorem states that for any commutative semiring `R` and semirings `A₁` and `A₂` over `R` that also possess algebra structures, and for any algebra equivalence `e` from `A₁` to `A₂`, if you compose the algebra homomorphism corresponding to the inverse of `e` with the algebra homomorphism corresponding to `e`, you will get the identity algebra homomorphism on `A₁`. This is the algebraic version of the fact that applying a function followed by its inverse gives you the original input back, or formally, for a function `f` and its inverse `f⁻¹`, `f⁻¹(f(x)) = x` for all `x` in the domain of `f`.

For any commutative semirings `R` with algebra structures `A₁` and `A₂` over `R`, and an algebra equivalence `e` from `A₁` to `A₂`, the composition of `e.algebraMap.inv` and `e.algebraMap` is the identity algebra homomorphism on `A₁`.


theorem PrimeSpectrum.zeroLocus_span :
    ∀ {R : Type u} [inst : CommSemiring R] (s : Set R),
      PrimeSpectrum.zeroLocus ↑(Ideal.span s) = PrimeSpectrum.zeroLocus s :=
  by sorry

This theorem, named `PrimeSpectrum.zeroLocus_span`, states that for any type `R` which is a commutative semiring and any set `s` of type `R`, the zero locus of the ideal generated by `s` is equal to the zero locus of `s` itself. In mathematical terms, if we think of `s` as a subset of a ring `R`, the set of all prime ideals that contain the ideal generated by `s` is exactly the same as the set of all prime ideals that contain `s`. The `zeroLocus` function maps a set to the set of prime ideals of the ring that contain all elements of the given set. The theorem thus relates the properties of an ideal and the subset of the ring which generates it in terms of the prime spectrum of the ring.

For any commutative semiring R and set s of R, the ideal generated by s and the set s have equal zero locus in the prime spectrum of R.


/-- Lagrange's **Mean Value Theorem**, `deriv` version.  -/
theorem exists_deriv_eq_slope :
    ∀ (f : ℝ → ℝ) {a b : ℝ},
      a < b →
        ContinuousOn f (Set.Icc a b) →
          DifferentiableOn ℝ f (Set.Ioo a b) → ∃ c ∈ Set.Ioo a b, deriv f c = (f b - f a) / (b - a) :=
  by sorry

This is a Lean 4 version of Lagrange's Mean Value Theorem specifically for real-valued functions. The theorem states that for any real-valued function `f`, if `f` is continuous on a closed interval `[a, b]` and differentiable on the open interval `(a, b)`, then there exists a point `c` in `(a, b)` such that the derivative of `f` at `c` is equal to the slope of the secant line through `(a, f(a))` and `(b, f(b))`. The slope of the secant line is given by `(f b - f a) / (b - a)`. This is the key result in calculus that provides a geometric interpretation for derivatives and leads to the fundamental theorem of calculus.

If a real-valued function `f` is continuous on a closed interval `[a, b]` and differentiable on the open interval `(a, b)`, then there exists a point `c` in `(a, b)` such that `f'(c) = (f(b) - f(a)) / (b - a)`.


theorem Cardinal.IsLimit.aleph0_le : ∀ {c : Cardinal.{u_1}}, Cardinal.IsLimit c → Cardinal.aleph0 ≤ c := by sorry

The theorem `Cardinal.IsLimit.aleph0_le` states that for any cardinal number `c`, if `c` is a limit cardinal (i.e., it is not zero and not a successor cardinal), then `ℵ₀` (aleph null), which is the smallest infinite cardinal, is less than or equal to `c`. In other words, every limit cardinal is at least as large as the smallest infinite cardinal.

For any limit cardinal `c`, we have `ℵ₀ ≤ c`.


theorem Array.size_ofFn : ∀ {n : ℕ} {α : Type u_1} (f : Fin n → α), Array.size (Array.ofFn f) = n := by sorry

The theorem `Array.size_ofFn` states that for any function `f` from the finite set of natural numbers less than `n` to some type `α`, the size of the array created by applying `f` to each element of the finite set (`Array.ofFn f`) is equal to `n`. In other words, if you create an array by mapping a function over each element in a set of size `n`, the size of the resulting array will also be `n`.

For any function from a finite set of size n to type α, the size of the array obtained by applying the function to each element is equal to n.


theorem TopologicalSpace.Opens.coe_inj :
    ∀ {α : Type u_2} [inst : TopologicalSpace α] {U V : TopologicalSpace.Opens α}, ↑U = ↑V ↔ U = V := by sorry

This theorem states that for any type `α` with a topological space structure, and any two members `U` and `V` of the open subsets of `α`, the assertion that the underlying sets of `U` and `V` are equal (denoted `↑U = ↑V`) is equivalent to `U` and `V` themselves being equal. In other words, two open subsets of a topological space are the same if and only if their underlying sets are the same.

For any topological space `α`, two of its open subsets `U` and `V` are equal if and only if their underlying sets are equal (`↑U = ↑V` implies `U = V`).


theorem Multiset.toFinset_card_of_nodup :
    ∀ {α : Type u_1} [inst : DecidableEq α] {m : Multiset α},
      Multiset.Nodup m → (Multiset.toFinset m).card = Multiset.card m :=
  by sorry

The theorem `Multiset.toFinset_card_of_nodup` states that for any type `α` with decidable equality and any multiset `m` of that type, if `m` has no duplicate elements (as ensured by `Multiset.Nodup m`), then the cardinality of the finset resulting from `m` by removing duplicates (achieved by `Multiset.toFinset m`) is equal to the cardinality of `m`. In other words, if a multiset has no duplicates, converting it to a finset does not change its cardinality.

If `m` is a multiset of type `α` with no duplicate elements, then the cardinality of `Multiset.toFinset m` equals the cardinality of `m`.


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

The theorem `Real.mul_rpow` states that for any real numbers `x`, `y`, and `z`, if `x` and `y` are both non-negative, then the `z`th power of the product of `x` and `y` is equal to the product of the `z`th power of `x` and the `z`th power of `y`. In mathematical notation, it says that for all $x, y, z \in \mathbb{R}$ with $x, y \geq 0$, we have $(xy)^z = x^z y^z$.

For any non-negative real numbers x, y, and z, $(xy)^z = x^z \cdot y^z$.


theorem Localization.one_def : ∀ {M : Type u_4} [inst : CommMonoid M] (S : Submonoid M), Localization.one S = One.one :=
  by sorry

This theorem states that for any type `M` which is a commutative monoid, and for any submonoid `S` of `M`, the identity element of the localization of `S` is equal to the identity element of the underlying set. In other words, the identity of the localization of a submonoid is the same as the identity of the set itself. This identity element in both cases is represented as `⟨1, 1⟩`. So, regardless of the specific submonoid `S` or the exact type `M`, the identity for any Localization is always the same as the identity for the set.

For any commutative monoid M and its submonoid S, the identity element of S's localization is equal to the identity element of M's underlying set.


/-- **Alias** of the reverse direction of `Int.not_le`. -/
theorem Int.not_le_of_gt : ∀ {a b : ℤ}, b < a → ¬a ≤ b := by sorry

This theorem, `Int.not_le_of_gt`, is essentially an alias for the reverse direction of the `Int.not_le` theorem. It states that for any two integers `a` and `b`, if `b` is less than `a` then it is not true that `a` is less than or equal to `b`. In mathematical terms, if b < a, then it is not the case that a ≤ b.

For all integers a and b, if b < a then a > b.


theorem SetTheory.PGame.fuzzy_congr :
    ∀ {x₁ y₁ x₂ y₂ : SetTheory.PGame},
      x₁ ≈ x₂ → y₁ ≈ y₂ → (SetTheory.PGame.Fuzzy x₁ y₁ ↔ SetTheory.PGame.Fuzzy x₂ y₂) :=
  by sorry

This theorem, `SetTheory.PGame.fuzzy_congr`, states that for any four pre-games `x₁`, `y₁`, `x₂`, and `y₂`, if `x₁` is equivalent to `x₂` and `y₁` is equivalent to `y₂`, then the fuzzy relationship between `x₁` and `y₁` is the same as the fuzzy relationship between `x₂` and `y₂`. In other words, if two pairs of pre-games are each equivalent within their pair, then the "fuzziness" or confusion between the games in the first pair is the same as that in the second pair. Here, a fuzzy relationship between two pre-games means that the first player can always win either game.

If pre-games x₁, y₁, x₂, and y₂ satisfy x₁ ≈ x₂ and y₁ ≈ y₂, then the fuzzy relationship between x₁ and y₁ is equal to the fuzzy relationship between x₂ and y₂.


UniformContinuous.sub

theorem UniformContinuous.sub :
    ∀ {α : Type u_1} {β : Type u_2} [inst : UniformSpace α] [inst_1 : AddGroup α] [inst_2 : UniformAddGroup α]
      [inst_3 : UniformSpace β] {f g : β → α},
      UniformContinuous f → UniformContinuous g → UniformContinuous fun x => f x - g x :=
  by sorry

The theorem `UniformContinuous.sub` states that for any two types, `α` and `β`, where `α` is a uniform space and an additive group (also a uniform additive group), and `β` is a uniform space, given two functions `f` and `g` that map elements from `β` to `α` and are uniformly continuous, the function that maps each element `x` in `β` to the difference of the image of `x` under `f` and `g` (i.e., `f(x) - g(x)`) is also uniformly continuous. This refers to the property that the rate of change (in terms of uniform distance) is constant across the entire domain, regardless of the specific input value.

Given uniformly continuous functions `f` and `g` from a uniform space `β` to an additive group and uniform space `α`, their difference `x ↦ f(x) - g(x)` is also uniformly continuous on `β`.


theorem Set.op_mem_op : ∀ {α : Type u_1} {s : Set α} {a : α}, Opposite.op a ∈ Set.op s ↔ a ∈ s := by sorry

This theorem states that for any type `α`, any set `s` of type `α`, and any element `a` of type `α`, the element 'a' is a member of the set 's' if and only if the opposite of 'a' is a member of the opposite set of 's'. Here, the 'opposite' of an element or a set is defined using the `Opposite.op` and `Set.op` functions, respectively.

For any type `α`, set `s` of type `α`, and element `a` of type `α`, `a` is in `s` if and only if the opposite of `a` is in the opposite of `s`.


theorem orderOf_le_of_pow_eq_one :
    ∀ {G : Type u_1} [inst : Monoid G] {x : G} {n : ℕ}, 0 < n → x ^ n = 1 → orderOf x ≤ n := by sorry

The theorem `orderOf_le_of_pow_eq_one` states that for any type `G` that forms a Monoid, and any element `x` in `G`, if there exists a natural number `n` greater than `0` such that raising `x` to the power `n` yields the identity `1`, then the order of `x` is less than or equal to `n`. In other words, if `x` to the power of `n` equals `1`, then `n` is at least as large as the smallest positive integer for which this is true, which is the order of `x`.

If for some Monoid `G` and its element `x` there exists a natural number `n` such that `x^n = 1`, then the order of `x` is less than or equal to `n`.


/-- If `s` is a measurable set, then `𝓝[s] a` is a measurably generated filter for
each `a`. This cannot be an `instance` because it depends on a non-instance `hs : MeasurableSet s`.
 -/
theorem MeasurableSet.nhdsWithin_isMeasurablyGenerated :
    ∀ {α : Type u_1} [inst : TopologicalSpace α] [inst_1 : MeasurableSpace α] [inst_2 : OpensMeasurableSpace α]
      {s : Set α}, MeasurableSet s → ∀ (a : α), Filter.IsMeasurablyGenerated (nhdsWithin a s) :=
  by sorry

This theorem states that if `s` is a measurable set in a topological and measurable space, which is also an opens measurable space, then for every element `a` in the space, the "neighborhood within" filter (`𝓝[s] a`) is measurably generated. The "neighborhood within" filter here refers to sets that contain the intersection of `s` and a neighborhood of `a`. Note that the measurability of `s` is not an instance and hence needs to be provided explicitly. This theorem essentially ties together the concepts of topological (neighborhood) and measure (measurably generated) properties of sets.

In a topological and measurable space, if `s` is a measurable and open set, then the "neighborhood within" filter of any element `a` in `s`, `𝓝[s] a`, is measurably generated.


theorem CategoryTheory.Adjunction.homEquiv_apply_eq :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂}
      [inst_1 : CategoryTheory.Category.{v₂, u₂} D] {F : CategoryTheory.Functor C D} {G : CategoryTheory.Functor D C}
      (adj : F ⊣ G) {A : C} {B : D} (f : F.obj A ⟶ B) (g : A ⟶ G.obj B),
      (adj.homEquiv A B) f = g ↔ f = (adj.homEquiv A B).symm g :=
  by sorry

This theorem states that for any categories `C` and `D`, their functors `F` and `G` that form an adjunction `adj`, along with objects `A` in `C` and `B` in `D`, and morphisms `f` from `F.obj A` to `B` and `g` from `A` to `G.obj B`, the morphism `f` is equal to the application of the inverse of `adj.homEquiv` at `A` and `B` to `g` if and only if the application of `adj.homEquiv` at `A` and `B` to `f` is equal to `g`. In other words, the adjunction homomorphism equivalence `adj.homEquiv` provides a bijective correspondence between the morphisms `f` and `g`.

For any categories `C`, `D`, functors `F: C -> D`, `G: D -> C`, and their adjunction `adj: (F, G)`, the natural transformation `adj.homEquiv` is a bijective correspondence between morphisms `f: F(A) -> B` and `g: A -> G(B)` in `C` and `D`, respectively.


theorem Finsupp.support_filter :
    ∀ {α : Type u_1} {M : Type u_5} [inst : Zero M] (p : α → Prop) [inst_1 : DecidablePred p] (f : α →₀ M),
      (Finsupp.filter p f).support = Finset.filter p f.support :=
  by sorry

The theorem `Finsupp.support_filter` states that for all types `α` and `M`, given a zero instance for `M`, a predicate `p` on `α` that is decidable, and a function `f` from `α` to `M` with finite support, the support of the function obtained by filtering `f` using `p` (i.e., keeping only those elements of `f` for which `p` holds and setting the rest to zero) is equal to the set obtained by filtering the support of `f` (i.e., the set of `α` where `f` is non-zero) using the same predicate `p`. In other words, applying the filter to the function has the same effect on its support as applying the filter directly to the support set.

For any type `α` and decidable predicate `p` on `α`, and given a function `f` from `α` to a type `M` with finite support, the support of the filtered function `\{x | p x ∧ f x ≠ 0\} → ⊤ -> ∫ x, p x → f x` is equal to the filtered set `\{x | p x\} ∩ supp f`.


theorem Finset.sum_pos :
    ∀ {ι : Type u_1} {M : Type u_4} [inst : OrderedCancelAddCommMonoid M] {f : ι → M} {s : Finset ι},
      (∀ i ∈ s, 0 < f i) → s.Nonempty → 0 < Finset.sum s fun i => f i :=
  by sorry

The theorem `Finset.sum_pos` states that for any type `ι`, any `M` which is an ordered, cancellative, commutative monoid, any function `f` from `ι` to `M`, and any finite set `s` of `ι`, if every element `i` in `s` has the property that `f(i)` is greater than zero, and if `s` is not empty, then the sum of `f(i)` for all `i` in `s` (denoted by `Finset.sum s fun i => f i`) is also greater than zero. In other words, the sum of positive values over a nonempty finite set is also positive.

For any ordered, cancellative, commutative monoid M and function f from a nonempty finite set ι to M with f(i) > 0 for all i in ι, the sum of f(i) over i in ι is greater than zero.


Set.Nonempty.fst

theorem Set.Nonempty.fst :
    ∀ {α : Type u_1} {β : Type u_2} {s : Set α} {t : Set β}, Set.Nonempty (s ×ˢ t) → Set.Nonempty s := by sorry

The theorem `Set.Nonempty.fst` states that for any types `α` and `β`, and any sets `s` of type `α` and `t` of type `β`, if the Cartesian product of `s` and `t` (`s ×ˢ t`) is nonempty, then the set `s` is also nonempty. In other words, having at least one pair of elements from `s` and `t` implies that `s` must contain at least one element.

If the Cartesian product of sets `s` and `t` is nonempty, then `s` is nonempty.


theorem HolderOnWith.edist_le :
    ∀ {X : Type u_1} {Y : Type u_2} [inst : PseudoEMetricSpace X] [inst_1 : PseudoEMetricSpace Y] {C r : NNReal}
      {f : X → Y} {s : Set X},
      HolderOnWith C r f s → ∀ {x y : X}, x ∈ s → y ∈ s → edist (f x) (f y) ≤ ↑C * edist x y ^ ↑r :=
  by sorry

The theorem `HolderOnWith.edist_le` states that for any two types `X` and `Y` that each forms a PseudoEMetricSpace, any non-negative real numbers `C` and `r`, any function `f` from `X` to `Y`, and any set `s` of elements of type `X`, if `f` is Hölder continuous with constant `C` and exponent `r` on the set `s`, then for any two elements `x` and `y` in the set `s`, the extended distance between `f(x)` and `f(y)` is less than or equal to `C` times the extended distance between `x` and `y` raised to the power `r`. In other words, `edist (f x) (f y) ≤ C * edist x y ^ r` for all `x,y ∈ s`.

For any Hölder continuous function f between two pseudo-metric spaces X and Y with constant C and exponent r, and for any x, y in X, the extended distance between f(x) and f(y) is less than or equal to C times the extended distance between x and y raised to the power of r.


theorem List.filter_filter :
    ∀ {α : Type u_1} {p : α → Bool} (q : α → Bool) (l : List α),
      List.filter p (List.filter q l) = List.filter (fun a => decide (p a = true ∧ q a = true)) l :=
  by sorry

The theorem `List.filter_filter` states that for any type `α`, any two boolean-valued functions `p` and `q` on `α`, and any list `l` of elements of type `α`, the process of first filtering `l` with `q` and then filtering the result with `p` is equivalent to filtering `l` once with a function that returns `true` for an element if and only if both `p` and `q` return `true` for that element. In other words, the composition of the filter functions is the same as the filter function for the logical conjunction of the original predicate functions.

The `List.filter_filter` theorem in Lean 4 asserts that for any list `l` and functions `p` and `q`, `List.filter (λx => p x ∧ q x) l` is equal to `List.filter q (List.filter p l)`.


theorem IsCoprime.add_mul_left_left :
    ∀ {R : Type u} [inst : CommRing R] {x y : R}, IsCoprime x y → ∀ (z : R), IsCoprime (x + y * z) y := by sorry

This theorem states that for any commutative ring `R` and any elements `x`, `y`, and `z` of `R`, if `x` and `y` are coprime (meaning that there exist numbers `a` and `b` such that `a * x + b * y = 1`), then `x + y * z` and `y` are also coprime. In other words, if `x` and `y` share no common divisors other than 1, the same will hold true for the element `x + y * z` and `y`.

If `x` and `y` are coprime elements in a commutative ring `R`, then `x` and `y + x * z` are coprime for all `z` in `R`.


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

This theorem, `indepFun_prod_mk_prod_mk`, states that for any types `α`, `Ω`, and `ι`, given a measurable space over `α` and `Ω`, a measure `μ` on `α`, a `κ` kernel on the measurable space over `α` and `Ω`, and a family of functions `{f : (i : ι) → Ω → β i}` on an index type `ι` and outputting in some type `β` where each `β i` has a measurable space structure, under the condition that `κ` is a Markov kernel, and the function `f` is independent with respect to the kernel `κ` and the measure `μ`, if all functions `f i` are measurable, then for any distinct indices `i`, `j`, `k`, `l` in `ι`, the functions `(f i a, f j a)` and `(f k a, f l a)` are mutually independent with respect to the kernel `κ` and the measure `μ`.

In the context of probability theory, this theorem is stating a property about independence of functions under certain conditions. In particular, it says that if we have a set of measurable functions that are independent with respect to a Markov kernel and a measure, then certain pairs of these functions, specified by distinct indices, will also be independent.

If `κ` is a Markov kernel, `μ` is a measure, `α`, `Ω`, and `ι` are types, `f : ι → Ω → β i` is a family of measurable functions, and `κ` and `f` are independent with respect to `μ`, then for any distinct indices `i`, `j` in `ι`, the functions `f i` and `f j` are independent with respect to `κ` and `μ`.


theorem LinearIndependent.to_subtype_range :
    ∀ {R : Type u_2} {M : Type u_4} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] {ι : Type u_8}
      {f : ι → M}, LinearIndependent R f → LinearIndependent (ι := { x // x ∈ Set.range f }) R Subtype.val :=
  by sorry

The theorem `LinearIndependent.to_subtype_range` states that for any ring `R`, any additive commutative group `M`, and any module structure on `M` over `R`, if a function `f` from a type `ι` to `M` is linearly independent over `R`, then the function `Subtype.val`, which returns the underlying elements of the set `{x // x ∈ range of f}`, is also linearly independent over `R`. In other words, restriction of a linearly independent set to the range of its defining function preserves linear independence.

If `f` is a linearly independent function from type `ι` to the module `M` over ring `R`, then the image of `f` is a linearly independent subset of `M`.


theorem Mathlib.Data.List.Duplicate._auxLemma.4 :
    ∀ {α : Type u_1} {l : List α} {x y : α}, List.Duplicate x (y :: l) = (y = x ∧ x ∈ l ∨ List.Duplicate x l) := by
  sorry

This theorem, named `_auxLemma.4` from the `Mathlib.Data.List.Duplicate` module in Lean, states that for any type `α`, any list `l` of type `α`, and any `x` and `y` of type `α`, the condition of `x` being a duplicate in the list formed by prepending `y` to `l` is equivalent to either `y` being equal to `x` and `x` being in `l`, or `x` being a duplicate in `l`.

For any type `α`, list `l` of type `α`, and `x`, `y` of type `α`, `x` is a duplicate in the list `x :: y :: l` if and only if `y = x` or `x` is a duplicate in `l`.


theorem Nat.primeFactors_mul : ∀ {a b : ℕ}, a ≠ 0 → b ≠ 0 → (a * b).primeFactors = a.primeFactors ∪ b.primeFactors := by
  sorry

This theorem states that for any two non-zero natural numbers `a` and `b`, the set of prime factors of their product `a * b` is equal to the union of the sets of prime factors of `a` and `b`. In other words, the prime factors of the product of two numbers are precisely the prime factors of the individual numbers.

The set of prime factors of the product of two natural numbers is equal to the union of the sets of prime factors of each number.


theorem Ioi_mem_nhdsSet_Icc :
    ∀ {α : Type u_1} [inst : LinearOrder α] [inst_1 : TopologicalSpace α] [inst_2 : OrderClosedTopology α] {a b c : α},
      a < b → Set.Ioi a ∈ nhdsSet (Set.Icc b c) :=
  by sorry

This theorem states that for any three elements `a`, `b`, and `c` of a type `α` endowed with a linear order and a topological space structure in which the order is closed, if `a` is less than `b`, then the set of elements greater than `a` (`Set.Ioi a`) is a neighborhood of the closed interval from `b` to `c` (`Set.Icc b c`). In other words, `Set.Ioi a` is in the filter of neighborhoods of the set `Set.Icc b c`.

For any type `α` with a linear order and a topology where order intervals are closed, if `a < b` then the set of elements greater than `a` is a neighborhood of the closed interval `[b, c]`.


theorem prod_mk_mem_compRel :
    ∀ {α : Type ua} {a b c : α} {s t : Set (α × α)}, (a, c) ∈ s → (c, b) ∈ t → (a, b) ∈ compRel s t := by sorry

This theorem states that for any type `α` and any three elements `a`, `b`, and `c` of type `α`, and any two sets `s` and `t` of pairs of elements of type `α`, if the pair `(a, c)` belongs to the set `s` and the pair `(c, b)` belongs to the set `t`, then the pair `(a, b)` belongs to the composition of the relations `s` and `t`. The composition of relations `s` and `t` is defined as the set of all pairs `(x, y)` such that there exists some `z` where `(x, z)` is in `s` and `(z, y)` is in `t`.

If `(a, c)` is in the relation `s` and `(c, b)` is in the relation `t`, then `(a, b)` is in the composition of `s` and `t`.


theorem Num.castNum_eq_bitwise :
    ∀ {f : Num → Num → Num} {g : Bool → Bool → Bool} (p : PosNum → PosNum → Num),
      g false false = false →
        f 0 0 = 0 →
          (∀ (n : PosNum), f 0 (Num.pos n) = bif g false true then Num.pos n else 0) →
            (∀ (n : PosNum), f (Num.pos n) 0 = bif g true false then Num.pos n else 0) →
              (∀ (m n : PosNum), f (Num.pos m) (Num.pos n) = p m n) →
                (p 1 1 = bif g true true then 1 else 0) →
                  (∀ (b : Bool) (n : PosNum),
                      p 1 (PosNum.bit b n) = Num.bit (g true b) (bif g false true then Num.pos n else 0)) →
                    (∀ (a : Bool) (m : PosNum),
                        p (PosNum.bit a m) 1 = Num.bit (g a true) (bif g true false then Num.pos m else 0)) →
                      (∀ (a b : Bool) (m n : PosNum), p (PosNum.bit a m) (PosNum.bit b n) = Num.bit (g a b) (p m n)) →
                        ∀ (m n : Num), ↑(f m n) = Nat.bitwise g ↑m ↑n :=
  by sorry

This theorem, `Num.castNum_eq_bitwise`, states that for any two Num-to-Num functions `f` and `g`, and a PosNum-to-PosNum-to-Num function `p`, given certain conditions, the cast of the application of `f` to any two Num values `m` and `n` is equal to the bitwise operation on the cast of `m` and `n` using `g`.

The conditions for this to hold are:
- `g` returns `false` when applied to two `false` Boolean values,
- `f` returns `0` when applied to two `0` Num values,
- For any positive number `n`, `f` returns `Num.pos n` if `g` applied to `false` and `true` returns `true`, and `0` otherwise,
- Similar condition holds for `f` returning `Num.pos n` if `g` applied to `true` and `false` returns `true`, and `0` otherwise, for any positive number `n`,
- For any two positive numbers `m` and `n`, `f` returns the application of `p` to `m` and `n`,
- `p` returns `1` if `g` applied to two `true` Boolean values returns `true`, and `0` otherwise,
- For any Boolean value `b` and positive number `n`, `p` returns the bitwise operation on `g` applied to `true` and `b` and `Num.pos n` if `g` applied to `false` and `true` returns `true`, and `0` otherwise,
- A similar condition holds for `p` returning the bitwise operation on `g` applied to `a` and `true` and `Num.pos m` if `g` applied to `true` and `false` returns `true`, and `0` otherwise, for any Boolean value `a` and positive number `m`,
- For any two Boolean values `a` and `b`, and positive numbers `m` and `n`, `p` returns the bitwise operation on `g` applied to `a` and `b` and the application of `p` to `m` and `n`.
These conditions provide a detailed relationship between the behaviour of functions `f`, `g`, and `p` and the bitwise operations.

For functions `f`, `g`, and `p` satisfying certain conditions, the cast of `f` applied to two numbers `m` and `n` is equal to the bitwise operation on the casts of `m` and `n` using `g`, represented by `p`.


theorem Fintype.piFinset_image :
    ∀ {α : Type u_1} [inst : DecidableEq α] [inst_1 : Fintype α] {γ : α → Type u_2} {δ : α → Type u_3}
      [inst_2 : (a : α) → DecidableEq (δ a)] (f : (a : α) → γ a → δ a) (s : (a : α) → Finset (γ a)),
      (Fintype.piFinset fun a => Finset.image (f a) (s a)) = Finset.image (fun b a => f a (b a)) (Fintype.piFinset s) :=
  by sorry

The theorem `Fintype.piFinset_image` states that for every type `α` with decidable equality and finiteness, and for every pair of type functions `γ` and `δ` from `α` where each `δ a` also has decidable equality, given a function `f` mapping an element of `α` and `γ a` to `δ a`, and a function `s` mapping each `a` in `α` to a `Finset` of `γ a`, the image under `f` of the Cartesian product finset of `s a` across all `a` in `α` is equal to the Cartesian product finset of the image under `f` of `s a` for each `a` in `α`. In mathematical terms, this can be interpreted as distributing the image function across the Cartesian product of finsets.

For every type `α` with decidable equality and finiteness, and for every pair of type functions `γ : α → Type* δ : α → Type` with decidable equality, given functions `f : α × γ → δ` and `s : α → Finset γ`, the image of the Cartesian product of `s a` under `f` for all `a` in `α` is equal to the Cartesian product of the images of `s a` under `f` for each `a` in `α`.


/-- C2.1.3 in [Elephant]  -/
theorem CategoryTheory.Presieve.isSheafFor_iff_generate :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {P : CategoryTheory.Functor Cᵒᵖ (Type w)} {X : C}
      (R : CategoryTheory.Presieve X),
      CategoryTheory.Presieve.IsSheafFor P R ↔
        CategoryTheory.Presieve.IsSheafFor P (CategoryTheory.Sieve.generate R).arrows :=
  by sorry

This theorem, denoted as C2.1.3 in the Elephant book, states that for any category `C`, any presheaf `P` of types over `C`, any object `X` of `C`, and any presieve `R` of arrows into `X`, the presheaf `P` is a sheaf for the presieve `R` if and only if `P` is a sheaf for the sieve generated by `R`. This is significant because it creates a link between the notion of a sheaf for a given set of arrows and a sheaf for the smallest sieve containing this set. The sieve generated by `R` consists of all arrows that factor through arrows in `R`.

For any category `C`, presheaf `P` over `C`, object `X` in `C`, and sieve `R` of arrows into `X`, `P` is a sheaf for `R` if and only if it is a sheaf for the sieve generated by `R`.


theorem Finset.prod_lt_prod' :
    ∀ {ι : Type u_1} {M : Type u_4} [inst : OrderedCancelCommMonoid M] {f g : ι → M} {s : Finset ι},
      (∀ i ∈ s, f i ≤ g i) → (∃ i ∈ s, f i < g i) → (Finset.prod s fun i => f i) < Finset.prod s fun i => g i :=
  by sorry

The theorem `Finset.prod_lt_prod'` states that for any types `ι` and `M`, where `M` is an ordered cancel commutative monoid, and for any functions `f` and `g` from `ι` to `M`, and any finite set `s` of type `ι`, if for every element `i` in `s`, `f(i)` is less than or equal to `g(i)`, and there exists an element `i` in `s` such that `f(i)` is strictly less than `g(i)`, then the product of `f(i)` for all `i` in `s` is strictly less than the product of `g(i)` for all `i` in `s`. In mathematical terms, if $\forall i \in s, f(i) \leq g(i)$ and $\exists i \in s, f(i) < g(i)$, then $\prod_{i \in s} f(i) < \prod_{i \in s} g(i)$.

If `ι` is a type, `M` is an ordered cancel commutative monoid, `f` and `g` are functions from `ι` to `M`, and `s` is a finite set of type `ι` such that `∀ i ∈ s, f(i) ≤ g(i)` and `∃ i ∈ s, f(i) < g(i)`, then `∏ i ∈ s, f(i) < ∏ i ∈ s, g(i)`.


theorem padicNormE.eq_padicNorm : ∀ {p : ℕ} [hp : Fact (Nat.Prime p)] (q : ℚ), ‖↑q‖ = ↑(padicNorm p q) := by sorry

The theorem `padicNormE.eq_padicNorm` states that for any prime number `p` and any rational number `q`, the p-adic norm of `q`, denoted as `‖↑q‖`, is equal to the p-adic norm of `q` as defined by the function `padicNorm`. In other words, the p-adic norm of `q` under the standard p-adic norm function is the same as the p-adic norm of `q` under the `padicNorm` function when `p` is prime.

For any prime number p and rational number q, the standard p-adic norm of q equals the p-adic norm of q computed by the `padicNorm` function.


theorem LinearMap.toAddMonoidHom_injective :
    ∀ {R : Type u_1} {S : Type u_6} {M : Type u_9} {M₃ : Type u_12} [inst : Semiring R] [inst_1 : Semiring S]
      [inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid M₃] [inst_4 : Module R M] [inst_5 : Module S M₃] {σ : R →+* S},
      Function.Injective LinearMap.toAddMonoidHom :=
  by sorry

The theorem `LinearMap.toAddMonoidHom_injective` states that for any semirings `R` and `S`, additive commutative monoids `M` and `M₃`, `R`-module structure on `M`, `S`-module structure on `M₃`, and ring homomorphism `σ` from `R` to `S`, the function `LinearMap.toAddMonoidHom`, which converts a linear map to an additive map, is injective. In other words, if two linear maps become identical when viewed as additive maps, those two linear maps were originally identical.

If two linear maps between modules over ring homomorphisms have the same additive map representation, then they are equal as linear maps.


theorem Int.even_sub : ∀ {m n : ℤ}, Even (m - n) ↔ (Even m ↔ Even n) := by sorry

This theorem states that for all integers `m` and `n`, `m - n` is even if and only if `m` is even if and only if `n` is even. In mathematical terms, it asserts that an integer subtraction `m - n` is even if and only if the integers `m` and `n` are both either even or odd.

For integers `m` and `n`, `m - n` is even if and only if both `m` and `n` are even or odd.


theorem sup_ind : ∀ {α : Type u} [inst : LinearOrder α] (a b : α) {p : α → Prop}, p a → p b → p (a ⊔ b) := by sorry

This theorem states that for any type `α` that has a linear order and any two elements `a` and `b` of that type, if a property `p` holds true for both `a` and `b`, then it also holds true for the supremum of `a` and `b`. Here, the supremum (denoted by `a ⊔ b`) is the least upper bound of `a` and `b`, or in other words, the smallest element that is greater than or equal to both `a` and `b` in the linear order.

If `α` is a type with a linear order and `a`, `b` are elements of `α` such that `p` holds for `a` and `b`, then `p` holds for their supremum `a ⊔ b`.


theorem Polynomial.degree_le_of_dvd :
    ∀ {R : Type u} [inst : Semiring R] [inst_1 : NoZeroDivisors R] {p q : Polynomial R},
      p ∣ q → q ≠ 0 → Polynomial.degree p ≤ Polynomial.degree q :=
  by sorry

The theorem `Polynomial.degree_le_of_dvd` states that for any type `R` with a semiring structure and no zero divisors, and for any two polynomials `p` and `q` over `R`, if `p` divides `q` and `q` is not the zero polynomial, then the degree of `p` is less than or equal to the degree of `q`. In other words, if one polynomial divides another, the degree of the divisor polynomial cannot exceed the degree of the dividend polynomial, provided that the dividend polynomial is not zero.

If `p` divides `q` in a semiring `R` without zero divisors, then the degree of `p` is less than or equal to the degree of `q`.


theorem ContinuousAffineMap.coe_injective :
    ∀ {R : Type u_1} {V : Type u_2} {W : Type u_3} {P : Type u_4} {Q : Type u_5} [inst : Ring R]
      [inst_1 : AddCommGroup V] [inst_2 : Module R V] [inst_3 : TopologicalSpace P] [inst_4 : AddTorsor V P]
      [inst_5 : AddCommGroup W] [inst_6 : Module R W] [inst_7 : TopologicalSpace Q] [inst_8 : AddTorsor W Q],
      Function.Injective DFunLike.coe :=
  by sorry

The theorem `ContinuousAffineMap.coe_injective` states that for any ring `R`, additive commutative groups `V` and `W`, modules `V` and `W` over `R`, topological spaces `P` and `Q`, and additive torsors `V` over `P` and `W` over `Q`, the function `DFunLike.coe`, which is a coercion function from `F` to a function, is injective. In other words, if for two continuous affine maps, the corresponding functions (obtained by applying `DFunLike.coe`) are equal, then the original continuous affine maps are also equal.

For any continuous affine maps between additive commutative groups made into topological spaces as modules over a ring, the coercion function from the space of functions to the space of continuous affine maps is injective.


theorem MvPolynomial.eval₂Hom_zero :
    ∀ {R : Type u} {S₂ : Type w} {σ : Type u_1} [inst : CommSemiring R] [inst_1 : CommSemiring S₂] (f : R →+* S₂),
      MvPolynomial.eval₂Hom f 0 = RingHom.comp f MvPolynomial.constantCoeff :=
  by sorry

The theorem `MvPolynomial.eval₂Hom_zero` states that for any types `R`, `S₂`, and `σ`, with `R` and `S₂` as commutative semirings, and any ring homomorphism `f` from `R` to `S₂`, when we evaluate a multivariate polynomial with coefficients in `R` and indeterminates `σ` at zero using `MvPolynomial.eval₂Hom` with the ring homomorphism `f`, it is equivalent to first applying the constant coefficient function `MvPolynomial.constantCoeff` to the polynomial and then applying the ring homomorphism `f`. In other words, we can either evaluate the polynomial at zero and then map the result through `f`, or we can first extract the constant term of the polynomial and then map that constant term through `f`. These two processes yield the same result.

For any commutative semirings R and S₂, ring homomorphism f from R to S₂, multivariate polynomial P with coefficients in R and indeterminates σ, we have MvPolynomial.eval₂Hom (P) (0) (f) = MvPolynomial.constantCoeff P ∘ f.


/-- A seminorm is continuous at `0` if `p.closedBall 0 r ∈ 𝓝 0` for *all* `r > 0`.
Over a `NontriviallyNormedField` it is actually enough to check that this is true
for *some* `r`, see `Seminorm.continuousAt_zero'`.  -/
theorem Seminorm.continuousAt_zero_of_forall' :
    ∀ {𝕝 : Type u_6} {E : Type u_7} [inst : SeminormedRing 𝕝] [inst_1 : AddCommGroup E] [inst_2 : Module 𝕝 E]
      [inst_3 : TopologicalSpace E] {p : Seminorm 𝕝 E},
      (∀ r > 0, Seminorm.closedBall p 0 r ∈ nhds 0) → ContinuousAt (⇑p) 0 :=
  by sorry

The theorem `Seminorm.continuousAt_zero_of_forall'` states that a seminorm, denoted as `p`, is continuous at `0` if the closed ball of any radius `r` greater than `0` centered at `0` with respect to seminorm `p` is a neighborhood of `0`. This is applicable in the context of a seminormed ring `𝕝` and a topological space `E` that is also an additive commutative group and an `𝕝`-module. More precisely, a seminorm `p` is continuous at `0` if for every real number `r` greater than `0`, the set of elements `y` in `E` such that the seminorm of `y - 0` is less than or equal to `r` belongs to the neighborhood filter at `0`. Over a `NontriviallyNormedField`, it is sufficient to check this condition for some `r` greater than `0`, as stated in `Seminorm.continuousAt_zero'`.

A seminorm `p` on an additive commutative group and `𝕝`-module `E` is continuous at `0` if for every `r` > 0, the closed ball `B(0, r)` with respect to `p` is a neighborhood of `0`.


theorem Sym2.other_spec' :
    ∀ {α : Type u_1} [inst : DecidableEq α] {a : α} {z : Sym2 α} (h : a ∈ z), s(a, Sym2.Mem.other' h) = z := by sorry

This theorem states that for any type `α` with a decidable equality and for any elements `a` of type `α` and `z` of type `Sym2 α` (i.e., an unordered pair of `α`), if `a` is a member of `z`, then the result of pairing `a` with the other element of the unordered pair `z` (obtained using the function `Sym2.Mem.other'`) is equal to `z`. In other words, it ensures that the function `Sym2.Mem.other'` correctly retrieves the other element of the unordered pair `z` when `a` is known to be a member of `z`.

For any decidably equal type `α` and elements `a` in unordered pair `z` of type `Sym2 α`, `a` paired with the other element of `z` using `Sym2.Mem.other'` equals `z`.


theorem ZeroAtInftyContinuousMap.coe_sub :
    ∀ {α : Type u} {β : Type v} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] [inst_2 : AddGroup β]
      [inst_3 : TopologicalAddGroup β] (f g : ZeroAtInftyContinuousMap α β), ⇑(f - g) = ⇑f - ⇑g :=
  by sorry

This theorem states that for any two continuous maps 'f' and 'g' from a topological space 'α' to a topological add group 'β' that vanish at infinity, the mapping of the difference between 'f' and 'g' is equal to the difference of the individual mappings of 'f' and 'g'. Here, 'β' is not just a topological space but also an additive group, and the addition operation is continuous.

For continuous functions $f, g : \alpha \to (\beta, +)$ with $\beta$ being a topological add group and $f, g$ vanishing at infinity, we have $f - g : \alpha \to \beta$ being the continuous function equal to $f - g : \alpha \to \beta$ defined pointwise.


theorem MeasureTheory.AEEqFun.coeFn_const :
    ∀ (α : Type u_1) {β : Type u_2} [inst : MeasurableSpace α] {μ : MeasureTheory.Measure α}
      [inst_1 : TopologicalSpace β] (b : β),
      ↑(MeasureTheory.AEEqFun.const α b) =ᶠ[MeasureTheory.Measure.ae μ] Function.const α b :=
  by sorry

The theorem `MeasureTheory.AEEqFun.coeFn_const` states that for any measurable space `α`, any topological space `β`, any measure `μ` on `α`, and any constant `b` of type `β`, the equivalence class of the constant function `b` (created using `MeasureTheory.AEEqFun.const`), when coerced, is almost everywhere equal (according to the measure `μ`) to the constant function `b` (created using `Function.const`). This theorem establishes a connection between the constant functions defined in the context of measure theory and typical constant functions.

For any measurable space α, topological space β, measure μ on α, and constant b of type β, the coerced equivalence class of the constant function `MeasureTheory.AEEqFun.const b` is almost everywhere equal to the standard constant function `Function.const b`.


IsPrimitiveRoot.unique

theorem IsPrimitiveRoot.unique :
    ∀ {M : Type u_1} [inst : CommMonoid M] {k l : ℕ} {ζ : M}, IsPrimitiveRoot ζ k → IsPrimitiveRoot ζ l → k = l := by
  sorry

This theorem states that for any type `M` that is a commutative monoid and any natural numbers `k` and `l`, if `ζ` is a primitive root of both `k` and `l`, then `k` must be equal to `l`. In other words, a primitive root uniquely identifies the order of the group in a commutative monoid.

In a commutative monoid, if a primitive root exists for both natural numbers `k` and `l`, then `k` equals `l`.


theorem MvPolynomial.aevalTower_X :
    ∀ {R : Type u} {σ : Type u_1} [inst : CommSemiring R] {S : Type u_2} {A : Type u_3} [inst_1 : CommSemiring S]
      [inst_2 : CommSemiring A] [inst_3 : Algebra S R] [inst_4 : Algebra S A] (g : R →ₐ[S] A) (y : σ → A) (i : σ),
      (MvPolynomial.aevalTower g y) (MvPolynomial.X i) = y i :=
  by sorry

The theorem `MvPolynomial.aevalTower_X` states that for all commutative semirings `R`, `S`, and `A`, with `S` being an algebra over `R` and `A`, and for any algebra homomorphism `g` from `R` to `A` over `S`, and any function `y` from `σ` to `A`, and any element `i` of `σ`, the result of applying the algebra homomorphism induced by `g` and `y` on the `MvPolynomial` degree `1` monomial `X` at `i` is equal to `y` at `i`. In simple language, it means that evaluating a degree `1` monomial at a certain point using the defined algebra homomorphism gives the same result as directly applying the function `y` at that point.

For any commutative semirings R, S, and A, algebra g from R to A over S, function y from σ to A, and element i of σ, the evaluation of the degree 1 monomial X at i via the induced algebra homomorphism g and y is equal to y(i).


theorem AddSubgroup.leftTransversals.diff_add_diff :
    ∀ {G : Type u_1} [inst : AddGroup G] {H : AddSubgroup G} {A : Type u_2} [inst_1 : AddCommGroup A] (ϕ : ↥H →+ A)
      (R S T : ↑(AddSubgroup.leftTransversals ↑H)) [inst_2 : AddSubgroup.FiniteIndex H],
      AddSubgroup.leftTransversals.diff ϕ R S + AddSubgroup.leftTransversals.diff ϕ S T =
        AddSubgroup.leftTransversals.diff ϕ R T :=
  by sorry

This theorem states that for any additive group `G` and any subgroup `H` of `G`, if `R`, `S`, and `T` are three left transversals of `H` (sets which together with `H` form a partition of `G`), and if `ϕ` is a group homomorphism from `H` to another additive commutative group `A`, then the difference of the differences of `ϕ` on `R` and `S`, and on `S` and `T`, equals the difference of `ϕ` on `R` and `T`. This is true under the assumption that `H` has finite index in `G`, meaning the quotient group `G/H` is a finite set. In other words, this theorem expresses a kind of "associativity" for the difference operation on left transversals of an additive subgroup.

For any additive group G, subgroup H with finite index, and three left transversals R, S, T of H, if φ is a group homomorphism from H to an additive commutative group A, then φ(r_i − s_i) − φ(s_i − t_i) = φ(r_i − t_i) for all i, where r_i, s_i, and t_i are elements of R, S, and T, respectively.


theorem Nat.mul_div_le : ∀ (m n : ℕ), n * (m / n) ≤ m := by sorry

This theorem states that for all natural numbers `m` and `n`, the product of `n` and the quotient of `m` divided by `n` is less than or equal to `m`. In mathematical terms, for all `m, n ∈ ℕ`, we have `n * (m / n) ≤ m`. This basically encapsulates the property of integer division, where the product of the divisor and the quotient is less than or equal to the dividend.

For all natural numbers `m` and `n`, `n * (m ÷ n) ≤ m`. (Here `÷` represents integer division in Lean 4.)


theorem primitiveRoots_zero : ∀ {R : Type u_4} [inst : CommRing R] [inst_1 : IsDomain R], primitiveRoots 0 R = ∅ := by
  sorry

The theorem `primitiveRoots_zero` states that for any type `R` that is an integral domain with a commutative ring structure, the set of 0-th primitive roots of unity in `R` is empty. In other words, there are no 0-th primitive roots of unity in an integral domain.

In any integral domain, there are no 0-th primitive roots of unity.


theorem Mathlib.Algebra.Order.Floor._auxLemma.3 :
    ∀ {α : Type u_2} [inst : LinearOrderedSemiring α] [inst_1 : FloorSemiring α] {a : α} {n : ℕ},
      (⌈a⌉₊ ≤ n) = (a ≤ ↑n) :=
  by sorry

This theorem, from the Mathlib library in Lean 4, states that for any type `α` that has the structure of a linearly ordered semiring and a floor semiring, and for any element `a` of this type and natural number `n`, the property that the ceiling of `a` is less than or equal to `n` is equivalent to the property that `a` itself is less than or equal to the natural number `n` converted to the type `α`. In other words, it explores the relationship between the floor function and the natural ordering on the set.

For any linearly ordered semiring `α` with a floor semiring, the ceiling of an element `a` in `α` is less than or equal to a natural number `n` if and only if `a` is less than or equal to the floor of `n` in `α`.


HasFDerivAtFilter.mono

theorem HasFDerivAtFilter.mono :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {f : E → F}
      {f' : E →L[𝕜] F} {x : E} {L₁ L₂ : Filter E},
      HasFDerivAtFilter f f' x L₂ → L₁ ≤ L₂ → HasFDerivAtFilter f f' x L₁ :=
  by sorry

This theorem, `HasFDerivAtFilter.mono`, is stating a property about the derivative of a function `f` at a point `x` with respect to filters `L₁` and `L₂`. Specifically, it says that if a function `f` has a derivative `f'` at a point `x` with respect to a filter `L₂`, and `L₁` is a subset of (or equal to) `L₂`, then `f` also has a derivative `f'` at `x` with respect to `L₁`. Here, `𝕜`, `E`, and `F` are types representing normed fields and normed vector spaces respectively, and `→L[𝕜]` represents bounded linear maps from E to F over the field `𝕜`.

If a function `f` has a derivative `f'` at point `x` with respect to filter `L₂`, and `L₁` is a subset of `L₂`, then `f` has a derivative `f'` at `x` with respect to filter `L₁`.


UniformSpace.Completion.Continuous.mul

theorem UniformSpace.Completion.Continuous.mul :
    ∀ {α : Type u_1} [inst : Ring α] [inst_1 : UniformSpace α] [inst_2 : TopologicalRing α] [inst_3 : UniformAddGroup α]
      {β : Type u_2} [inst_4 : TopologicalSpace β] {f g : β → UniformSpace.Completion α},
      Continuous f → Continuous g → Continuous fun b => f b * g b :=
  by sorry

This theorem states that for any type `α` which has a ring structure, a uniform space structure, a topological ring structure, and is a uniform additive group, and for any other type `β` which has a topological space structure, if `f` and `g` are continuous functions from `β` to the Hausdorff completion of `α`, then the function which maps an element `b` in `β` to the product of `f(b)` and `g(b)` in the Hausdorff completion of `α` is also continuous. In other words, the product of two continuous functions remains continuous in the context of the Hausdorff completion of a topological ring when the ring is also a uniform space and a uniform additive group.

If `α` is a topological ring and uniform additive group, `β` is a topological space, and `f` and `g` are continuous functions from `β` to the Hausdorff completion of `α`, then the function that maps `b` to `f(b)` \* `g(b)` in the Hausdorff completion of `α` is also continuous.


theorem Mathlib.Topology.Order._auxLemma.6 :
    ∀ {α : Type u_1} [inst : TopologicalSpace α] [inst_1 : DiscreteTopology α] (s : Set α), IsOpen s = True := by sorry

The theorem `Mathlib.Topology.Order._auxLemma.6` states that for any set `s` of any type `α`, given that `α` has a topological space structure and is equipped with a discrete topology, the set `s` is always open. In other words, in a discrete topological space, all sets are open.

In a discrete topological space, every subset is open.


SeparatedNhds.symm

theorem SeparatedNhds.symm :
    ∀ {X : Type u_1} [inst : TopologicalSpace X] {s t : Set X}, SeparatedNhds s t → SeparatedNhds t s := by sorry

This theorem, named `SeparatedNhds.symm`, states that for any type `X` that has a topological space structure and any two subsets `s` and `t` of `X`, if `s` and `t` satisfy the `SeparatedNhds` predicate (i.e., there exist disjoint open sets `U` and `V` such that `s` is a subset of `U` and `t` is a subset of `V`), then `t` and `s` also satisfy the `SeparatedNhds` predicate. Essentially, it asserts that the `SeparatedNhds` property is symmetric: if `s` and `t` are separated by neighbourhoods, then so are `t` and `s`.

If subsets `s` and `t` of a topological space `X` are separated (i.e., there exist disjoint open sets containing each), then `s` and `t` are symmetrically separated.


theorem hasStrictFDerivAt_const :
    ∀ {𝕜 : 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] (c : F)
      (x : E), HasStrictFDerivAt (fun x => c) 0 x :=
  by sorry

This theorem states that for any non-trivially normed field 𝕜, normed additive commutative groups E and F, and normed spaces 𝕜 of E and F, a constant function (represented by a constant c of type F) has a strict Frechet derivative of 0 at any point x in E. In simple terms, it's saying that the rate of change (or derivative) of a constant function is always 0, which aligns with our intuitive understanding of derivatives in calculus.

For any normed field 𝕜, normed additive commutative groups E, and normed spaces 𝕜[E] and 𝕜[F], the constant function from E to F has a strict Frechet derivative equal to 0 at every point in E.


theorem PowerBasis.equivAdjoinSimple.proof_1 :
    ∀ {K : Type u_2} {L : Type u_1} [inst : Field K] [inst_1 : Field L] [inst_2 : Algebra K L] (pb : PowerBasis K L),
      IsIntegral K pb.gen :=
  by sorry

The theorem `PowerBasis.equivAdjoinSimple.proof_1` asserts that for any field `K`, any field `L`, and any algebra of `L` over `K` denoted by `Algebra K L`, if there's a power basis `pb : PowerBasis K L`, then the generator of the power basis, `pb.gen`, is an integral element over `K`. In other words, the generator of the power basis is a root of some monic polynomial with coefficients in `K`.

Given a field extension `L` over `K` with a power basis `pb` having generator `pb.gen`, the generator is an integral element over `K`, that is, it is a root of some monic polynomial with coefficients in `K`.


theorem PowerBasis.equivAdjoinSimple.proof_2 :
    ∀ {K : Type u_1} {L : Type u_2} [inst : Field K] [inst_1 : Field L] [inst_2 : Algebra K L] (pb : PowerBasis K L),
      minpoly K (IntermediateField.adjoin.powerBasis ⋯).gen = minpoly K pb.gen :=
  by sorry

This theorem states that for any given types 'K' and 'L' where 'K' is a field, 'L' is a field, and there's an algebra structure over 'K' and 'L', and given a power basis 'pb' over 'K' and 'L', the minimal polynomial of the generator of the power basis formed by adjoining an element to 'K' is the same as the minimal polynomial of the generator of the original power basis 'pb'. In other words, the process of creating a power basis by adjoining an element to a field doesn't change the minimal polynomial of the power basis generator.

Given fields K and L with an algebra structure, a power basis pb over K and L, and an element a adjoined to K, the minimal polynomials of the generators of the original and new power bases are equal.


/-- Cantor's intersection theorem for sequences indexed by `ℕ`:
the intersection of a decreasing sequence of nonempty compact closed sets is nonempty.  -/
theorem IsCompact.nonempty_iInter_of_sequence_nonempty_isCompact_isClosed :
    ∀ {X : Type u} [inst : TopologicalSpace X] (t : ℕ → Set X),
      (∀ (i : ℕ), t (i + 1) ⊆ t i) →
        (∀ (i : ℕ), Set.Nonempty (t i)) → IsCompact (t 0) → (∀ (i : ℕ), IsClosed (t i)) → Set.Nonempty (⋂ i, t i) :=
  by sorry

The theorem `IsCompact.nonempty_iInter_of_sequence_nonempty_isCompact_isClosed` is known as Cantor's intersection theorem for sequences indexed by ℕ (the set of natural numbers). It states that if we have a topological space `X` and a sequence of sets `t` indexed by the natural numbers (i.e., `t : ℕ → Set X`), where each set in the sequence is a subset of the previous one (i.e., `∀ (i : ℕ), t (i + 1) ⊆ t i`), and every set in the sequence is nonempty and closed, with the first set being compact (i.e., `∀ (i : ℕ), Set.Nonempty (t i)`, `IsCompact (t 0)`, and `∀ (i : ℕ), IsClosed (t i)`), then the intersection of all sets in the sequence is also nonempty (i.e., `Set.Nonempty (⋂ i, t i)`). This theorem is a fundamental result in topology, highlighting the peculiar properties of compact sets.

If `X` is a topological space, `t : ℕ → Set X` is a decreasing sequence of nonempty, closed, and compact sets in `X` with `t 0` compact, then their intersection is nonempty.


/-- The property of being a sheaf is preserved by isomorphism.  -/
theorem CategoryTheory.Presieve.isSheaf_iso :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {P : CategoryTheory.Functor Cᵒᵖ (Type w)}
      (J : CategoryTheory.GrothendieckTopology C) {P' : CategoryTheory.Functor Cᵒᵖ (Type w)},
      (P ≅ P') → CategoryTheory.Presieve.IsSheaf J P → CategoryTheory.Presieve.IsSheaf J P' :=
  by sorry

The theorem `CategoryTheory.Presieve.isSheaf_iso` states that the property of being a sheaf is preserved by isomorphism. In particular, it says that for a given category `C`, functor `P`, Grothendieck topology `J`, and another functor `P'`, if `P` is isomorphic to `P'` (denoted by `P ≅ P'` in Lean), then if `P` is a sheaf for the topology `J`, it follows that `P'` is also a sheaf for the topology `J`. In other words, isomorphism does not affect the sheaf property of a functor with respect to a given topology.

If functors `P` and `P'` are isomorphic in a category `C` with respect to a Grothendieck topology `J`, then `P` being a sheaf implies that `P'` is also a sheaf for `J`.


theorem SemiNormedGroupCat.explicitCokernelπ_desc :
    ∀ {X Y Z : SemiNormedGroupCat} {f : X ⟶ Y} {g : Y ⟶ Z} (w : CategoryTheory.CategoryStruct.comp f g = 0),
      CategoryTheory.CategoryStruct.comp (SemiNormedGroupCat.explicitCokernelπ f)
          (SemiNormedGroupCat.explicitCokernelDesc w) =
        g :=
  by sorry

The theorem `SemiNormedGroupCat.explicitCokernelπ_desc` states that for any three objects (X, Y, Z) in the category of seminormed abelian groups and any two morphisms f from X to Y and g from Y to Z, if the composition of f and g is zero, then the composition of the projection from Y to the explicit cokernel of f and the descent to the explicit cokernel is equal to g. In other words, for a sequence of morphisms in the category of seminormed abelian groups that becomes zero upon composition, the composition of the morphism's projection to its cokernel and the descent to the cokernel equals the original morphism. This theorem is part of the theory of cokernels in the context of category theory.

If the composition of morphisms f : X → Y and g : Y → Z in the category of seminormed abelian groups is zero, then the composition of the projection of f's cokernel and the descent to that cokernel equals g.


ContDiffWithinAt.mono

theorem ContDiffWithinAt.mono :
    ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {E : Type uE} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {F : Type uF} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {s : Set E}
      {f : E → F} {x : E} {n : ℕ∞}, ContDiffWithinAt 𝕜 n f s x → ∀ {t : Set E}, t ⊆ s → ContDiffWithinAt 𝕜 n f t x :=
  by sorry

This theorem states that if a function `f` is continuously differentiable within a set `s` at a point `x`, to any order `n` over a nontrivial normed field `𝕜`, then the function `f` is also continuously differentiable within any subset `t` of `s` at the same point `x`, to the same order `n`. Here, `E` and `F` are normed additively commutative groups under the field `𝕜`, and `f` is a function from `E` to `F`.

If a continuously differentiable function `f : E -> F` of order `n` over a normed field `𝕜` at a point `x` in a set `s`, then `f` is also continuously differentiable of order `n` at `x` in any subset `t` of `s`.


theorem MeasureTheory.NullMeasurableSet.exists_measurable_subset_ae_eq :
    ∀ {α : Type u_2} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} {s : Set α},
      MeasureTheory.NullMeasurableSet s μ → ∃ t ⊆ s, MeasurableSet t ∧ t =ᶠ[MeasureTheory.Measure.ae μ] s :=
  by sorry

This theorem states that for any type `α` equipped with a measure space `m0` and a measure `μ`, and for any set `s` of `α`, if `s` is a null measurable set with respect to `μ`, there exists a subset `t` of `s` such that `t` is a measurable set and `t` is almost everywhere equal to `s` with respect to the measure `μ`. In other words, every null measurable set can be approximated almost everywhere by a measurable set.

Given a measure space `(α, m0, μ)` and a null measurable set `s ⊆ α`, there exists a measurable set `t ∋ s` such that `μ(s \ t) = 0`.


theorem TopCat.Presheaf.SheafConditionEqualizerProducts.piInters.proof_1 :
    ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} C] [inst_1 : CategoryTheory.Limits.HasProducts C]
      {X : TopCat} (F : TopCat.Presheaf C X) {ι : Type u_1} (U : ι → TopologicalSpace.Opens ↑X),
      CategoryTheory.Limits.HasLimit (CategoryTheory.Discrete.functor fun p => F.obj (Opposite.op (U p.1 ⊓ U p.2))) :=
  by sorry

This theorem states that for any category `C` with products, any topological space `X`, any presheaf `F` of `C` on `X`, and any function `U` from an index set `ι` to the open sets of `X`, there is a limit in `C` for the functor from the discrete category on ι² to `C` that sends a pair `p` to the object of `F` corresponding to the intersection of `U p.1` and `U p.2`. In simpler terms, this is a condition for a presheaf `F` to be a sheaf in terms of equalizer products, stating that certain limits exist in the category.

For any category with products, given a topological space, a presheaf, and a function to its open sets, the presheaf is a sheaf if and only if it satisfies the condition that for any index set and any pair of elements, the limit of the functor sending a pair to the intersection of their images exists in the category.


theorem Cardinal.bddAbove_of_small : ∀ (s : Set Cardinal.{u}) [h : Small.{u, u + 1} ↑s], BddAbove s := by sorry

The theorem `Cardinal.bddAbove_of_small` states that for any set `s` of Cardinal numbers, if `s` is small (i.e., there exists an injection from `s` to a type in Universe `u`), then `s` is bounded above. In other words, there exists a cardinal number that serves as an upper bound for all the elements in the set `s`.

If a set `s` of Cardinal numbers is small, then it is bounded above.


theorem CircleDeg1Lift.translationNumber_pow :
    ∀ (f : CircleDeg1Lift) (n : ℕ),
      CircleDeg1Lift.translationNumber (f ^ n) = ↑n * CircleDeg1Lift.translationNumber f :=
  by sorry

The theorem `CircleDeg1Lift.translationNumber_pow` states that for any `CircleDeg1Lift` function `f` and any natural number `n`, the translation number of the `n`-th power of `f` is equal to `n` multiplied by the translation number of the original function `f`. In mathematical terms, if τ(f) denotes the translation number of function `f`, then for all `f : CircleDeg1Lift` and `n : ℕ`, we have τ(f^n) = n * τ(f).

The translation number of a `CircleDeg1Lift` function raised to the power of a natural number is equal to the product of that number and the translation number of the original function.


theorem Matrix.diagonal_mul :
    ∀ {m : Type u_2} {n : Type u_3} {α : Type v} [inst : NonUnitalNonAssocSemiring α] [inst_1 : Fintype m]
      [inst_2 : DecidableEq m] (d : m → α) (M : Matrix m n α) (i : m) (j : n),
      (Matrix.diagonal d * M) i j = d i * M i j :=
  by sorry

This theorem states that for any types `m`, `n`, and `α` where `α` is a non-unital non-associative semiring, `m` is a fintype, and `m` has decidable equality, and given a function `d` from `m` to `α`, a matrix `M` of type `Matrix m n α`, and elements `i` of `m` and `j` of `n`, the multiplication of the diagonal matrix created from `d` and `M` at the positions `i` and `j` is equal to the result of multiplying the `i-th` element of `d` and the element at position `i` and `j` of `M`. In mathematical terms, this theorem states that $(D * M)_{ij} = d_i * M_{ij}$, where $D$ is the diagonal matrix created from `d`.

For any non-unital non-associative semiring type `α`, fintype `m` with decidable equality, and function `d` from `m` to `α`, the diagonal matrix product of `d` and matrix `M` equals the element-wise product of the diagonal elements of `d` with the corresponding elements of `M`.


theorem Mathlib.Algebra.Homology.QuasiIso._auxLemma.4 :
    ∀ {ι : Type u_2} {C : Type u} [inst : CategoryTheory.Category.{v, u} C]
      [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] {c : ComplexShape ι} {K L : HomologicalComplex C c}
      (f : K ⟶ L) (i : ι) [inst_2 : HomologicalComplex.HasHomology K i] [inst_3 : HomologicalComplex.HasHomology L i],
      QuasiIsoAt f i = CategoryTheory.ShortComplex.QuasiIso ((HomologicalComplex.shortComplexFunctor C c i).map f) :=
  by sorry

This theorem states that for any type `ι`, any category `C` with zero morphisms, any `ComplexShape` `c`, any two `HomologicalComplex` `K` and `L` in the category `C` with shape `c`, a morphism `f` from `K` to `L`, and index `i`, if `K` has homology in degree `i` and `L` has homology in degree `i`, then the `QuasiIsoAt` of the morphism `f` at index `i` is equal to the quasi-isomorphism of the map of `f` under the action of the functor `shortComplexFunctor` at index `i`.

In other words, it asserts the equivalence between a quasi-isomorphism at a given index in a homological complex and the corresponding quasi-isomorphism in the associated short complex at that index.

For any type `ι`, category `C` with zero morphisms, `ComplexShape` `c`, `HomologicalComplex` `K` and `L` in `C` with shape `c`, morphism `f` from `K` to `L`, and index `i`, if `K` and `L` have homology in degree `i`, then `QuasiIsoAt i f` equals the quasi-isomorphism of `f` under `shortComplexFunctor` at index `i`.


theorem Mathlib.GroupTheory.Subgroup.Basic._auxLemma.72 :
    ∀ {G : Type u_1} [inst : AddGroup G] {N : Type u_5} [inst_1 : AddGroup N] {f : G →+ N} {K : AddSubgroup G} {y : N},
      (y ∈ AddSubgroup.map f K) = ∃ x ∈ K, f x = y :=
  by sorry

This theorem states that for all additively grouped types `G` and `N`, a function `f` from `G` to `N` that preserves the group structure (`G →+ N`), a subgroup `K` of `G`, and an element `y` of `N`, `y` is in the image of the subgroup `K` under the function `f` if and only if there exists an element `x` in `K` such that `f(x) = y`. This image is itself a subgroup of `N` as defined by the `AddSubgroup.map` function. This is essentially the definition of the image of a set under a function in the context of additive groups and their subgroups.

For any additive group `G`, subgroup `K` of `G`, function `f : G -> N` preserving the group structure, and `y` in `N`, `y` is in the image of `K` under `f` if and only if there exists an `x` in `K` such that `f(x) = y`, and the image `f[K]` is a subgroup of `N`.


theorem Mathlib.GroupTheory.Subgroup.Basic._auxLemma.71 :
    ∀ {G : Type u_1} [inst : Group G] {N : Type u_5} [inst_1 : Group N] {f : G →* N} {K : Subgroup G} {y : N},
      (y ∈ Subgroup.map f K) = ∃ x ∈ K, f x = y :=
  by sorry

This theorem states that for any groups `G` and `N`, a group homomorphism `f` from `G` to `N`, a subgroup `K` of `G`, and an element `y` of `N`, `y` is in the image of the subgroup `K` under the homomorphism `f` if and only if there exists an element `x` in `K` such that `f(x)` equals `y`. In other words, it characterizes the image of a subgroup under a group homomorphism in terms of the elements of the original subgroup and the homomorphism's action on them.

For any group homomorphism $f$ from group $G$ to group $N$, subgroup $K$ of $G$, and element $y$ in $N$, $y$ is in the image of $K$ under $f$ if and only if there exists an element $x$ in $K$ such that $f(x) = y$.


Set.Infinite.nonempty

theorem Set.Infinite.nonempty : ∀ {α : Type u} {s : Set α}, Set.Infinite s → Set.Nonempty s := by sorry

The theorem `Set.Infinite.nonempty` states that for any type `α` and any set `s` of type `α`, if `s` is infinite, then `s` is nonempty. In other words, if a set is not finite, it must contain at least one element.

If a set is infinite, then it is nonempty.


theorem UniqueFactorizationMonoid.normalizedFactors_mul :
    ∀ {α : Type u_1} [inst : CancelCommMonoidWithZero α] [inst_1 : NormalizationMonoid α]
      [inst_2 : UniqueFactorizationMonoid α] {x y : α},
      x ≠ 0 →
        y ≠ 0 →
          UniqueFactorizationMonoid.normalizedFactors (x * y) =
            UniqueFactorizationMonoid.normalizedFactors x + UniqueFactorizationMonoid.normalizedFactors y :=
  by sorry

This theorem states that for any type `α` that is a `CancelCommMonoidWithZero`, a `NormalizationMonoid`, and a `UniqueFactorizationMonoid`, and for any non-zero elements `x` and `y` of type `α`, the multiset of normalized prime factors of the product `x * y` is equal to the sum of the multisets of normalized prime factors of `x` and `y`. This reflects the fundamental property of prime factorization, stating that the prime factorization of a product is the concatenation of the prime factorizations of the factors, in the context of a `UniqueFactorizationMonoid`.

In a `CancelCommMonoidWithZero`, `NormalizationMonoid`, and `UniqueFactorizationMonoid` `α`, the multiset of normalized prime factors of the product of any two non-zero elements `x` and `y` is equal to the sum of the multisets of normalized prime factors of `x` and `y`.


theorem Mathlib.GroupTheory.Subgroup.Basic._auxLemma.19 :
    ∀ {G : Type u_1} [inst : AddGroup G] (K : AddSubgroup G) (x : G), (x ∈ K.toAddSubmonoid) = (x ∈ K) := by sorry

This theorem states that for any given additive group `G` and any additive subgroup `K` of `G`, an element `x` of `G` belongs to the additive submonoid generated by `K` if and only if `x` belongs to `K` itself. In other words, in the context of additive groups, the subset of `G` defined by `K` as a subgroup is the same as the subset defined by `K` as a submonoid.

An additive subgroup of an abelian group equals the additive submonoid generated by it.


theorem SmoothBumpFunction.support_eq_inter_preimage :
    ∀ {E : Type uE} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [inst_2 : FiniteDimensional ℝ E]
      {H : Type uH} [inst_3 : TopologicalSpace H] {I : ModelWithCorners ℝ E H} {M : Type uM}
      [inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] {c : M} (f : SmoothBumpFunction I c),
      Function.support ↑f = (chartAt H c).source ∩ ↑(extChartAt I c) ⁻¹' Metric.ball (↑(extChartAt I c) c) f.rOut :=
  by sorry

This theorem states that for any normed additively commutative group `E` that is a finite-dimensional real vector space, and any topological space `H`, given a model with corners `I` from the reals to `E` and `H`, and any topological space `M` that is a charted space over `H`, and any point `c` in `M`, for any smooth bump function `f` with model `I` and center `c`, the support of `f` (the set of points where `f` is not zero) is equal to the intersection of the source of the chart at `c` and the preimage under the extended chart at `c` of the open ball centered at the image under the extended chart at `c` of `c` with radius given by `f.rOut` (the radius at which `f` tapers off to zero).

For any smooth bump function `f` with model `I` and center `c` in a charted space `M` over a topological space `H`, the support of `f` equals the intersection of the source of the chart at `c` and the preimage under the extended chart at `c` of the open ball centered at the image of `c` with radius `f.rOut`.


theorem Primrec₂.of_eq :
    ∀ {α : Type u_1} {β : Type u_2} {σ : Type u_3} [inst : Primcodable α] [inst_1 : Primcodable β]
      [inst_2 : Primcodable σ] {f g : α → β → σ}, Primrec₂ f → (∀ (a : α) (b : β), f a b = g a b) → Primrec₂ g :=
  by sorry

The theorem `Primrec₂.of_eq` states that for any three types `α`, `β`, and `σ` where `α`, `β`, and `σ` are primitive recursive (i.e., we have instances of `Primcodable α`, `Primcodable β`, and `Primcodable σ`), if `f` and `g` are binary functions from `α` and `β` to `σ` such that `f` is primitive recursive (`Primrec₂ f`), and `g` is equal to `f` for all inputs `a` and `b` (from `α` and `β` respectively), then `g` is also primitive recursive (`Primrec₂ g`). In other words, if two binary functions are equal and one of them is primitive recursive, then the other one is also primitive recursive.

If two binary functions `f` and `g` from primitive recursive types to a primitive recursive type are equal, then both `f` and `g` are primitive recursive.


theorem ZFSet.mem_sInter : ∀ {x y : ZFSet}, ZFSet.Nonempty x → (y ∈ ⋂₀ x ↔ ∀ z ∈ x, y ∈ z) := by sorry

This theorem states that for any two Zermelo-Fraenkel (ZF) sets, `x` and `y`, if `x` is nonempty, then `y` is an element of the intersection of all the sets in `x` if and only if `y` is an element of every set `z` that is an element of `x`. Here, `⋂₀ x` represents the intersection of all sets within `x`.

For any nonempty set `x` in ZF, an element `y` belongs to the intersection of all sets in `x` if and only if it belongs to every set in `x`.


theorem Set.indicator_union_of_not_mem_inter :
    ∀ {α : Type u_1} {M : Type u_4} [inst : AddZeroClass M] {s t : Set α} {a : α},
      a ∉ s ∩ t → ∀ (f : α → M), Set.indicator (s ∪ t) f a = Set.indicator s f a + Set.indicator t f a :=
  by sorry

The theorem `Set.indicator_union_of_not_mem_inter` states that for any type `α` and `M` where `M` is an additive group, given two sets `s` and `t` of type `Set α`, and an element `a` of type `α`, if the element `a` does not belong to the intersection of the sets `s` and `t`, then for any function `f` from `α` to `M`, the indicator function of the union of the sets `s` and `t` applied to `a` equals the sum of the indicator function of `s` applied to `a` and the indicator function of `t` applied to `a`. In other words, the indicator of a union of two disjoint sets at a point is the sum of the indicators of the sets at that point.

If sets `s` and `t` have no common element `a`, then the indicator function of `s ∪ t` at `a` equals the sum of the indicator functions of `s` and `t` at `a`.


theorem FreeAlgebra.ι_def :
    ∀ (R : Type u_3) [inst : CommSemiring R] {X : Type u_4} (m : X),
      FreeAlgebra.ι R m = Quot.mk (FreeAlgebra.Rel R X) (FreeAlgebra.Pre.of m) :=
  by sorry

The theorem `FreeAlgebra.ι_def` states that for any commutative semiring `R` and any type `X`, the canonical function `FreeAlgebra.ι R` that takes an element `m` of `X` and maps it to an element of the free algebra of `X` over `R`, is equal to the function `Quot.mk` applied to the relation `FreeAlgebra.Rel R X` and `FreeAlgebra.Pre.of m`. Here, `Quot.mk` constructs a quotient type using the given relation and `FreeAlgebra.Pre.of m` constructs an element of the pre-algebra. In mathematical terms, this theorem specifies how elements from `X` are embedded into the free algebra.

The canonical embedding of an element from `X` into the free algebra over a commutative semiring `R` is equal to the quotient type construction using the relation `FreeAlgebra.Rel R X` and the pre-algebra element `FreeAlgebra.Pre.of m`.


FiniteField.card

theorem FiniteField.card :
    ∀ (K : Type u_1) [inst : Field K] [inst_1 : Fintype K] (p : ℕ) [inst : CharP K p],
      ∃ n, Nat.Prime p ∧ Fintype.card K = p ^ ↑n :=
  by sorry

The theorem `FiniteField.card` states that for any type `K` that has a field structure and is finite (i.e., has a finite number of elements), and for any natural number `p` that has the property of being the characteristic of `K`, there exists some natural number `n` such that `p` is prime and the number of elements in `K` (denoted `Fintype.card K`) equals `p` to the power `n`. In other words, the cardinality of a finite field is always a prime number raised to some power.

The cardinality of a finite field is a prime number raised to some power.


theorem Polynomial.leadingCoeff_C_mul_X_pow :
    ∀ {R : Type u} [inst : Semiring R] (a : R) (n : ℕ),
      Polynomial.leadingCoeff (Polynomial.C a * Polynomial.X ^ n) = a :=
  by sorry

This theorem states that for any semiring `R`, and for any element `a` from `R` and any natural number `n`, the leading coefficient of the polynomial obtained by multiplying the constant polynomial `a` with `X` raised to the power `n` is `a`. In other words, if you have a polynomial that is simply a constant times a power of `X`, the leading coefficient (the coefficient of the highest power of `X`) is just that constant.

For any semiring `R` and element `a` from `R`, the leading coefficient of the polynomial `a * X^n` is `a`.


/-- Composing on the left by a uniformly continuous function preserves
uniform convergence on a set  -/
theorem UniformContinuous.comp_tendstoUniformlyOn :
    ∀ {α : Type u} {β : Type v} {γ : Type w} {ι : Type x} [inst : UniformSpace β] {F : ι → α → β} {f : α → β}
      {s : Set α} {p : Filter ι} [inst_1 : UniformSpace γ] {g : β → γ},
      UniformContinuous g → TendstoUniformlyOn F f p s → TendstoUniformlyOn (fun i => g ∘ F i) (g ∘ f) p s :=
  by sorry

This theorem states that if we have a uniformly continuous function `g` from `β` to `γ`, and a sequence of functions `F` that converges uniformly on a set `s` to a limiting function `f` with respect to some filter `p`, then composing each function in the sequence `F` with `g` will also converge uniformly on the same set `s` to the function obtained by composing `f` with `g` with respect to the same filter `p`. This basically means that left composition preserves the property of uniform convergence on a set.

If `g` is uniformly continuous from `β` to `γ`, `F: Array α -> β` converges uniformly on set `s` to `f` with respect to filter `p`, then the composed functions `g ∘ F` converge uniformly on `s` to `g ∘ f` with respect to `p`.


theorem MonoidHom.range_top_iff_surjective :
    ∀ {G : Type u_1} [inst : Group G] {N : Type u_7} [inst_1 : Group N] {f : G →* N},
      MonoidHom.range f = ⊤ ↔ Function.Surjective ⇑f :=
  by sorry

This theorem states that for any given groups `G` and `N`, and any monoid homomorphism `f` from `G` to `N`, the range of `f` is equal to the entire group `N` (denoted by `⊤`) if and only if `f` is a surjective function. In other words, a monoid homomorphism from one group to another is surjective (every element in the target group is the image of some element in the source group) if and only if its range covers the entire target group.

A monoid homomorphism between groups is surjective if and only if its image equals the entire target group.


theorem Eq.congr_left : ∀ {α : Sort u_1} {x y z : α}, x = y → (x = z ↔ y = z) := by sorry

This theorem, `Eq.congr_left`, states that for any type `α` and any elements `x`, `y`, and `z` of type `α`, if `x` is equal to `y`, then `x` being equal to `z` is logically equivalent to `y` being equal to `z`. Essentially, it says that if we have two equivalent elements, we can interchange them in any equality relation without affecting the truth value of the relation.

If `x = y` then `x = z` if and only if `y = z`.


theorem fderiv_zero_of_not_differentiableAt :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {f : E → F}
      {x : E}, ¬DifferentiableAt 𝕜 f x → fderiv 𝕜 f x = 0 :=
  by sorry

This theorem states that for any non-trivially normed field `𝕜`, a normed add commutative group `E`, a normed space over `𝕜` and `E`, a normed add commutative group `F`, and a normed space over `𝕜` and `F`, if a function `f` from `E` to `F` is not differentiable at a point `x` in `E`, then the Frechet derivative (`fderiv`) of the function `f` at point `x` is zero.

If a function between two normed spaces is not differentiable at a point, then its Frechet derivative at that point is the zero mapping.


theorem Finsupp.erase_eq_update_zero :
    ∀ {α : Type u_1} {M : Type u_5} [inst : Zero M] (f : α →₀ M) (a : α), Finsupp.erase a f = Finsupp.update f a 0 := by
  sorry

This theorem states that for any types `α` and `M` where `M` has an instance of `Zero`, and for any finitely supported function `f` from `α` to `M`, and any value `a` from `α`, the operation of erasing `a` from `f` is identical to the operation of updating `f` at `a` with the value `0`. In other words, erasing `a` from the function `f` (making `f(a)` equal to `0`) is the same as explicitly updating `f(a)` to `0`.

For any type `α`, type `M` with `Zero` instance, finitely supported function `f:` `α` `->` `M`, and `a` `∈` `α`, erasing `a` from `f` (setting `f a` to `0`) is equivalent to updating `f` at `a` with `0` (`f.update a 0`).


theorem List.filter_eq_self : ∀ {α : Type u_1} {p : α → Bool} {l : List α}, List.filter p l = l ↔ ∀ a ∈ l, p a = true :=
  by sorry

The theorem `List.filter_eq_self` states that for any type `α`, any Boolean-valued function `p` on `α`, and any list `l` of elements of type `α`, the list obtained by filtering `l` with `p` is equal to `l` itself if and only if the function `p` returns `true` for all elements `a` in `l`. This means that every element of the list `l` satisfies the condition defined by the function `p`.

For any type `α`, list `l` of `α`, and Boolean-valued function `p` on `α`, `List.filter p l = l` if and only if `p a` holds for all `a` in `l`.


theorem Mathlib.MeasureTheory.Measure.Restrict._auxLemma.3 :
    ∀ {α : Type u_2} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} {s : Set α},
      (μ.restrict s = 0) = (↑↑μ s = 0) :=
  by sorry

This theorem pertains to the field of Measure Theory. For any type `α`, given a measurable space `m0` of this type, a measure `μ` on this measurable space, and a set `s` of the same type, the theorem states that the measure of the set `s` being restricted by `μ` equals zero if and only if the measure of the set `s` in `μ` is zero. In other words, the result of restricting the measure `μ` to the set `s` yields a zero measure if and only if the original measure of `s` under `μ` is zero.

For any measurable space `(α, m0)` and measure `μ`, a set `s` has zero measure under `μ` if and only if the restricted measure `μ | s` is the zero measure.


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

This theorem states that for any type `G` that forms a group, given any two elements `a` and `b` of the group, the product of the inverse of `a` and `b` equals the identity element (denoted by `1` in algebraic structures) if and only if `a` equals `b`. In other words, in a group, a number multiplied by its inverse results in the identity element.

In a group, for all elements `a` and `b`, `a * a⁻¹ = b * b⁻¹` if and only if `a = b`, where `*` denotes group multiplication and `⁻¹` denotes the inverse.


Submodule.Quotient.eq'

theorem Submodule.Quotient.eq' :
    ∀ {R : Type u_1} {M : Type u_2} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] (p : Submodule R M)
      {x y : M}, Submodule.Quotient.mk x = Submodule.Quotient.mk y ↔ -x + y ∈ p :=
  by sorry

The theorem `Submodule.Quotient.eq'` states that for any ring `R`, additive commutative group `M`, and `M` being a module over `R`, given a submodule `p` of `M`, and any two elements `x` and `y` of `M`, the equivalence class of `x` in the quotient module `M/p` is equal to the equivalence class of `y` if and only if the element `-x + y` belongs to the submodule `p`. This theorem encapsulates the fundamental property of quotient structures in module theory.

For any ring R, additive commutative group M, and submodule p of M, two elements x and y of M belong to the same equivalence class in M/p if and only if x - y belongs to p.


theorem Matrix.SpecialLinearGroup.coe_mul :
    ∀ {n : Type u} [inst : DecidableEq n] [inst_1 : Fintype n] {R : Type v} [inst_2 : CommRing R]
      (A B : Matrix.SpecialLinearGroup n R), ↑(A * B) = ↑A * ↑B :=
  by sorry

This theorem states that for any type `n` with decidable equality and finiteness, and any commutative ring `R`, the multiplication operation in the special linear group of `n` by `n` matrices with coefficients in `R` is compatible with the matrix multiplication. Specifically, if `A` and `B` are elements of the special linear group, then the matrix of the product `A * B` in the group is the same as the product of the matrices of `A` and `B`.

For any commutative ring R and type n with decidable equality and finiteness, the multiplication operation in the special linear group of n by n matrices over R preserves matrix multiplication.


theorem Denumerable.ofNat_of_decode :
    ∀ {α : Type u_1} [inst : Denumerable α] {n : ℕ} {b : α}, Encodable.decode n = some b → Denumerable.ofNat α n = b :=
  by sorry

This theorem, `Denumerable.ofNat_of_decode`, states that for every type `α` that has a `Denumerable` instance and for every natural number `n` and element `b` of type `α`, if the decoding of `n` yields `b` (i.e., `Encodable.decode n = some b`), then the `n`-th element of `α`, as indexed by the decoding, is indeed `b` (i.e., `Denumerable.ofNat α n = b`). This connects the behavior of the `Encodable.decode` function with the `Denumerable.ofNat` function and asserts that they are consistent in their indexing and decoding of elements in denumerable types.

For every denumerable type `α` and natural number `n` such that `Encodable.decode n = some b`, it holds that `Denumerable.ofNat α n = b`.


/-- If `n` has only one element, the determinant of an `n` by `n` matrix is just that element.
Although `Unique` implies `DecidableEq` and `Fintype`, the instances might
not be syntactically equal. Thus, we need to fill in the args explicitly.  -/
theorem Matrix.det_unique :
    ∀ {R : Type v} [inst : CommRing R] {n : Type u_3} [inst_1 : Unique n] [inst_2 : DecidableEq n] [inst_3 : Fintype n]
      (A : Matrix n n R), Matrix.det A = A default default :=
  by sorry

The theorem `Matrix.det_unique` states that if a type `n` has only one element (expressed by the `Unique n` condition), then the determinant of any `n` by `n` matrix (whose entries are elements of a commutative ring `R`) is just that single element of `n`. Specifically, for such a matrix `A`, `Matrix.det A = A default default`, where `default` is the unique element of `n`. Note that while the `Unique` condition implies `DecidableEq` and `Fintype`, these instances may not be syntactically identical, so they need to be provided explicitly.

If a square matrix over a commutative ring has determinant and its entries form a type with only one element, then the determinant equals that unique element.


theorem AddUnits.neg_add_cancel_right :
    ∀ {α : Type u} [inst : AddMonoid α] (a : α) (b : AddUnits α), a + ↑(-b) + ↑b = a := by sorry

This theorem, `AddUnits.neg_add_cancel_right`, states that for any type `α` that forms an additive monoid, and for any elements `a` of type `α` and `b` of type `AddUnits α` (which is a type of additive units), adding `a` to the additive inverse of `b` (represented by `-b`) and then adding `b` results in `a`. In the language of mathematics, this can be expressed as \(a + (-b) + b = a\). Essentially, it's stating that the "additive cancellation" property holds in this monoid.

For any additive monoid type `α` and its additive unit `b`, we have `a + (-b) = a` for all `a` in `α`.


theorem SymAlg.mul_def :
    ∀ {α : Type u_1} [inst : Add α] [inst_1 : Mul α] [inst_2 : One α] [inst_3 : OfNat α 2] [inst_4 : Invertible 2]
      (a b : αˢʸᵐ), a * b = SymAlg.sym (⅟2 * (SymAlg.unsym a * SymAlg.unsym b + SymAlg.unsym b * SymAlg.unsym a)) :=
  by sorry

This theorem states that for any type `α` that has addition, multiplication, a specified unity ("one"), a way to interpret the number 2, and an invertible 2, and any two elements `a` and `b` of the symbolic algebra of `α`, the product of `a` and `b` in the symbolic algebra is represented by the element of `α` which is the average (multiplied by the multiplicative inverse of 2) of the product of the elements represented by `a` and `b` and the product of the elements represented by `b` and `a`. In other words, in this symbolic algebra, multiplication is commutative and averaged.

For any commutative ring `α` with unity and invertible 2, the multiplication is distributive over averaging, that is, `(a * b) + (b * a) = (a + b) * (a ^ (-1) + b ^ (-1))` for all `a, b` in `α`.


Continuous.inner

theorem Continuous.inner :
    ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
      {α : Type u_4} [inst_3 : TopologicalSpace α] {f g : α → E},
      Continuous f → Continuous g → Continuous fun t => ⟪f t, g t⟫_𝕜 :=
  by sorry

This theorem states that for any field `𝕜` that behaves like real or complex numbers, and any normed add commutative group `E` that is also an inner product space over `𝕜`, if `f` and `g` are two continuous functions from a topological space `α` to `E`, then the function that maps any element `t` of `α` to the inner product of `f(t)` and `g(t)` in `𝕜` is also continuous.

For any continuous functions $f$ and $g$ from a topological space $\alpha$ to an inner product space $E$ over a field $\mathbb{F}$ that is also a normed additive commutative group, the function mapping $t \mapsto \langle f(t), g(t) \rangle_{\mathbb{F}}$ is continuous.


/-- The rank of the range of a linear map is at most the rank of the source.  -/
theorem lift_rank_range_le :
    ∀ {R : Type u} {M : Type v} {M' : Type v'} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : AddCommGroup M']
      [inst_3 : Module R M] [inst_4 : Module R M'] (f : M →ₗ[R] M'),
      Cardinal.lift.{v, v'} (Module.rank R ↥(LinearMap.range f)) ≤ Cardinal.lift.{v', v} (Module.rank R M) :=
  by sorry

This theorem states that for any given ring `R` and two additive commutative groups `M` and `M'` with `M` and `M'` being modules over `R`, and a linear map `f` from `M` to `M'`, the cardinality (or "rank" in terms of modules) of the image (or "range") of `f` is less than or equal to the cardinality (or "rank") of the source module `M`. In other words, the dimension of the image of a linear map is always less than or equal to the dimension of the domain. This is done by lifting the cardinalities to a common universe before comparing.

The cardinality of the image of a linear map between two finite-dimensional modules over a ring is less than or equal to the cardinality of the source module.


theorem Polynomial.eval₂_pow :
    ∀ {R : Type u} {S : Type v} [inst : Semiring R] {p : Polynomial R} [inst_1 : CommSemiring S] (f : R →+* S) (x : S)
      (n : ℕ), Polynomial.eval₂ f x (p ^ n) = Polynomial.eval₂ f x p ^ n :=
  by sorry

This theorem states that for any two types `R` and `S` with `R` being a semiring and `S` being a commutative semiring, given a ring homomorphism `f` from `R` to `S`, a value `x` in `S`, a polynomial `p` over `R`, and a natural number `n`, the evaluation of the `n`-th power of the polynomial `p` at `x` (using the ring homomorphism `f` to map the coefficients into `S`) is equal to the `n`-th power of the evaluation of `p` at `x`. In mathematical notation, if we denote the evaluation of a polynomial `p` at `x` with ring homomorphism `f` as `eval₂(f, x, p)`, then the theorem states that `eval₂(f, x, p^n) = eval₂(f, x, p)^n`.

For any semiring homomorphism \(f\) from semiring \(R\) to commutative semiring \(S\), and for any \(x \in S\), polynomial \(p \in R[\underline{x}]\), and natural number \(n\), we have \(f(p^n)(x) = (f(p))^n(x)\).


theorem Real.add_one_le_exp : ∀ (x : ℝ), x + 1 ≤ Real.exp x := by sorry

This theorem states that for all real numbers `x`, the sum of `x` and one is less than or equal to the exponential of `x`. In mathematical terms, it is saying that for all `x` in ℝ, `x + 1 ≤ exp(x)`.

For all real numbers x, the exponential function exp(x) is greater than or equal to the sum of x and 1: x + 1 ≤ exp(x). (Note: The original statement was incorrect, so I corrected it to reflect the actual theorem.)


theorem Mathlib.Data.Nat.PartENat._auxLemma.2 : ∀ (x : ℕ), (↑x).1 = True := by sorry

This theorem, `Mathlib.Data.Nat.PartENat._auxLemma.2`, states that for every natural number `x`, the first component (`.1`) of the coe function applied to `x` (`↑x`) is equal to `True`. In other words, this theorem asserts that a certain condition holds true for the first component of the coe function when it is applied to any natural number.

For every natural number `x`, the first component of the coe function of `x` is `True`. (or equivalently, the coe function of a natural number `x` is a pair where the first component is `True`)


theorem Subring.mem_sInf : ∀ {R : Type u} [inst : Ring R] {S : Set (Subring R)} {x : R}, x ∈ sInf S ↔ ∀ p ∈ S, x ∈ p :=
  by sorry

This theorem states that for any given type `R` that is a ring, a set `S` of subrings of `R`, and an element `x` from `R`, `x` is an element of the infimum (greatest lower bound) of `S` if and only if `x` is an element of every `p` in `S`. Essentially, it defines membership in the infimum of a set of subrings: an element belongs to the infimum of a set of subrings if it belongs to every subring in that set.

For any ring R, a subset S of subrings of R, and an element x in R, x lies in the infimum of S if and only if x belongs to every subring p in S.


AddGroup.isAddUnit

theorem AddGroup.isAddUnit : ∀ {α : Type u} [inst : AddGroup α] (a : α), IsAddUnit a := by sorry

This theorem states that for any type `α` which forms an additive group (denoted by `AddGroup α`), every element `a` of this type is an `AddUnit`. In mathematical terms, this means that every element of the additive group has a two-sided additive inverse, or simply put, for each element there exists another element such that their sum is the additive identity (typically zero).

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


theorem MeasurableSpace.induction_on_inter :
    ∀ {α : Type u_1} {C : Set α → Prop} {s : Set (Set α)} [m : MeasurableSpace α],
      m = MeasurableSpace.generateFrom s →
        IsPiSystem s →
          C ∅ →
            (∀ t ∈ s, C t) →
              (∀ (t : Set α), MeasurableSet t → C t → C tᶜ) →
                (∀ (f : ℕ → Set α),
                    Pairwise (Disjoint on f) → (∀ (i : ℕ), MeasurableSet (f i)) → (∀ (i : ℕ), C (f i)) → C (⋃ i, f i)) →
                  ∀ ⦃t : Set α⦄, MeasurableSet t → C t :=
  by sorry

This theorem states that, given a type `α`, a property `C` on subsets of `α`, and a set `s` of subsets of `α`, if the measurable space `m` is generated from `s`, `s` is a π-system, `C` holds for the empty set, and `C` holds for each subset in `s`, then the following properties hold:

1. For any subset `t` of `α`, if `t` is measurable and `C` holds for `t`, then `C` holds for the complement of `t`.
2. For any sequence `f` from natural numbers to subsets of `α` such that the images of different natural numbers are pairwise disjoint, if each subset in the sequence is measurable and `C` holds for each subset, then `C` holds for the union of the subsets in the sequence.

Under these conditions, the theorem finally asserts that for any measurable subset `t` of `α`, `C` holds for `t`. This theorem can be seen as an induction principle for proving properties of subsets in a generated measurable space that are closed under complement and countable unions.

Given a measurable space generated by a π-system `s` and a property `C` on subsets that holds for the empty set and all subsets in `s`, if `C` preserves complements and countable unions of pairwise disjoint sets, then `C` holds for any measurable subset of the space.


theorem norm_eq_sqrt_inner :
    ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
      (x : E), ‖x‖ = Real.sqrt (RCLike.re ⟪x, x⟫_𝕜) :=
  by sorry

This theorem states that for any type `𝕜` that behaves like a division ring (`RCLike 𝕜`), a normed additive commutative group `E`, and a inner product space `𝕜 E`, the norm of a vector `x` in `E` is equal to the square root of the real part of the inner product of `x` with itself. Specifically, `‖x‖ = sqrt(Re⟪x, x⟫)`, where `‖x‖` is the norm of `x`, `sqrt` is the square root function, `Re⟪x, x⟫` is the real part of the inner product of `x` with itself. This is a generalization of the Pythagorean theorem to inner product spaces.

For any normed additive commutative group `E` over a division ring `𝕜` with an inner product, the norm of a vector `x` equals the square root of the real part of its inner product with itself: `‖x‖ = sqrt(Re⟪x, x⟫)`.


theorem MeasureTheory.JordanDecomposition.smul_posPart :
    ∀ {α : Type u_1} [inst : MeasurableSpace α] (j : MeasureTheory.JordanDecomposition α) (r : NNReal),
      (r • j).posPart = r • j.posPart :=
  by sorry

This theorem, named 'MeasureTheory.JordanDecomposition.smul_posPart', states that for any measurable space `α`, given a Jordan Decomposition `j` of that space and a nonnegative real number `r`, the positive part of the scaled (by `r`) Jordan Decomposition `(r • j)` is equal to the scaled positive part of the original Jordan Decomposition `(r • j.posPart)`. In other words, scaling a Jordan Decomposition and taking the positive part is the same as taking the positive part first and then scaling.

For any measurable space `α`, given a Jordan Decomposition `j` and a nonnegative real number `r`, `r • j.posPart = (r • j).posPart`.


theorem Mathlib.Data.List.Basic._auxLemma.33 : ∀ {α : Sort u_1} {a b : α}, (a = b) = (b = a) := by sorry

This theorem asserts the principle of symmetry in equality for any sort of object. Specifically, it states that for any sort of object `α` and any two instances `a` and `b` of that sort, the proposition that `a` equals `b` is identical to the proposition that `b` equals `a`. In other words, equality is commutative; it doesn't matter in which order we compare two instances of a sort, the result will be the same.

For any type `α` and elements `a` and `b` of type `α`, the equality `a = b` is equivalent to `b = a`.


theorem Mathlib.Data.List.Basic._auxLemma.22 : ∀ {α : Type u}, Function.Injective List.reverse = True := by sorry

This theorem states that for any type `α`, the `List.reverse` function, which reverses a list, is injective. This means that if the reversed lists are equal, i.e., `List.reverse(as1) = List.reverse(as2)`, then the original lists must have been equal, i.e., `as1 = as2`, thus asserting the uniqueness of the input to the `List.reverse` function based on its output.

If `as1` and `as2` are lists of the same type `α`, then `List.reverse as1 = List.reverse as2` implies `as1 = as2`.


theorem Matrix.SpecialLinearGroup.coe_one :
    ∀ {n : Type u} [inst : DecidableEq n] [inst_1 : Fintype n] {R : Type v} [inst_2 : CommRing R], ↑1 = 1 := by sorry

This theorem states that for any type `n` with decidable equality and finiteness, and for any type `R` that forms a commutative ring, the canonical embedding (denoted by `↑`) of the multiplicative identity element `1` from `R` into matrix special linear group is equal to the identity matrix `1`.

For any commutative ring R and decidably finite type n with decidable equality, the canonical embedding of the multiplicative identity 1 in R into the special linear group SL(n R) is equal to the identity matrix 1.